Home | History | Annotate | Line # | Download | only in libcrypto
      1 /*
      2  * WARNING: do not edit!
      3  * Generated by Makefile from crypto/params_idx.c.in
      4  *
      5  * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved.
      6  *
      7  * Licensed under the Apache License 2.0 (the "License").  You may not use
      8  * this file except in compliance with the License.  You can obtain a copy
      9  * in the file LICENSE in the source distribution or at
     10  * https://www.openssl.org/source/license.html
     11  */
     12 
     13 
     14 #include "internal/e_os.h"
     15 #include "internal/param_names.h"
     16 #include <string.h>
     17 
     18 /* Machine generated TRIE -- generated by util/perl/OpenSSL/paramnames.pm */
     19 int ossl_param_find_pidx(const char *s)
     20 {
     21     switch(s[0]) {
     22     default:
     23         break;
     24     case 'a':
     25         switch(s[1]) {
     26         default:
     27             break;
     28         case 'c':
     29             if (strcmp("vp-info", s + 2) == 0)
     30                 return PIDX_KDF_PARAM_X942_ACVPINFO;
     31             break;
     32         case 'd':
     33             switch(s[2]) {
     34             default:
     35                 break;
     36             case 'd':
     37                 if (strcmp("itional-random", s + 3) == 0)
     38                     return PIDX_SIGNATURE_PARAM_ADD_RANDOM;
     39                 break;
     40             case '\0':
     41                 return PIDX_KDF_PARAM_ARGON2_AD;
     42             }
     43             break;
     44         case 'e':
     45             if (strcmp("ad", s + 2) == 0)
     46                 return PIDX_CIPHER_PARAM_AEAD;
     47             break;
     48         case 'l':
     49             switch(s[2]) {
     50             default:
     51                 break;
     52             case 'g':
     53                 switch(s[3]) {
     54                 default:
     55                     break;
     56                 case '_':
     57                     if (strcmp("id_param", s + 4) == 0)
     58                         return PIDX_CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD;
     59                     break;
     60                 case 'i':
     61                     if (strcmp("d-absent", s + 4) == 0)
     62                         return PIDX_DIGEST_PARAM_ALGID_ABSENT;
     63                     break;
     64                 case 'o':
     65                     switch(s[4]) {
     66                     default:
     67                         break;
     68                     case 'r':
     69                         switch(s[5]) {
     70                         default:
     71                             break;
     72                         case 'i':
     73                             switch(s[6]) {
     74                             default:
     75                                 break;
     76                             case 't':
     77                                 switch(s[7]) {
     78                                 default:
     79                                     break;
     80                                 case 'h':
     81                                     switch(s[8]) {
     82                                     default:
     83                                         break;
     84                                     case 'm':
     85                                         switch(s[9]) {
     86                                         default:
     87                                             break;
     88                                         case '-':
     89                                             switch(s[10]) {
     90                                             default:
     91                                                 break;
     92                                             case 'i':
     93                                                 switch(s[11]) {
     94                                                 default:
     95                                                     break;
     96                                                 case 'd':
     97                                                     switch(s[12]) {
     98                                                     default:
     99                                                         break;
    100                                                     case '-':
    101                                                         if (strcmp("params", s + 13) == 0)
    102                                                             return PIDX_ALG_PARAM_ALGORITHM_ID_PARAMS;
    103                                                         break;
    104                                                     case '\0':
    105                                                         return PIDX_ALG_PARAM_ALGORITHM_ID;
    106                                                     }
    107                                                 }
    108                                             }
    109                                         }
    110                                     }
    111                                 }
    112                             }
    113                         }
    114                     }
    115                 }
    116                 break;
    117             case 'i':
    118                 if (strcmp("as", s + 3) == 0)
    119                     return PIDX_STORE_PARAM_ALIAS;
    120             }
    121             break;
    122         case '\0':
    123             return PIDX_PKEY_PARAM_EC_A;
    124         }
    125         break;
    126     case 'b':
    127         switch(s[1]) {
    128         default:
    129             break;
    130         case 'a':
    131             if (strcmp("sis-type", s + 2) == 0)
    132                 return PIDX_PKEY_PARAM_EC_CHAR2_TYPE;
    133             break;
    134         case 'i':
    135             if (strcmp("ts", s + 2) == 0)
    136                 return PIDX_PKEY_PARAM_BITS;
    137             break;
    138         case 'l':
    139             switch(s[2]) {
    140             default:
    141                 break;
    142             case 'o':
    143                 switch(s[3]) {
    144                 default:
    145                     break;
    146                 case 'c':
    147                     switch(s[4]) {
    148                     default:
    149                         break;
    150                     case 'k':
    151                         switch(s[5]) {
    152                         default:
    153                             break;
    154                         case '-':
    155                             if (strcmp("size", s + 6) == 0)
    156                                 return PIDX_MAC_PARAM_BLOCK_SIZE;
    157                             break;
    158                         case '_':
    159                             if (strcmp("padding", s + 6) == 0)
    160                                 return PIDX_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING;
    161                             break;
    162                         case 's':
    163                             if (strcmp("ize", s + 6) == 0)
    164                                 return PIDX_DIGEST_PARAM_BLOCK_SIZE;
    165                         }
    166                     }
    167                 }
    168             }
    169             break;
    170         case 'u':
    171             if (strcmp("ildinfo", s + 2) == 0)
    172                 return PIDX_PROV_PARAM_BUILDINFO;
    173             break;
    174         case '\0':
    175             return PIDX_PKEY_PARAM_EC_B;
    176         }
    177         break;
    178     case 'c':
    179         switch(s[1]) {
    180         default:
    181             break;
    182         case '-':
    183             if (strcmp("rounds", s + 2) == 0)
    184                 return PIDX_MAC_PARAM_C_ROUNDS;
    185             break;
    186         case 'e':
    187             if (strcmp("kalg", s + 2) == 0)
    188                 return PIDX_KDF_PARAM_CEK_ALG;
    189             break;
    190         case 'i':
    191             if (strcmp("pher", s + 2) == 0)
    192                 return PIDX_ALG_PARAM_CIPHER;
    193             break;
    194         case 'o':
    195             switch(s[2]) {
    196             default:
    197                 break;
    198             case 'f':
    199                 if (strcmp("actor", s + 3) == 0)
    200                     return PIDX_PKEY_PARAM_EC_COFACTOR;
    201                 break;
    202             case 'n':
    203                 switch(s[3]) {
    204                 default:
    205                     break;
    206                 case 's':
    207                     if (strcmp("tant", s + 4) == 0)
    208                         return PIDX_KDF_PARAM_CONSTANT;
    209                     break;
    210                 case 't':
    211                     if (strcmp("ext-string", s + 4) == 0)
    212                         return PIDX_SIGNATURE_PARAM_CONTEXT_STRING;
    213                 }
    214             }
    215             break;
    216         case 't':
    217             switch(s[2]) {
    218             default:
    219                 break;
    220             case 's':
    221                 switch(s[3]) {
    222                 default:
    223                     break;
    224                 case '_':
    225                     if (strcmp("mode", s + 4) == 0)
    226                         return PIDX_CIPHER_PARAM_CTS_MODE;
    227                     break;
    228                 case '\0':
    229                     return PIDX_CIPHER_PARAM_CTS;
    230                 }
    231             }
    232             break;
    233         case 'u':
    234             switch(s[2]) {
    235             default:
    236                 break;
    237             case 's':
    238                 switch(s[3]) {
    239                 default:
    240                     break;
    241                 case 't':
    242                     switch(s[4]) {
    243                     default:
    244                         break;
    245                     case 'o':
    246                         switch(s[5]) {
    247                         default:
    248                             break;
    249                         case 'm':
    250                             switch(s[6]) {
    251                             default:
    252                                 break;
    253                             case '-':
    254                                 if (strcmp("iv", s + 7) == 0)
    255                                     return PIDX_CIPHER_PARAM_CUSTOM_IV;
    256                                 break;
    257                             case '\0':
    258                                 return PIDX_MAC_PARAM_CUSTOM;
    259                             }
    260                         }
    261                     }
    262                 }
    263             }
    264         }
    265         break;
    266     case 'd':
    267         switch(s[1]) {
    268         default:
    269             break;
    270         case '-':
    271             if (strcmp("rounds", s + 2) == 0)
    272                 return PIDX_MAC_PARAM_D_ROUNDS;
    273             break;
    274         case 'a':
    275             switch(s[2]) {
    276             default:
    277                 break;
    278             case 't':
    279                 switch(s[3]) {
    280                 default:
    281                     break;
    282                 case 'a':
    283                     switch(s[4]) {
    284                     default:
    285                         break;
    286                     case '-':
    287                         switch(s[5]) {
    288                         default:
    289                             break;
    290                         case 's':
    291                             if (strcmp("tructure", s + 6) == 0)
    292                                 return PIDX_OBJECT_PARAM_DATA_STRUCTURE;
    293                             break;
    294                         case 't':
    295                             if (strcmp("ype", s + 6) == 0)
    296                                 return PIDX_OBJECT_PARAM_DATA_TYPE;
    297                         }
    298                         break;
    299                     case '\0':
    300                         return PIDX_OBJECT_PARAM_DATA;
    301                     }
    302                 }
    303             }
    304             break;
    305         case 'e':
    306             switch(s[2]) {
    307             default:
    308                 break;
    309             case 'c':
    310                 switch(s[3]) {
    311                 default:
    312                     break;
    313                 case 'o':
    314                     if (strcmp("ded-from-explicit", s + 4) == 0)
    315                         return PIDX_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS;
    316                     break;
    317                 case 'r':
    318                     if (strcmp("ypt-only", s + 4) == 0)
    319                         return PIDX_CIPHER_PARAM_DECRYPT_ONLY;
    320                 }
    321                 break;
    322             case 'f':
    323                 if (strcmp("ault-digest", s + 3) == 0)
    324                     return PIDX_PKEY_PARAM_DEFAULT_DIGEST;
    325                 break;
    326             case 's':
    327                 if (strcmp("c", s + 3) == 0)
    328                     return PIDX_OBJECT_PARAM_DESC;
    329                 break;
    330             case 't':
    331                 if (strcmp("erministic", s + 3) == 0)
    332                     return PIDX_SIGNATURE_PARAM_DETERMINISTIC;
    333             }
    334             break;
    335         case 'h':
    336             if (strcmp("kem-ikm", s + 2) == 0)
    337                 return PIDX_PKEY_PARAM_DHKEM_IKM;
    338             break;
    339         case 'i':
    340             switch(s[2]) {
    341             default:
    342                 break;
    343             case 'g':
    344                 switch(s[3]) {
    345                 default:
    346                     break;
    347                 case 'e':
    348                     switch(s[4]) {
    349                     default:
    350                         break;
    351                     case 's':
    352                         switch(s[5]) {
    353                         default:
    354                             break;
    355                         case 't':
    356                             switch(s[6]) {
    357                             default:
    358                                 break;
    359                             case '-':
    360                                 switch(s[7]) {
    361                                 default:
    362                                     break;
    363                                 case 'c':
    364                                     if (strcmp("heck", s + 8) == 0)
    365                                         return PIDX_PKEY_PARAM_FIPS_DIGEST_CHECK;
    366                                     break;
    367                                 case 'n':
    368                                     if (strcmp("oinit", s + 8) == 0)
    369                                         return PIDX_MAC_PARAM_DIGEST_NOINIT;
    370                                     break;
    371                                 case 'o':
    372                                     if (strcmp("neshot", s + 8) == 0)
    373                                         return PIDX_MAC_PARAM_DIGEST_ONESHOT;
    374                                     break;
    375                                 case 'p':
    376                                     if (strcmp("rops", s + 8) == 0)
    377                                         return PIDX_ASYM_CIPHER_PARAM_OAEP_DIGEST_PROPS;
    378                                     break;
    379                                 case 's':
    380                                     if (strcmp("ize", s + 8) == 0)
    381                                         return PIDX_PKEY_PARAM_DIGEST_SIZE;
    382                                 }
    383                                 break;
    384                             case '\0':
    385                                 return PIDX_STORE_PARAM_DIGEST;
    386                             }
    387                         }
    388                     }
    389                 }
    390                 break;
    391             case 's':
    392                 if (strcmp("tid", s + 3) == 0)
    393                     return PIDX_PKEY_PARAM_DIST_ID;
    394             }
    395             break;
    396         case 'r':
    397             if (strcmp("bg-no-trunc-md", s + 2) == 0)
    398                 return PIDX_PROV_PARAM_DRBG_TRUNC_DIGEST;
    399             break;
    400         case 's':
    401             if (strcmp("a-sign-disabled", s + 2) == 0)
    402                 return PIDX_PROV_PARAM_DSA_SIGN_DISABLED;
    403             break;
    404         case '\0':
    405             return PIDX_PKEY_PARAM_RSA_D;
    406         }
    407         break;
    408     case 'e':
    409         switch(s[1]) {
    410         default:
    411             break;
    412         case 'a':
    413             if (strcmp("rly_clean", s + 2) == 0)
    414                 return PIDX_KDF_PARAM_EARLY_CLEAN;
    415             break;
    416         case 'c':
    417             switch(s[2]) {
    418             default:
    419                 break;
    420             case 'd':
    421                 switch(s[3]) {
    422                 default:
    423                     break;
    424                 case 'h':
    425                     switch(s[4]) {
    426                     default:
    427                         break;
    428                     case '-':
    429                         switch(s[5]) {
    430                         default:
    431                             break;
    432                         case 'c':
    433                             switch(s[6]) {
    434                             default:
    435                                 break;
    436                             case 'o':
    437                                 switch(s[7]) {
    438                                 default:
    439                                     break;
    440                                 case 'f':
    441                                     switch(s[8]) {
    442                                     default:
    443                                         break;
    444                                     case 'a':
    445                                         switch(s[9]) {
    446                                         default:
    447                                             break;
    448                                         case 'c':
    449                                             switch(s[10]) {
    450                                             default:
    451                                                 break;
    452                                             case 't':
    453                                                 switch(s[11]) {
    454                                                 default:
    455                                                     break;
    456                                                 case 'o':
    457                                                     switch(s[12]) {
    458                                                     default:
    459                                                         break;
    460                                                     case 'r':
    461                                                         switch(s[13]) {
    462                                                         default:
    463                                                             break;
    464                                                         case '-':
    465                                                             switch(s[14]) {
    466                                                             default:
    467                                                                 break;
    468                                                             case 'c':
    469                                                                 if (strcmp("heck", s + 15) == 0)
    470                                                                     return PIDX_PROV_PARAM_ECDH_COFACTOR_CHECK;
    471                                                                 break;
    472                                                             case 'm':
    473                                                                 if (strcmp("ode", s + 15) == 0)
    474                                                                     return PIDX_EXCHANGE_PARAM_EC_ECDH_COFACTOR_MODE;
    475                                                             }
    476                                                         }
    477                                                     }
    478                                                 }
    479                                             }
    480                                         }
    481                                     }
    482                                 }
    483                             }
    484                         }
    485                     }
    486                 }
    487             }
    488             break;
    489         case 'm':
    490             if (strcmp("s_check", s + 2) == 0)
    491                 return PIDX_KDF_PARAM_FIPS_EMS_CHECK;
    492             break;
    493         case 'n':
    494             switch(s[2]) {
    495             default:
    496                 break;
    497             case 'c':
    498                 switch(s[3]) {
    499                 default:
    500                     break;
    501                 case 'o':
    502                     switch(s[4]) {
    503                     default:
    504                         break;
    505                     case 'd':
    506                         switch(s[5]) {
    507                         default:
    508                             break;
    509                         case 'e':
    510                             if (strcmp("d-pub-key", s + 6) == 0)
    511                                 return PIDX_PKEY_PARAM_ENCODED_PUBLIC_KEY;
    512                             break;
    513                         case 'i':
    514                             if (strcmp("ng", s + 6) == 0)
    515                                 return PIDX_PKEY_PARAM_EC_ENCODING;
    516                         }
    517                     }
    518                     break;
    519                 case 'r':
    520                     switch(s[4]) {
    521                     default:
    522                         break;
    523                     case 'y':
    524                         switch(s[5]) {
    525                         default:
    526                             break;
    527                         case 'p':
    528                             switch(s[6]) {
    529                             default:
    530                                 break;
    531                             case 't':
    532                                 switch(s[7]) {
    533                                 default:
    534                                     break;
    535                                 case '-':
    536                                     switch(s[8]) {
    537                                     default:
    538                                         break;
    539                                     case 'c':
    540                                         if (strcmp("heck", s + 9) == 0)
    541                                             return PIDX_CIPHER_PARAM_FIPS_ENCRYPT_CHECK;
    542                                         break;
    543                                     case 'l':
    544                                         if (strcmp("evel", s + 9) == 0)
    545                                             return PIDX_ENCODER_PARAM_ENCRYPT_LEVEL;
    546                                     }
    547                                 }
    548                             }
    549                         }
    550                     }
    551                 }
    552                 break;
    553             case 'g':
    554                 if (strcmp("ine", s + 3) == 0)
    555                     return PIDX_ALG_PARAM_ENGINE;
    556                 break;
    557             case 't':
    558                 switch(s[3]) {
    559                 default:
    560                     break;
    561                 case 'r':
    562                     switch(s[4]) {
    563                     default:
    564                         break;
    565                     case 'o':
    566                         switch(s[5]) {
    567                         default:
    568                             break;
    569                         case 'p':
    570                             switch(s[6]) {
    571                             default:
    572                                 break;
    573                             case 'y':
    574                                 switch(s[7]) {
    575                                 default:
    576                                     break;
    577                                 case '_':
    578                                     if (strcmp("required", s + 8) == 0)
    579                                         return PIDX_DRBG_PARAM_ENTROPY_REQUIRED;
    580                                     break;
    581                                 case '\0':
    582                                     return PIDX_KDF_PARAM_HMACDRBG_ENTROPY;
    583                                 }
    584                             }
    585                         }
    586                     }
    587                 }
    588             }
    589             break;
    590         case '\0':
    591             return PIDX_PKEY_PARAM_RSA_E;
    592             break;
    593         case 'x':
    594             if (strcmp("pect", s + 2) == 0)
    595                 return PIDX_STORE_PARAM_EXPECT;
    596         }
    597         break;
    598     case 'f':
    599         switch(s[1]) {
    600         default:
    601             break;
    602         case 'i':
    603             switch(s[2]) {
    604             default:
    605                 break;
    606             case 'e':
    607                 if (strcmp("ld-type", s + 3) == 0)
    608                     return PIDX_PKEY_PARAM_EC_FIELD_TYPE;
    609                 break;
    610             case 'n':
    611                 if (strcmp("gerprint", s + 3) == 0)
    612                     return PIDX_STORE_PARAM_FINGERPRINT;
    613                 break;
    614             case 'p':
    615                 if (strcmp("s-indicator", s + 3) == 0)
    616                     return PIDX_ALG_PARAM_FIPS_APPROVED_INDICATOR;
    617             }
    618         }
    619         break;
    620     case 'g':
    621         switch(s[1]) {
    622         default:
    623             break;
    624         case 'e':
    625             switch(s[2]) {
    626             default:
    627                 break;
    628             case 'n':
    629                 switch(s[3]) {
    630                 default:
    631                     break;
    632                 case 'e':
    633                     switch(s[4]) {
    634                     default:
    635                         break;
    636                     case 'r':
    637                         switch(s[5]) {
    638                         default:
    639                             break;
    640                         case 'a':
    641                             switch(s[6]) {
    642                             default:
    643                                 break;
    644                             case 't':
    645                                 switch(s[7]) {
    646                                 default:
    647                                     break;
    648                                 case 'e':
    649                                     switch(s[8]) {
    650                                     default:
    651                                         break;
    652                                     case '\0':
    653                                         return PIDX_RAND_PARAM_GENERATE;
    654                                     }
    655                                     break;
    656                                 case 'o':
    657                                     if (strcmp("r", s + 8) == 0)
    658                                         return PIDX_PKEY_PARAM_EC_GENERATOR;
    659                                 }
    660                             }
    661                         }
    662                     }
    663                 }
    664             }
    665             break;
    666         case 'i':
    667             if (strcmp("ndex", s + 2) == 0)
    668                 return PIDX_PKEY_PARAM_FFC_GINDEX;
    669             break;
    670         case 'r':
    671             switch(s[2]) {
    672             default:
    673                 break;
    674             case 'o':
    675                 switch(s[3]) {
    676                 default:
    677                     break;
    678                 case 'u':
    679                     switch(s[4]) {
    680                     default:
    681                         break;
    682                     case 'p':
    683                         switch(s[5]) {
    684                         default:
    685                             break;
    686                         case '-':
    687                             if (strcmp("check", s + 6) == 0)
    688                                 return PIDX_PKEY_PARAM_EC_GROUP_CHECK_TYPE;
    689                             break;
    690                         case '\0':
    691                             return PIDX_PKEY_PARAM_GROUP_NAME;
    692                         }
    693                     }
    694                 }
    695             }
    696             break;
    697         case '\0':
    698             return PIDX_PKEY_PARAM_FFC_G;
    699         }
    700         break;
    701     case 'h':
    702         switch(s[1]) {
    703         default:
    704             break;
    705         case 'a':
    706             if (strcmp("s-randkey", s + 2) == 0)
    707                 return PIDX_CIPHER_PARAM_HAS_RAND_KEY;
    708             break;
    709         case 'i':
    710             if (strcmp("ndex", s + 2) == 0)
    711                 return PIDX_PKEY_PARAM_FFC_H;
    712             break;
    713         case 'k':
    714             switch(s[2]) {
    715             default:
    716                 break;
    717             case 'd':
    718                 switch(s[3]) {
    719                 default:
    720                     break;
    721                 case 'f':
    722                     switch(s[4]) {
    723                     default:
    724                         break;
    725                     case '-':
    726                         switch(s[5]) {
    727                         default:
    728                             break;
    729                         case 'd':
    730                             if (strcmp("igest-check", s + 6) == 0)
    731                                 return PIDX_PROV_PARAM_HKDF_DIGEST_CHECK;
    732                             break;
    733                         case 'k':
    734                             if (strcmp("ey-check", s + 6) == 0)
    735                                 return PIDX_PROV_PARAM_HKDF_KEY_CHECK;
    736                         }
    737                     }
    738                 }
    739             }
    740             break;
    741         case 'm':
    742             if (strcmp("ac-key-check", s + 2) == 0)
    743                 return PIDX_PROV_PARAM_HMAC_KEY_CHECK;
    744             break;
    745         case 's':
    746             if (strcmp("_padding", s + 2) == 0)
    747                 return PIDX_LIBSSL_RECORD_LAYER_PARAM_HS_PADDING;
    748         }
    749         break;
    750     case 'i':
    751         switch(s[1]) {
    752         default:
    753             break;
    754         case 'd':
    755             switch(s[2]) {
    756             default:
    757                 break;
    758             case '\0':
    759                 return PIDX_KDF_PARAM_PKCS12_ID;
    760             }
    761             break;
    762         case 'k':
    763             if (strcmp("me", s + 2) == 0)
    764                 return PIDX_KEM_PARAM_IKME;
    765             break;
    766         case 'm':
    767             if (strcmp("plicit-rejection", s + 2) == 0)
    768                 return PIDX_PKEY_PARAM_IMPLICIT_REJECTION;
    769             break;
    770         case 'n':
    771             switch(s[2]) {
    772             default:
    773                 break;
    774             case 'c':
    775                 if (strcmp("lude-public", s + 3) == 0)
    776                     return PIDX_PKEY_PARAM_EC_INCLUDE_PUBLIC;
    777                 break;
    778             case 'f':
    779                 if (strcmp("o", s + 3) == 0)
    780                     return PIDX_PASSPHRASE_PARAM_INFO;
    781                 break;
    782             case 'p':
    783                 if (strcmp("ut-type", s + 3) == 0)
    784                     return PIDX_STORE_PARAM_INPUT_TYPE;
    785                 break;
    786             case 's':
    787                 if (strcmp("tance", s + 3) == 0)
    788                     return PIDX_SIGNATURE_PARAM_INSTANCE;
    789             }
    790             break;
    791         case 't':
    792             switch(s[2]) {
    793             default:
    794                 break;
    795             case 'e':
    796                 switch(s[3]) {
    797                 default:
    798                     break;
    799                 case 'r':
    800                     switch(s[4]) {
    801                     default:
    802                         break;
    803                     case 'a':
    804                         if (strcmp("tion", s + 5) == 0)
    805                             return PIDX_GEN_PARAM_ITERATION;
    806                         break;
    807                     case '\0':
    808                         return PIDX_KDF_PARAM_ITER;
    809                     }
    810                 }
    811             }
    812             break;
    813         case 'v':
    814             switch(s[2]) {
    815             default:
    816                 break;
    817             case '-':
    818                 if (strcmp("generated", s + 3) == 0)
    819                     return PIDX_CIPHER_PARAM_AEAD_IV_GENERATED;
    820                 break;
    821             case 'l':
    822                 if (strcmp("en", s + 3) == 0)
    823                     return PIDX_CIPHER_PARAM_IVLEN;
    824                 break;
    825             case '\0':
    826                 return PIDX_MAC_PARAM_IV;
    827             }
    828         }
    829         break;
    830     case 'j':
    831         switch(s[1]) {
    832         default:
    833             break;
    834         case '\0':
    835             return PIDX_PKEY_PARAM_FFC_COFACTOR;
    836         }
    837         break;
    838     case 'k':
    839         switch(s[1]) {
    840         default:
    841             break;
    842         case '1':
    843             switch(s[2]) {
    844             default:
    845                 break;
    846             case '\0':
    847                 return PIDX_PKEY_PARAM_EC_CHAR2_PP_K1;
    848             }
    849             break;
    850         case '2':
    851             switch(s[2]) {
    852             default:
    853                 break;
    854             case '\0':
    855                 return PIDX_PKEY_PARAM_EC_CHAR2_PP_K2;
    856             }
    857             break;
    858         case '3':
    859             switch(s[2]) {
    860             default:
    861                 break;
    862             case '\0':
    863                 return PIDX_PKEY_PARAM_EC_CHAR2_PP_K3;
    864             }
    865             break;
    866         case 'a':
    867             if (strcmp("t", s + 2) == 0)
    868                 return PIDX_SIGNATURE_PARAM_KAT;
    869             break;
    870         case 'b':
    871             if (strcmp("kdf-key-check", s + 2) == 0)
    872                 return PIDX_PROV_PARAM_KBKDF_KEY_CHECK;
    873             break;
    874         case 'd':
    875             switch(s[2]) {
    876             default:
    877                 break;
    878             case 'f':
    879                 switch(s[3]) {
    880                 default:
    881                     break;
    882                 case '-':
    883                     switch(s[4]) {
    884                     default:
    885                         break;
    886                     case 'd':
    887                         switch(s[5]) {
    888                         default:
    889                             break;
    890                         case 'i':
    891                             switch(s[6]) {
    892                             default:
    893                                 break;
    894                             case 'g':
    895                                 switch(s[7]) {
    896                                 default:
    897                                     break;
    898                                 case 'e':
    899                                     switch(s[8]) {
    900                                     default:
    901                                         break;
    902                                     case 's':
    903                                         switch(s[9]) {
    904                                         default:
    905                                             break;
    906                                         case 't':
    907                                             switch(s[10]) {
    908                                             default:
    909                                                 break;
    910                                             case '-':
    911                                                 if (strcmp("props", s + 11) == 0)
    912                                                     return PIDX_EXCHANGE_PARAM_KDF_DIGEST_PROPS;
    913                                                 break;
    914                                             case '\0':
    915                                                 return PIDX_EXCHANGE_PARAM_KDF_DIGEST;
    916                                             }
    917                                         }
    918                                     }
    919                                 }
    920                             }
    921                         }
    922                         break;
    923                     case 'o':
    924                         if (strcmp("utlen", s + 5) == 0)
    925                             return PIDX_EXCHANGE_PARAM_KDF_OUTLEN;
    926                         break;
    927                     case 't':
    928                         if (strcmp("ype", s + 5) == 0)
    929                             return PIDX_EXCHANGE_PARAM_KDF_TYPE;
    930                         break;
    931                     case 'u':
    932                         if (strcmp("km", s + 5) == 0)
    933                             return PIDX_EXCHANGE_PARAM_KDF_UKM;
    934                     }
    935                 }
    936             }
    937             break;
    938         case 'e':
    939             switch(s[2]) {
    940             default:
    941                 break;
    942             case 'y':
    943                 switch(s[3]) {
    944                 default:
    945                     break;
    946                 case '-':
    947                     switch(s[4]) {
    948                     default:
    949                         break;
    950                     case 'c':
    951                         if (strcmp("heck", s + 5) == 0)
    952                             return PIDX_PKEY_PARAM_FIPS_KEY_CHECK;
    953                         break;
    954                     case 'l':
    955                         if (strcmp("ength", s + 5) == 0)
    956                             return PIDX_SKEY_PARAM_KEY_LENGTH;
    957                     }
    958                     break;
    959                 case 'b':
    960                     if (strcmp("its", s + 4) == 0)
    961                         return PIDX_CIPHER_PARAM_RC2_KEYBITS;
    962                     break;
    963                 case 'l':
    964                     if (strcmp("en", s + 4) == 0)
    965                         return PIDX_CIPHER_PARAM_KEYLEN;
    966                     break;
    967                 case '\0':
    968                     return PIDX_MAC_PARAM_KEY;
    969                 }
    970             }
    971             break;
    972         case 'm':
    973             if (strcmp("ac-key-check", s + 2) == 0)
    974                 return PIDX_PROV_PARAM_KMAC_KEY_CHECK;
    975         }
    976         break;
    977     case 'l':
    978         switch(s[1]) {
    979         default:
    980             break;
    981         case 'a':
    982             switch(s[2]) {
    983             default:
    984                 break;
    985             case 'b':
    986                 if (strcmp("el", s + 3) == 0)
    987                     return PIDX_KDF_PARAM_LABEL;
    988                 break;
    989             case 'n':
    990                 if (strcmp("es", s + 3) == 0)
    991                     return PIDX_KDF_PARAM_ARGON2_LANES;
    992             }
    993         }
    994         break;
    995     case 'm':
    996         switch(s[1]) {
    997         default:
    998             break;
    999         case 'a':
   1000             switch(s[2]) {
   1001             default:
   1002                 break;
   1003             case 'c':
   1004                 switch(s[3]) {
   1005                 default:
   1006                     break;
   1007                 case 'k':
   1008                     if (strcmp("ey", s + 4) == 0)
   1009                         return PIDX_CIPHER_PARAM_AEAD_MAC_KEY;
   1010                     break;
   1011                 case 'l':
   1012                     if (strcmp("en", s + 4) == 0)
   1013                         return PIDX_KDF_PARAM_MAC_SIZE;
   1014                     break;
   1015                 case '\0':
   1016                     return PIDX_ALG_PARAM_MAC;
   1017                 }
   1018                 break;
   1019             case 'n':
   1020                 if (strcmp("datory-digest", s + 3) == 0)
   1021                     return PIDX_PKEY_PARAM_MANDATORY_DIGEST;
   1022                 break;
   1023             case 'x':
   1024                 switch(s[3]) {
   1025                 default:
   1026                     break;
   1027                 case '-':
   1028                     if (strcmp("size", s + 4) == 0)
   1029                         return PIDX_PKEY_PARAM_MAX_SIZE;
   1030                     break;
   1031                 case '_':
   1032                     switch(s[4]) {
   1033                     default:
   1034                         break;
   1035                     case 'a':
   1036                         if (strcmp("dinlen", s + 5) == 0)
   1037                             return PIDX_DRBG_PARAM_MAX_ADINLEN;
   1038                         break;
   1039                     case 'e':
   1040                         switch(s[5]) {
   1041                         default:
   1042                             break;
   1043                         case 'a':
   1044                             if (strcmp("rly_data", s + 6) == 0)
   1045                                 return PIDX_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA;
   1046                             break;
   1047                         case 'n':
   1048                             if (strcmp("tropylen", s + 6) == 0)
   1049                                 return PIDX_DRBG_PARAM_MAX_ENTROPYLEN;
   1050                         }
   1051                         break;
   1052                     case 'f':
   1053                         if (strcmp("rag_len", s + 5) == 0)
   1054                             return PIDX_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN;
   1055                         break;
   1056                     case 'n':
   1057                         if (strcmp("oncelen", s + 5) == 0)
   1058                             return PIDX_DRBG_PARAM_MAX_NONCELEN;
   1059                         break;
   1060                     case 'p':
   1061                         if (strcmp("erslen", s + 5) == 0)
   1062                             return PIDX_DRBG_PARAM_MAX_PERSLEN;
   1063                         break;
   1064                     case 'r':
   1065                         if (strcmp("equest", s + 5) == 0)
   1066                             return PIDX_RAND_PARAM_MAX_REQUEST;
   1067                     }
   1068                     break;
   1069                 case 'i':
   1070                     if (strcmp("um_length", s + 4) == 0)
   1071                         return PIDX_DRBG_PARAM_MAX_LENGTH;
   1072                     break;
   1073                 case 'm':
   1074                     if (strcmp("em_bytes", s + 4) == 0)
   1075                         return PIDX_KDF_PARAM_SCRYPT_MAXMEM;
   1076                 }
   1077             }
   1078             break;
   1079         case 'e':
   1080             switch(s[2]) {
   1081             default:
   1082                 break;
   1083             case 'm':
   1084                 if (strcmp("cost", s + 3) == 0)
   1085                     return PIDX_KDF_PARAM_ARGON2_MEMCOST;
   1086                 break;
   1087             case 's':
   1088                 if (strcmp("sage-encoding", s + 3) == 0)
   1089                     return PIDX_SIGNATURE_PARAM_MESSAGE_ENCODING;
   1090             }
   1091             break;
   1092         case 'g':
   1093             switch(s[2]) {
   1094             default:
   1095                 break;
   1096             case 'f':
   1097                 switch(s[3]) {
   1098                 default:
   1099                     break;
   1100                 case '1':
   1101                     switch(s[4]) {
   1102                     default:
   1103                         break;
   1104                     case '-':
   1105                         switch(s[5]) {
   1106                         default:
   1107                             break;
   1108                         case 'd':
   1109                             if (strcmp("igest", s + 6) == 0)
   1110                                 return PIDX_PKEY_PARAM_MGF1_DIGEST;
   1111                             break;
   1112                         case 'p':
   1113                             if (strcmp("roperties", s + 6) == 0)
   1114                                 return PIDX_PKEY_PARAM_MGF1_PROPERTIES;
   1115                         }
   1116                     }
   1117                     break;
   1118                 case '\0':
   1119                     return PIDX_PKEY_PARAM_MASKGENFUNC;
   1120                 }
   1121             }
   1122             break;
   1123         case 'i':
   1124             switch(s[2]) {
   1125             default:
   1126                 break;
   1127             case 'c':
   1128                 if (strcmp("alg", s + 3) == 0)
   1129                     return PIDX_DIGEST_PARAM_MICALG;
   1130                 break;
   1131             case 'n':
   1132                 switch(s[3]) {
   1133                 default:
   1134                     break;
   1135                 case '_':
   1136                     switch(s[4]) {
   1137                     default:
   1138                         break;
   1139                     case 'e':
   1140                         if (strcmp("ntropylen", s + 5) == 0)
   1141                             return PIDX_DRBG_PARAM_MIN_ENTROPYLEN;
   1142                         break;
   1143                     case 'n':
   1144                         if (strcmp("oncelen", s + 5) == 0)
   1145                             return PIDX_DRBG_PARAM_MIN_NONCELEN;
   1146                     }
   1147                     break;
   1148                 case 'i':
   1149                     if (strcmp("um_length", s + 4) == 0)
   1150                         return PIDX_DRBG_PARAM_MIN_LENGTH;
   1151                 }
   1152             }
   1153             break;
   1154         case 'l':
   1155             switch(s[2]) {
   1156             default:
   1157                 break;
   1158             case '-':
   1159                 switch(s[3]) {
   1160                 default:
   1161                     break;
   1162                 case 'd':
   1163                     switch(s[4]) {
   1164                     default:
   1165                         break;
   1166                     case 's':
   1167                         switch(s[5]) {
   1168                         default:
   1169                             break;
   1170                         case 'a':
   1171                             switch(s[6]) {
   1172                             default:
   1173                                 break;
   1174                             case '.':
   1175                                 switch(s[7]) {
   1176                                 default:
   1177                                     break;
   1178                                 case 'i':
   1179                                     if (strcmp("nput_formats", s + 8) == 0)
   1180                                         return PIDX_PKEY_PARAM_ML_DSA_INPUT_FORMATS;
   1181                                     break;
   1182                                 case 'o':
   1183                                     if (strcmp("utput_formats", s + 8) == 0)
   1184                                         return PIDX_PKEY_PARAM_ML_DSA_OUTPUT_FORMATS;
   1185                                     break;
   1186                                 case 'p':
   1187                                     if (strcmp("refer_seed", s + 8) == 0)
   1188                                         return PIDX_PKEY_PARAM_ML_DSA_PREFER_SEED;
   1189                                     break;
   1190                                 case 'r':
   1191                                     if (strcmp("etain_seed", s + 8) == 0)
   1192                                         return PIDX_PKEY_PARAM_ML_DSA_RETAIN_SEED;
   1193                                 }
   1194                             }
   1195                         }
   1196                     }
   1197                     break;
   1198                 case 'k':
   1199                     switch(s[4]) {
   1200                     default:
   1201                         break;
   1202                     case 'e':
   1203                         switch(s[5]) {
   1204                         default:
   1205                             break;
   1206                         case 'm':
   1207                             switch(s[6]) {
   1208                             default:
   1209                                 break;
   1210                             case '.':
   1211                                 switch(s[7]) {
   1212                                 default:
   1213                                     break;
   1214                                 case 'i':
   1215                                     switch(s[8]) {
   1216                                     default:
   1217                                         break;
   1218                                     case 'm':
   1219                                         if (strcmp("port_pct_type", s + 9) == 0)
   1220                                             return PIDX_PKEY_PARAM_ML_KEM_IMPORT_PCT_TYPE;
   1221                                         break;
   1222                                     case 'n':
   1223                                         if (strcmp("put_formats", s + 9) == 0)
   1224                                             return PIDX_PKEY_PARAM_ML_KEM_INPUT_FORMATS;
   1225                                     }
   1226                                     break;
   1227                                 case 'o':
   1228                                     if (strcmp("utput_formats", s + 8) == 0)
   1229                                         return PIDX_PKEY_PARAM_ML_KEM_OUTPUT_FORMATS;
   1230                                     break;
   1231                                 case 'p':
   1232                                     if (strcmp("refer_seed", s + 8) == 0)
   1233                                         return PIDX_PKEY_PARAM_ML_KEM_PREFER_SEED;
   1234                                     break;
   1235                                 case 'r':
   1236                                     if (strcmp("etain_seed", s + 8) == 0)
   1237                                         return PIDX_PKEY_PARAM_ML_KEM_RETAIN_SEED;
   1238                                 }
   1239                             }
   1240                         }
   1241                     }
   1242                 }
   1243             }
   1244             break;
   1245         case 'o':
   1246             switch(s[2]) {
   1247             default:
   1248                 break;
   1249             case 'd':
   1250                 switch(s[3]) {
   1251                 default:
   1252                     break;
   1253                 case 'e':
   1254                     switch(s[4]) {
   1255                     default:
   1256                         break;
   1257                     case '\0':
   1258                         return PIDX_LIBSSL_RECORD_LAYER_PARAM_MODE;
   1259                     }
   1260                     break;
   1261                 case 'u':
   1262                     if (strcmp("le-filename", s + 4) == 0)
   1263                         return PIDX_PROV_PARAM_CORE_MODULE_FILENAME;
   1264                 }
   1265             }
   1266             break;
   1267         case 'u':
   1268             switch(s[2]) {
   1269             default:
   1270                 break;
   1271             case '\0':
   1272                 return PIDX_SIGNATURE_PARAM_MU;
   1273             }
   1274             break;
   1275         case '\0':
   1276             return PIDX_PKEY_PARAM_EC_CHAR2_M;
   1277         }
   1278         break;
   1279     case 'n':
   1280         switch(s[1]) {
   1281         default:
   1282             break;
   1283         case 'a':
   1284             if (strcmp("me", s + 2) == 0)
   1285                 return PIDX_STORE_PARAM_ISSUER;
   1286             break;
   1287         case 'o':
   1288             switch(s[2]) {
   1289             default:
   1290                 break;
   1291             case '-':
   1292                 if (strcmp("short-mac", s + 3) == 0)
   1293                     return PIDX_PROV_PARAM_NO_SHORT_MAC;
   1294                 break;
   1295             case 'n':
   1296                 switch(s[3]) {
   1297                 default:
   1298                     break;
   1299                 case 'c':
   1300                     switch(s[4]) {
   1301                     default:
   1302                         break;
   1303                     case 'e':
   1304                         switch(s[5]) {
   1305                         default:
   1306                             break;
   1307                         case '-':
   1308                             if (strcmp("type", s + 6) == 0)
   1309                                 return PIDX_SIGNATURE_PARAM_NONCE_TYPE;
   1310                             break;
   1311                         case '\0':
   1312                             return PIDX_KDF_PARAM_HMACDRBG_NONCE;
   1313                         }
   1314                     }
   1315                 }
   1316             }
   1317             break;
   1318         case 'u':
   1319             if (strcmp("m", s + 2) == 0)
   1320                 return PIDX_CIPHER_PARAM_NUM;
   1321             break;
   1322         case '\0':
   1323             return PIDX_PKEY_PARAM_RSA_N;
   1324         }
   1325         break;
   1326     case 'o':
   1327         switch(s[1]) {
   1328         default:
   1329             break;
   1330         case 'a':
   1331             if (strcmp("ep-label", s + 2) == 0)
   1332                 return PIDX_ASYM_CIPHER_PARAM_OAEP_LABEL;
   1333             break;
   1334         case 'p':
   1335             switch(s[2]) {
   1336             default:
   1337                 break;
   1338             case 'e':
   1339                 switch(s[3]) {
   1340                 default:
   1341                     break;
   1342                 case 'n':
   1343                     if (strcmp("ssl-version", s + 4) == 0)
   1344                         return PIDX_PROV_PARAM_CORE_VERSION;
   1345                     break;
   1346                 case 'r':
   1347                     if (strcmp("ation", s + 4) == 0)
   1348                         return PIDX_KEM_PARAM_OPERATION;
   1349                 }
   1350                 break;
   1351             case 't':
   1352                 if (strcmp("ions", s + 3) == 0)
   1353                     return PIDX_LIBSSL_RECORD_LAYER_PARAM_OPTIONS;
   1354             }
   1355             break;
   1356         case 'r':
   1357             if (strcmp("der", s + 2) == 0)
   1358                 return PIDX_PKEY_PARAM_EC_ORDER;
   1359         }
   1360         break;
   1361     case 'p':
   1362         switch(s[1]) {
   1363         default:
   1364             break;
   1365         case '1':
   1366             switch(s[2]) {
   1367             default:
   1368                 break;
   1369             case '\0':
   1370                 return PIDX_PKEY_PARAM_RSA_TEST_P1;
   1371             }
   1372             break;
   1373         case '2':
   1374             switch(s[2]) {
   1375             default:
   1376                 break;
   1377             case '\0':
   1378                 return PIDX_PKEY_PARAM_RSA_TEST_P2;
   1379             }
   1380             break;
   1381         case 'a':
   1382             switch(s[2]) {
   1383             default:
   1384                 break;
   1385             case 'd':
   1386                 switch(s[3]) {
   1387                 default:
   1388                     break;
   1389                 case '-':
   1390                     switch(s[4]) {
   1391                     default:
   1392                         break;
   1393                     case 'm':
   1394                         if (strcmp("ode", s + 5) == 0)
   1395                             return PIDX_PKEY_PARAM_PAD_MODE;
   1396                         break;
   1397                     case 't':
   1398                         if (strcmp("ype", s + 5) == 0)
   1399                             return PIDX_DIGEST_PARAM_PAD_TYPE;
   1400                     }
   1401                     break;
   1402                 case 'd':
   1403                     if (strcmp("ing", s + 4) == 0)
   1404                         return PIDX_CIPHER_PARAM_PADDING;
   1405                     break;
   1406                 case '\0':
   1407                     return PIDX_EXCHANGE_PARAM_PAD;
   1408                 }
   1409                 break;
   1410             case 'r':
   1411                 switch(s[3]) {
   1412                 default:
   1413                     break;
   1414                 case 't':
   1415                     switch(s[4]) {
   1416                     default:
   1417                         break;
   1418                     case 'y':
   1419                         switch(s[5]) {
   1420                         default:
   1421                             break;
   1422                         case 'u':
   1423                             if (strcmp("-info", s + 6) == 0)
   1424                                 return PIDX_KDF_PARAM_X942_PARTYUINFO;
   1425                             break;
   1426                         case 'v':
   1427                             if (strcmp("-info", s + 6) == 0)
   1428                                 return PIDX_KDF_PARAM_X942_PARTYVINFO;
   1429                         }
   1430                     }
   1431                 }
   1432                 break;
   1433             case 's':
   1434                 if (strcmp("s", s + 3) == 0)
   1435                     return PIDX_KDF_PARAM_PASSWORD;
   1436             }
   1437             break;
   1438         case 'b':
   1439             switch(s[2]) {
   1440             default:
   1441                 break;
   1442             case 'i':
   1443                 if (strcmp("ts", s + 3) == 0)
   1444                     return PIDX_PKEY_PARAM_FFC_PBITS;
   1445                 break;
   1446             case 'k':
   1447                 if (strcmp("df2-lower-bound-check", s + 3) == 0)
   1448                     return PIDX_PROV_PARAM_PBKDF2_LOWER_BOUND_CHECK;
   1449             }
   1450             break;
   1451         case 'c':
   1452             if (strcmp("ounter", s + 2) == 0)
   1453                 return PIDX_PKEY_PARAM_FFC_PCOUNTER;
   1454             break;
   1455         case 'i':
   1456             if (strcmp("peline-tag", s + 2) == 0)
   1457                 return PIDX_CIPHER_PARAM_PIPELINE_AEAD_TAG;
   1458             break;
   1459         case 'k':
   1460             if (strcmp("cs5", s + 2) == 0)
   1461                 return PIDX_KDF_PARAM_PKCS5;
   1462             break;
   1463         case 'o':
   1464             switch(s[2]) {
   1465             default:
   1466                 break;
   1467             case 'i':
   1468                 if (strcmp("nt-format", s + 3) == 0)
   1469                     return PIDX_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT;
   1470                 break;
   1471             case 't':
   1472                 if (strcmp("ential", s + 3) == 0)
   1473                     return PIDX_GEN_PARAM_POTENTIAL;
   1474             }
   1475             break;
   1476         case 'r':
   1477             switch(s[2]) {
   1478             default:
   1479                 break;
   1480             case 'e':
   1481                 switch(s[3]) {
   1482                 default:
   1483                     break;
   1484                 case 'd':
   1485                     if (strcmp("iction_resistance", s + 4) == 0)
   1486                         return PIDX_DRBG_PARAM_PREDICTION_RESISTANCE;
   1487                     break;
   1488                 case 'f':
   1489                     if (strcmp("ix", s + 4) == 0)
   1490                         return PIDX_KDF_PARAM_PREFIX;
   1491                 }
   1492                 break;
   1493             case 'i':
   1494                 switch(s[3]) {
   1495                 default:
   1496                     break;
   1497                 case 'm':
   1498                     if (strcmp("es", s + 4) == 0)
   1499                         return PIDX_PKEY_PARAM_RSA_PRIMES;
   1500                     break;
   1501                 case 'v':
   1502                     switch(s[4]) {
   1503                     default:
   1504                         break;
   1505                     case '_':
   1506                         if (strcmp("len", s + 5) == 0)
   1507                             return PIDX_PKEY_PARAM_DH_PRIV_LEN;
   1508                         break;
   1509                     case '\0':
   1510                         return PIDX_PKEY_PARAM_PRIV_KEY;
   1511                     }
   1512                 }
   1513                 break;
   1514             case 'o':
   1515                 switch(s[3]) {
   1516                 default:
   1517                     break;
   1518                 case 'p':
   1519                     if (strcmp("erties", s + 4) == 0)
   1520                         return PIDX_STORE_PARAM_PROPERTIES;
   1521                     break;
   1522                 case 'v':
   1523                     if (strcmp("ider-name", s + 4) == 0)
   1524                         return PIDX_PROV_PARAM_CORE_PROV_NAME;
   1525                 }
   1526             }
   1527             break;
   1528         case 'u':
   1529             if (strcmp("b", s + 2) == 0)
   1530                 return PIDX_PKEY_PARAM_PUB_KEY;
   1531             break;
   1532         case '\0':
   1533             return PIDX_PKEY_PARAM_FFC_P;
   1534         }
   1535         break;
   1536     case 'q':
   1537         switch(s[1]) {
   1538         default:
   1539             break;
   1540         case '1':
   1541             switch(s[2]) {
   1542             default:
   1543                 break;
   1544             case '\0':
   1545                 return PIDX_PKEY_PARAM_RSA_TEST_Q1;
   1546             }
   1547             break;
   1548         case '2':
   1549             switch(s[2]) {
   1550             default:
   1551                 break;
   1552             case '\0':
   1553                 return PIDX_PKEY_PARAM_RSA_TEST_Q2;
   1554             }
   1555             break;
   1556         case 'b':
   1557             if (strcmp("its", s + 2) == 0)
   1558                 return PIDX_PKEY_PARAM_FFC_QBITS;
   1559             break;
   1560         case '\0':
   1561             return PIDX_PKEY_PARAM_FFC_Q;
   1562             break;
   1563         case 'x':
   1564             switch(s[2]) {
   1565             default:
   1566                 break;
   1567             case '\0':
   1568                 return PIDX_PKEY_PARAM_EC_PUB_X;
   1569             }
   1570             break;
   1571         case 'y':
   1572             switch(s[2]) {
   1573             default:
   1574                 break;
   1575             case '\0':
   1576                 return PIDX_PKEY_PARAM_EC_PUB_Y;
   1577             }
   1578         }
   1579         break;
   1580     case 'r':
   1581         switch(s[1]) {
   1582         default:
   1583             break;
   1584         case 'a':
   1585             switch(s[2]) {
   1586             default:
   1587                 break;
   1588             case 'n':
   1589                 switch(s[3]) {
   1590                 default:
   1591                     break;
   1592                 case 'd':
   1593                     switch(s[4]) {
   1594                     default:
   1595                         break;
   1596                     case 'k':
   1597                         if (strcmp("ey", s + 5) == 0)
   1598                             return PIDX_CIPHER_PARAM_RANDOM_KEY;
   1599                         break;
   1600                     case 'o':
   1601                         if (strcmp("m_data", s + 5) == 0)
   1602                             return PIDX_DRBG_PARAM_RANDOM_DATA;
   1603                     }
   1604                 }
   1605                 break;
   1606             case 'w':
   1607                 if (strcmp("-bytes", s + 3) == 0)
   1608                     return PIDX_SKEY_PARAM_RAW_BYTES;
   1609             }
   1610             break;
   1611         case 'e':
   1612             switch(s[2]) {
   1613             default:
   1614                 break;
   1615             case 'a':
   1616                 switch(s[3]) {
   1617                 default:
   1618                     break;
   1619                 case 'd':
   1620                     switch(s[4]) {
   1621                     default:
   1622                         break;
   1623                     case '_':
   1624                         switch(s[5]) {
   1625                         default:
   1626                             break;
   1627                         case 'a':
   1628                             if (strcmp("head", s + 6) == 0)
   1629                                 return PIDX_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD;
   1630                             break;
   1631                         case 'b':
   1632                             if (strcmp("uffer_len", s + 6) == 0)
   1633                                 return PIDX_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN;
   1634                         }
   1635                     }
   1636                 }
   1637                 break;
   1638             case 'f':
   1639                 if (strcmp("erence", s + 3) == 0)
   1640                     return PIDX_OBJECT_PARAM_REFERENCE;
   1641                 break;
   1642             case 's':
   1643                 switch(s[3]) {
   1644                 default:
   1645                     break;
   1646                 case 'e':
   1647                     switch(s[4]) {
   1648                     default:
   1649                         break;
   1650                     case 'e':
   1651                         switch(s[5]) {
   1652                         default:
   1653                             break;
   1654                         case 'd':
   1655                             switch(s[6]) {
   1656                             default:
   1657                                 break;
   1658                             case '_':
   1659                                 switch(s[7]) {
   1660                                 default:
   1661                                     break;
   1662                                 case 'c':
   1663                                     if (strcmp("ounter", s + 8) == 0)
   1664                                         return PIDX_DRBG_PARAM_RESEED_COUNTER;
   1665                                     break;
   1666                                 case 'r':
   1667                                     if (strcmp("equests", s + 8) == 0)
   1668                                         return PIDX_DRBG_PARAM_RESEED_REQUESTS;
   1669                                     break;
   1670                                 case 't':
   1671                                     switch(s[8]) {
   1672                                     default:
   1673                                         break;
   1674                                     case 'i':
   1675                                         switch(s[9]) {
   1676                                         default:
   1677                                             break;
   1678                                         case 'm':
   1679                                             switch(s[10]) {
   1680                                             default:
   1681                                                 break;
   1682                                             case 'e':
   1683                                                 switch(s[11]) {
   1684                                                 default:
   1685                                                     break;
   1686                                                 case '_':
   1687                                                     if (strcmp("interval", s + 12) == 0)
   1688                                                         return PIDX_DRBG_PARAM_RESEED_TIME_INTERVAL;
   1689                                                     break;
   1690                                                 case '\0':
   1691                                                     return PIDX_DRBG_PARAM_RESEED_TIME;
   1692                                                 }
   1693                                             }
   1694                                         }
   1695                                     }
   1696                                 }
   1697                             }
   1698                         }
   1699                     }
   1700                 }
   1701             }
   1702             break;
   1703         case 'o':
   1704             if (strcmp("unds", s + 2) == 0)
   1705                 return PIDX_CIPHER_PARAM_ROUNDS;
   1706             break;
   1707         case 's':
   1708             switch(s[2]) {
   1709             default:
   1710                 break;
   1711             case 'a':
   1712                 switch(s[3]) {
   1713                 default:
   1714                     break;
   1715                 case '-':
   1716                     switch(s[4]) {
   1717                     default:
   1718                         break;
   1719                     case 'c':
   1720                         switch(s[5]) {
   1721                         default:
   1722                             break;
   1723                         case 'o':
   1724                             switch(s[6]) {
   1725                             default:
   1726                                 break;
   1727                             case 'e':
   1728                                 switch(s[7]) {
   1729                                 default:
   1730                                     break;
   1731                                 case 'f':
   1732                                     switch(s[8]) {
   1733                                     default:
   1734                                         break;
   1735                                     case 'f':
   1736                                         switch(s[9]) {
   1737                                         default:
   1738                                             break;
   1739                                         case 'i':
   1740                                             switch(s[10]) {
   1741                                             default:
   1742                                                 break;
   1743                                             case 'c':
   1744                                                 switch(s[11]) {
   1745                                                 default:
   1746                                                     break;
   1747                                                 case 'i':
   1748                                                     switch(s[12]) {
   1749                                                     default:
   1750                                                         break;
   1751                                                     case 'e':
   1752                                                         switch(s[13]) {
   1753                                                         default:
   1754                                                             break;
   1755                                                         case 'n':
   1756                                                             switch(s[14]) {
   1757                                                             default:
   1758                                                                 break;
   1759                                                             case 't':
   1760                                                                 switch(s[15]) {
   1761                                                                 default:
   1762                                                                     break;
   1763                                                                 case '1':
   1764                                                                     switch(s[16]) {
   1765                                                                     default:
   1766                                                                         break;
   1767                                                                     case '\0':
   1768                                                                         return PIDX_PKEY_PARAM_RSA_COEFFICIENT1;
   1769                                                                     }
   1770                                                                     break;
   1771                                                                 case '2':
   1772                                                                     switch(s[16]) {
   1773                                                                     default:
   1774                                                                         break;
   1775                                                                     case '\0':
   1776                                                                         return PIDX_PKEY_PARAM_RSA_COEFFICIENT2;
   1777                                                                     }
   1778                                                                     break;
   1779                                                                 case '3':
   1780                                                                     switch(s[16]) {
   1781                                                                     default:
   1782                                                                         break;
   1783                                                                     case '\0':
   1784                                                                         return PIDX_PKEY_PARAM_RSA_COEFFICIENT3;
   1785                                                                     }
   1786                                                                     break;
   1787                                                                 case '4':
   1788                                                                     switch(s[16]) {
   1789                                                                     default:
   1790                                                                         break;
   1791                                                                     case '\0':
   1792                                                                         return PIDX_PKEY_PARAM_RSA_COEFFICIENT4;
   1793                                                                     }
   1794                                                                     break;
   1795                                                                 case '5':
   1796                                                                     switch(s[16]) {
   1797                                                                     default:
   1798                                                                         break;
   1799                                                                     case '\0':
   1800                                                                         return PIDX_PKEY_PARAM_RSA_COEFFICIENT5;
   1801                                                                     }
   1802                                                                     break;
   1803                                                                 case '6':
   1804                                                                     switch(s[16]) {
   1805                                                                     default:
   1806                                                                         break;
   1807                                                                     case '\0':
   1808                                                                         return PIDX_PKEY_PARAM_RSA_COEFFICIENT6;
   1809                                                                     }
   1810                                                                     break;
   1811                                                                 case '7':
   1812                                                                     switch(s[16]) {
   1813                                                                     default:
   1814                                                                         break;
   1815                                                                     case '\0':
   1816                                                                         return PIDX_PKEY_PARAM_RSA_COEFFICIENT7;
   1817                                                                     }
   1818                                                                     break;
   1819                                                                 case '8':
   1820                                                                     switch(s[16]) {
   1821                                                                     default:
   1822                                                                         break;
   1823                                                                     case '\0':
   1824                                                                         return PIDX_PKEY_PARAM_RSA_COEFFICIENT8;
   1825                                                                     }
   1826                                                                     break;
   1827                                                                 case '9':
   1828                                                                     switch(s[16]) {
   1829                                                                     default:
   1830                                                                         break;
   1831                                                                     case '\0':
   1832                                                                         return PIDX_PKEY_PARAM_RSA_COEFFICIENT9;
   1833                                                                     }
   1834                                                                     break;
   1835                                                                 case '\0':
   1836                                                                     return PIDX_PKEY_PARAM_RSA_COEFFICIENT;
   1837                                                                 }
   1838                                                             }
   1839                                                         }
   1840                                                     }
   1841                                                 }
   1842                                             }
   1843                                         }
   1844                                     }
   1845                                 }
   1846                             }
   1847                         }
   1848                         break;
   1849                     case 'd':
   1850                         if (strcmp("erive-from-pq", s + 5) == 0)
   1851                             return PIDX_PKEY_PARAM_RSA_DERIVE_FROM_PQ;
   1852                         break;
   1853                     case 'e':
   1854                         switch(s[5]) {
   1855                         default:
   1856                             break;
   1857                         case 'x':
   1858                             switch(s[6]) {
   1859                             default:
   1860                                 break;
   1861                             case 'p':
   1862                                 switch(s[7]) {
   1863                                 default:
   1864                                     break;
   1865                                 case 'o':
   1866                                     switch(s[8]) {
   1867                                     default:
   1868                                         break;
   1869                                     case 'n':
   1870                                         switch(s[9]) {
   1871                                         default:
   1872                                             break;
   1873                                         case 'e':
   1874                                             switch(s[10]) {
   1875                                             default:
   1876                                                 break;
   1877                                             case 'n':
   1878                                                 switch(s[11]) {
   1879                                                 default:
   1880                                                     break;
   1881                                                 case 't':
   1882                                                     switch(s[12]) {
   1883                                                     default:
   1884                                                         break;
   1885                                                     case '1':
   1886                                                         switch(s[13]) {
   1887                                                         default:
   1888                                                             break;
   1889                                                         case '0':
   1890                                                             switch(s[14]) {
   1891                                                             default:
   1892                                                                 break;
   1893                                                             case '\0':
   1894                                                                 return PIDX_PKEY_PARAM_RSA_EXPONENT10;
   1895                                                             }
   1896                                                             break;
   1897                                                         case '\0':
   1898                                                             return PIDX_PKEY_PARAM_RSA_EXPONENT1;
   1899                                                         }
   1900                                                         break;
   1901                                                     case '2':
   1902                                                         switch(s[13]) {
   1903                                                         default:
   1904                                                             break;
   1905                                                         case '\0':
   1906                                                             return PIDX_PKEY_PARAM_RSA_EXPONENT2;
   1907                                                         }
   1908                                                         break;
   1909                                                     case '3':
   1910                                                         switch(s[13]) {
   1911                                                         default:
   1912                                                             break;
   1913                                                         case '\0':
   1914                                                             return PIDX_PKEY_PARAM_RSA_EXPONENT3;
   1915                                                         }
   1916                                                         break;
   1917                                                     case '4':
   1918                                                         switch(s[13]) {
   1919                                                         default:
   1920                                                             break;
   1921                                                         case '\0':
   1922                                                             return PIDX_PKEY_PARAM_RSA_EXPONENT4;
   1923                                                         }
   1924                                                         break;
   1925                                                     case '5':
   1926                                                         switch(s[13]) {
   1927                                                         default:
   1928                                                             break;
   1929                                                         case '\0':
   1930                                                             return PIDX_PKEY_PARAM_RSA_EXPONENT5;
   1931                                                         }
   1932                                                         break;
   1933                                                     case '6':
   1934                                                         switch(s[13]) {
   1935                                                         default:
   1936                                                             break;
   1937                                                         case '\0':
   1938                                                             return PIDX_PKEY_PARAM_RSA_EXPONENT6;
   1939                                                         }
   1940                                                         break;
   1941                                                     case '7':
   1942                                                         switch(s[13]) {
   1943                                                         default:
   1944                                                             break;
   1945                                                         case '\0':
   1946                                                             return PIDX_PKEY_PARAM_RSA_EXPONENT7;
   1947                                                         }
   1948                                                         break;
   1949                                                     case '8':
   1950                                                         switch(s[13]) {
   1951                                                         default:
   1952                                                             break;
   1953                                                         case '\0':
   1954                                                             return PIDX_PKEY_PARAM_RSA_EXPONENT8;
   1955                                                         }
   1956                                                         break;
   1957                                                     case '9':
   1958                                                         switch(s[13]) {
   1959                                                         default:
   1960                                                             break;
   1961                                                         case '\0':
   1962                                                             return PIDX_PKEY_PARAM_RSA_EXPONENT9;
   1963                                                         }
   1964                                                         break;
   1965                                                     case '\0':
   1966                                                         return PIDX_PKEY_PARAM_RSA_EXPONENT;
   1967                                                     }
   1968                                                 }
   1969                                             }
   1970                                         }
   1971                                     }
   1972                                 }
   1973                             }
   1974                         }
   1975                         break;
   1976                     case 'f':
   1977                         switch(s[5]) {
   1978                         default:
   1979                             break;
   1980                         case 'a':
   1981                             switch(s[6]) {
   1982                             default:
   1983                                 break;
   1984                             case 'c':
   1985                                 switch(s[7]) {
   1986                                 default:
   1987                                     break;
   1988                                 case 't':
   1989                                     switch(s[8]) {
   1990                                     default:
   1991                                         break;
   1992                                     case 'o':
   1993                                         switch(s[9]) {
   1994                                         default:
   1995                                             break;
   1996                                         case 'r':
   1997                                             switch(s[10]) {
   1998                                             default:
   1999                                                 break;
   2000                                             case '1':
   2001                                                 switch(s[11]) {
   2002                                                 default:
   2003                                                     break;
   2004                                                 case '0':
   2005                                                     switch(s[12]) {
   2006                                                     default:
   2007                                                         break;
   2008                                                     case '\0':
   2009                                                         return PIDX_PKEY_PARAM_RSA_FACTOR10;
   2010                                                     }
   2011                                                     break;
   2012                                                 case '\0':
   2013                                                     return PIDX_PKEY_PARAM_RSA_FACTOR1;
   2014                                                 }
   2015                                                 break;
   2016                                             case '2':
   2017                                                 switch(s[11]) {
   2018                                                 default:
   2019                                                     break;
   2020                                                 case '\0':
   2021                                                     return PIDX_PKEY_PARAM_RSA_FACTOR2;
   2022                                                 }
   2023                                                 break;
   2024                                             case '3':
   2025                                                 switch(s[11]) {
   2026                                                 default:
   2027                                                     break;
   2028                                                 case '\0':
   2029                                                     return PIDX_PKEY_PARAM_RSA_FACTOR3;
   2030                                                 }
   2031                                                 break;
   2032                                             case '4':
   2033                                                 switch(s[11]) {
   2034                                                 default:
   2035                                                     break;
   2036                                                 case '\0':
   2037                                                     return PIDX_PKEY_PARAM_RSA_FACTOR4;
   2038                                                 }
   2039                                                 break;
   2040                                             case '5':
   2041                                                 switch(s[11]) {
   2042                                                 default:
   2043                                                     break;
   2044                                                 case '\0':
   2045                                                     return PIDX_PKEY_PARAM_RSA_FACTOR5;
   2046                                                 }
   2047                                                 break;
   2048                                             case '6':
   2049                                                 switch(s[11]) {
   2050                                                 default:
   2051                                                     break;
   2052                                                 case '\0':
   2053                                                     return PIDX_PKEY_PARAM_RSA_FACTOR6;
   2054                                                 }
   2055                                                 break;
   2056                                             case '7':
   2057                                                 switch(s[11]) {
   2058                                                 default:
   2059                                                     break;
   2060                                                 case '\0':
   2061                                                     return PIDX_PKEY_PARAM_RSA_FACTOR7;
   2062                                                 }
   2063                                                 break;
   2064                                             case '8':
   2065                                                 switch(s[11]) {
   2066                                                 default:
   2067                                                     break;
   2068                                                 case '\0':
   2069                                                     return PIDX_PKEY_PARAM_RSA_FACTOR8;
   2070                                                 }
   2071                                                 break;
   2072                                             case '9':
   2073                                                 switch(s[11]) {
   2074                                                 default:
   2075                                                     break;
   2076                                                 case '\0':
   2077                                                     return PIDX_PKEY_PARAM_RSA_FACTOR9;
   2078                                                 }
   2079                                                 break;
   2080                                             case '\0':
   2081                                                 return PIDX_PKEY_PARAM_RSA_FACTOR;
   2082                                             }
   2083                                         }
   2084                                     }
   2085                                 }
   2086                             }
   2087                         }
   2088                         break;
   2089                     case 'p':
   2090                         switch(s[5]) {
   2091                         default:
   2092                             break;
   2093                         case 'k':
   2094                             if (strcmp("cs15-pad-disabled", s + 6) == 0)
   2095                                 return PIDX_PROV_PARAM_RSA_PKCS15_PAD_DISABLED;
   2096                             break;
   2097                         case 's':
   2098                             if (strcmp("s-saltlen-check", s + 6) == 0)
   2099                                 return PIDX_SIGNATURE_PARAM_FIPS_RSA_PSS_SALTLEN_CHECK;
   2100                         }
   2101                         break;
   2102                     case 's':
   2103                         if (strcmp("ign-x931-pad-disabled", s + 5) == 0)
   2104                             return PIDX_PROV_PARAM_RSA_SIGN_X931_PAD_DISABLED;
   2105                     }
   2106                 }
   2107             }
   2108             break;
   2109         case '\0':
   2110             return PIDX_KDF_PARAM_SCRYPT_R;
   2111         }
   2112         break;
   2113     case 's':
   2114         switch(s[1]) {
   2115         default:
   2116             break;
   2117         case 'a':
   2118             switch(s[2]) {
   2119             default:
   2120                 break;
   2121             case 'f':
   2122                 if (strcmp("eprime-generator", s + 3) == 0)
   2123                     return PIDX_PKEY_PARAM_DH_GENERATOR;
   2124                 break;
   2125             case 'l':
   2126                 switch(s[3]) {
   2127                 default:
   2128                     break;
   2129                 case 't':
   2130                     switch(s[4]) {
   2131                     default:
   2132                         break;
   2133                     case 'l':
   2134                         if (strcmp("en", s + 5) == 0)
   2135                             return PIDX_SIGNATURE_PARAM_PSS_SALTLEN;
   2136                         break;
   2137                     case '\0':
   2138                         return PIDX_MAC_PARAM_SALT;
   2139                     }
   2140                 }
   2141                 break;
   2142             case 'v':
   2143                 if (strcmp("e-parameters", s + 3) == 0)
   2144                     return PIDX_ENCODER_PARAM_SAVE_PARAMETERS;
   2145             }
   2146             break;
   2147         case 'e':
   2148             switch(s[2]) {
   2149             default:
   2150                 break;
   2151             case 'c':
   2152                 switch(s[3]) {
   2153                 default:
   2154                     break;
   2155                 case 'r':
   2156                     if (strcmp("et", s + 4) == 0)
   2157                         return PIDX_KDF_PARAM_SECRET;
   2158                     break;
   2159                 case 'u':
   2160                     switch(s[4]) {
   2161                     default:
   2162                         break;
   2163                     case 'r':
   2164                         switch(s[5]) {
   2165                         default:
   2166                             break;
   2167                         case 'i':
   2168                             switch(s[6]) {
   2169                             default:
   2170                                 break;
   2171                             case 't':
   2172                                 switch(s[7]) {
   2173                                 default:
   2174                                     break;
   2175                                 case 'y':
   2176                                     switch(s[8]) {
   2177                                     default:
   2178                                         break;
   2179                                     case '-':
   2180                                         switch(s[9]) {
   2181                                         default:
   2182                                             break;
   2183                                         case 'b':
   2184                                             if (strcmp("its", s + 10) == 0)
   2185                                                 return PIDX_PKEY_PARAM_SECURITY_BITS;
   2186                                             break;
   2187                                         case 'c':
   2188                                             if (strcmp("hecks", s + 10) == 0)
   2189                                                 return PIDX_PROV_PARAM_SECURITY_CHECKS;
   2190                                         }
   2191                                     }
   2192                                 }
   2193                             }
   2194                         }
   2195                     }
   2196                 }
   2197                 break;
   2198             case 'e':
   2199                 if (strcmp("d", s + 3) == 0)
   2200                     return PIDX_PKEY_PARAM_SLH_DSA_SEED;
   2201                 break;
   2202             case 'r':
   2203                 if (strcmp("ial", s + 3) == 0)
   2204                     return PIDX_STORE_PARAM_SERIAL;
   2205                 break;
   2206             case 's':
   2207                 if (strcmp("sion_id", s + 3) == 0)
   2208                     return PIDX_KDF_PARAM_SSHKDF_SESSION_ID;
   2209             }
   2210             break;
   2211         case 'i':
   2212             switch(s[2]) {
   2213             default:
   2214                 break;
   2215             case 'g':
   2216                 switch(s[3]) {
   2217                 default:
   2218                     break;
   2219                 case 'n':
   2220                     switch(s[4]) {
   2221                     default:
   2222                         break;
   2223                     case '-':
   2224                         switch(s[5]) {
   2225                         default:
   2226                             break;
   2227                         case 'c':
   2228                             if (strcmp("heck", s + 6) == 0)
   2229                                 return PIDX_PKEY_PARAM_FIPS_SIGN_CHECK;
   2230                             break;
   2231                         case 'x':
   2232                             if (strcmp("931-pad-check", s + 6) == 0)
   2233                                 return PIDX_SIGNATURE_PARAM_FIPS_SIGN_X931_PAD_CHECK;
   2234                         }
   2235                         break;
   2236                     case 'a':
   2237                         switch(s[5]) {
   2238                         default:
   2239                             break;
   2240                         case 't':
   2241                             switch(s[6]) {
   2242                             default:
   2243                                 break;
   2244                             case 'u':
   2245                                 switch(s[7]) {
   2246                                 default:
   2247                                     break;
   2248                                 case 'r':
   2249                                     switch(s[8]) {
   2250                                     default:
   2251                                         break;
   2252                                     case 'e':
   2253                                         switch(s[9]) {
   2254                                         default:
   2255                                             break;
   2256                                         case '-':
   2257                                             if (strcmp("digest-check", s + 10) == 0)
   2258                                                 return PIDX_PROV_PARAM_SIGNATURE_DIGEST_CHECK;
   2259                                             break;
   2260                                         case '\0':
   2261                                             return PIDX_SIGNATURE_PARAM_SIGNATURE;
   2262                                         }
   2263                                     }
   2264                                 }
   2265                             }
   2266                         }
   2267                     }
   2268                 }
   2269                 break;
   2270             case 'z':
   2271                 if (strcmp("e", s + 3) == 0)
   2272                     return PIDX_MAC_PARAM_SIZE;
   2273             }
   2274             break;
   2275         case 'p':
   2276             if (strcmp("eed", s + 2) == 0)
   2277                 return PIDX_CIPHER_PARAM_SPEED;
   2278             break;
   2279         case 's':
   2280             switch(s[2]) {
   2281             default:
   2282                 break;
   2283             case 'h':
   2284                 switch(s[3]) {
   2285                 default:
   2286                     break;
   2287                 case 'k':
   2288                     switch(s[4]) {
   2289                     default:
   2290                         break;
   2291                     case 'd':
   2292                         switch(s[5]) {
   2293                         default:
   2294                             break;
   2295                         case 'f':
   2296                             switch(s[6]) {
   2297                             default:
   2298                                 break;
   2299                             case '-':
   2300                                 switch(s[7]) {
   2301                                 default:
   2302                                     break;
   2303                                 case 'd':
   2304                                     if (strcmp("igest-check", s + 8) == 0)
   2305                                         return PIDX_PROV_PARAM_SSHKDF_DIGEST_CHECK;
   2306                                     break;
   2307                                 case 'k':
   2308                                     if (strcmp("ey-check", s + 8) == 0)
   2309                                         return PIDX_PROV_PARAM_SSHKDF_KEY_CHECK;
   2310                                 }
   2311                             }
   2312                         }
   2313                     }
   2314                 }
   2315                 break;
   2316             case 'k':
   2317                 switch(s[3]) {
   2318                 default:
   2319                     break;
   2320                 case 'd':
   2321                     switch(s[4]) {
   2322                     default:
   2323                         break;
   2324                     case 'f':
   2325                         switch(s[5]) {
   2326                         default:
   2327                             break;
   2328                         case '-':
   2329                             switch(s[6]) {
   2330                             default:
   2331                                 break;
   2332                             case 'd':
   2333                                 if (strcmp("igest-check", s + 7) == 0)
   2334                                     return PIDX_PROV_PARAM_SSKDF_DIGEST_CHECK;
   2335                                 break;
   2336                             case 'k':
   2337                                 if (strcmp("ey-check", s + 7) == 0)
   2338                                     return PIDX_PROV_PARAM_SSKDF_KEY_CHECK;
   2339                             }
   2340                         }
   2341                     }
   2342                 }
   2343                 break;
   2344             case 'l':
   2345                 if (strcmp("3-ms", s + 3) == 0)
   2346                     return PIDX_DIGEST_PARAM_SSL3_MS;
   2347             }
   2348             break;
   2349         case 't':
   2350             switch(s[2]) {
   2351             default:
   2352                 break;
   2353             case '-':
   2354                 switch(s[3]) {
   2355                 default:
   2356                     break;
   2357                 case 'd':
   2358                     if (strcmp("esc", s + 4) == 0)
   2359                         return PIDX_PROV_PARAM_SELF_TEST_DESC;
   2360                     break;
   2361                 case 'p':
   2362                     if (strcmp("hase", s + 4) == 0)
   2363                         return PIDX_PROV_PARAM_SELF_TEST_PHASE;
   2364                     break;
   2365                 case 't':
   2366                     if (strcmp("ype", s + 4) == 0)
   2367                         return PIDX_PROV_PARAM_SELF_TEST_TYPE;
   2368                 }
   2369                 break;
   2370             case 'a':
   2371                 switch(s[3]) {
   2372                 default:
   2373                     break;
   2374                 case 't':
   2375                     switch(s[4]) {
   2376                     default:
   2377                         break;
   2378                     case 'e':
   2379                         switch(s[5]) {
   2380                         default:
   2381                             break;
   2382                         case '\0':
   2383                             return PIDX_RAND_PARAM_STATE;
   2384                         }
   2385                         break;
   2386                     case 'u':
   2387                         if (strcmp("s", s + 5) == 0)
   2388                             return PIDX_PROV_PARAM_STATUS;
   2389                     }
   2390                 }
   2391                 break;
   2392             case 'r':
   2393                 switch(s[3]) {
   2394                 default:
   2395                     break;
   2396                 case 'e':
   2397                     switch(s[4]) {
   2398                     default:
   2399                         break;
   2400                     case 'a':
   2401                         if (strcmp("m_mac", s + 5) == 0)
   2402                             return PIDX_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC;
   2403                         break;
   2404                     case 'n':
   2405                         if (strcmp("gth", s + 5) == 0)
   2406                             return PIDX_RAND_PARAM_STRENGTH;
   2407                     }
   2408                 }
   2409             }
   2410             break;
   2411         case 'u':
   2412             switch(s[2]) {
   2413             default:
   2414                 break;
   2415             case 'b':
   2416                 if (strcmp("ject", s + 3) == 0)
   2417                     return PIDX_STORE_PARAM_SUBJECT;
   2418                 break;
   2419             case 'p':
   2420                 switch(s[3]) {
   2421                 default:
   2422                     break;
   2423                 case 'p':
   2424                     switch(s[4]) {
   2425                     default:
   2426                         break;
   2427                     case '-':
   2428                         switch(s[5]) {
   2429                         default:
   2430                             break;
   2431                         case 'p':
   2432                             switch(s[6]) {
   2433                             default:
   2434                                 break;
   2435                             case 'r':
   2436                                 if (strcmp("ivinfo", s + 7) == 0)
   2437                                     return PIDX_KDF_PARAM_X942_SUPP_PRIVINFO;
   2438                                 break;
   2439                             case 'u':
   2440                                 if (strcmp("binfo", s + 7) == 0)
   2441                                     return PIDX_KDF_PARAM_X942_SUPP_PUBINFO;
   2442                             }
   2443                         }
   2444                     }
   2445                 }
   2446             }
   2447         }
   2448         break;
   2449     case 't':
   2450         switch(s[1]) {
   2451         default:
   2452             break;
   2453         case 'a':
   2454             switch(s[2]) {
   2455             default:
   2456                 break;
   2457             case 'g':
   2458                 switch(s[3]) {
   2459                 default:
   2460                     break;
   2461                 case 'l':
   2462                     if (strcmp("en", s + 4) == 0)
   2463                         return PIDX_CIPHER_PARAM_AEAD_TAGLEN;
   2464                     break;
   2465                 case '\0':
   2466                     return PIDX_CIPHER_PARAM_AEAD_TAG;
   2467                 }
   2468             }
   2469             break;
   2470         case 'd':
   2471             if (strcmp("es-encrypt-disabled", s + 2) == 0)
   2472                 return PIDX_PROV_PARAM_TDES_ENCRYPT_DISABLED;
   2473             break;
   2474         case 'e':
   2475             switch(s[2]) {
   2476             default:
   2477                 break;
   2478             case 's':
   2479                 switch(s[3]) {
   2480                 default:
   2481                     break;
   2482                 case 't':
   2483                     switch(s[4]) {
   2484                     default:
   2485                         break;
   2486                     case '-':
   2487                         if (strcmp("entropy", s + 5) == 0)
   2488                             return PIDX_SIGNATURE_PARAM_TEST_ENTROPY;
   2489                         break;
   2490                     case '_':
   2491                         switch(s[5]) {
   2492                         default:
   2493                             break;
   2494                         case 'e':
   2495                             if (strcmp("ntropy", s + 6) == 0)
   2496                                 return PIDX_RAND_PARAM_TEST_ENTROPY;
   2497                             break;
   2498                         case 'n':
   2499                             if (strcmp("once", s + 6) == 0)
   2500                                 return PIDX_RAND_PARAM_TEST_NONCE;
   2501                         }
   2502                     }
   2503                 }
   2504             }
   2505             break;
   2506         case 'h':
   2507             if (strcmp("reads", s + 2) == 0)
   2508                 return PIDX_KDF_PARAM_THREADS;
   2509             break;
   2510         case 'l':
   2511             switch(s[2]) {
   2512             default:
   2513                 break;
   2514             case 's':
   2515                 switch(s[3]) {
   2516                 default:
   2517                     break;
   2518                 case '-':
   2519                     switch(s[4]) {
   2520                     default:
   2521                         break;
   2522                     case 'c':
   2523                         if (strcmp("lient-version", s + 5) == 0)
   2524                             return PIDX_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION;
   2525                         break;
   2526                     case 'd':
   2527                         if (strcmp("ata-size", s + 5) == 0)
   2528                             return PIDX_MAC_PARAM_TLS_DATA_SIZE;
   2529                         break;
   2530                     case 'g':
   2531                         switch(s[5]) {
   2532                         default:
   2533                             break;
   2534                         case 'r':
   2535                             switch(s[6]) {
   2536                             default:
   2537                                 break;
   2538                             case 'o':
   2539                                 switch(s[7]) {
   2540                                 default:
   2541                                     break;
   2542                                 case 'u':
   2543                                     switch(s[8]) {
   2544                                     default:
   2545                                         break;
   2546                                     case 'p':
   2547                                         switch(s[9]) {
   2548                                         default:
   2549                                             break;
   2550                                         case '-':
   2551                                             switch(s[10]) {
   2552                                             default:
   2553                                                 break;
   2554                                             case 'a':
   2555                                                 if (strcmp("lg", s + 11) == 0)
   2556                                                     return PIDX_CAPABILITY_TLS_GROUP_ALG;
   2557                                                 break;
   2558                                             case 'i':
   2559                                                 switch(s[11]) {
   2560                                                 default:
   2561                                                     break;
   2562                                                 case 'd':
   2563                                                     switch(s[12]) {
   2564                                                     default:
   2565                                                         break;
   2566                                                     case '\0':
   2567                                                         return PIDX_CAPABILITY_TLS_GROUP_ID;
   2568                                                     }
   2569                                                     break;
   2570                                                 case 's':
   2571                                                     if (strcmp("-kem", s + 12) == 0)
   2572                                                         return PIDX_CAPABILITY_TLS_GROUP_IS_KEM;
   2573                                                 }
   2574                                                 break;
   2575                                             case 'n':
   2576                                                 switch(s[11]) {
   2577                                                 default:
   2578                                                     break;
   2579                                                 case 'a':
   2580                                                     switch(s[12]) {
   2581                                                     default:
   2582                                                         break;
   2583                                                     case 'm':
   2584                                                         switch(s[13]) {
   2585                                                         default:
   2586                                                             break;
   2587                                                         case 'e':
   2588                                                             switch(s[14]) {
   2589                                                             default:
   2590                                                                 break;
   2591                                                             case '-':
   2592                                                                 if (strcmp("internal", s + 15) == 0)
   2593                                                                     return PIDX_CAPABILITY_TLS_GROUP_NAME_INTERNAL;
   2594                                                                 break;
   2595                                                             case '\0':
   2596                                                                 return PIDX_CAPABILITY_TLS_GROUP_NAME;
   2597                                                             }
   2598                                                         }
   2599                                                     }
   2600                                                 }
   2601                                                 break;
   2602                                             case 's':
   2603                                                 if (strcmp("ec-bits", s + 11) == 0)
   2604                                                     return PIDX_CAPABILITY_TLS_GROUP_SECURITY_BITS;
   2605                                             }
   2606                                         }
   2607                                     }
   2608                                 }
   2609                             }
   2610                         }
   2611                         break;
   2612                     case 'm':
   2613                         switch(s[5]) {
   2614                         default:
   2615                             break;
   2616                         case 'a':
   2617                             switch(s[6]) {
   2618                             default:
   2619                                 break;
   2620                             case 'c':
   2621                                 switch(s[7]) {
   2622                                 default:
   2623                                     break;
   2624                                 case '-':
   2625                                     if (strcmp("size", s + 8) == 0)
   2626                                         return PIDX_CIPHER_PARAM_TLS_MAC_SIZE;
   2627                                     break;
   2628                                 case '\0':
   2629                                     return PIDX_CIPHER_PARAM_TLS_MAC;
   2630                                 }
   2631                                 break;
   2632                             case 'x':
   2633                                 switch(s[7]) {
   2634                                 default:
   2635                                     break;
   2636                                 case '-':
   2637                                     switch(s[8]) {
   2638                                     default:
   2639                                         break;
   2640                                     case 'd':
   2641                                         if (strcmp("tls", s + 9) == 0)
   2642                                             return PIDX_CAPABILITY_TLS_SIGALG_MAX_DTLS;
   2643                                         break;
   2644                                     case 't':
   2645                                         if (strcmp("ls", s + 9) == 0)
   2646                                             return PIDX_CAPABILITY_TLS_SIGALG_MAX_TLS;
   2647                                     }
   2648                                 }
   2649                             }
   2650                             break;
   2651                         case 'i':
   2652                             switch(s[6]) {
   2653                             default:
   2654                                 break;
   2655                             case 'n':
   2656                                 switch(s[7]) {
   2657                                 default:
   2658                                     break;
   2659                                 case '-':
   2660                                     switch(s[8]) {
   2661                                     default:
   2662                                         break;
   2663                                     case 'd':
   2664                                         if (strcmp("tls", s + 9) == 0)
   2665                                             return PIDX_CAPABILITY_TLS_SIGALG_MIN_DTLS;
   2666                                         break;
   2667                                     case 't':
   2668                                         if (strcmp("ls", s + 9) == 0)
   2669                                             return PIDX_CAPABILITY_TLS_SIGALG_MIN_TLS;
   2670                                     }
   2671                                 }
   2672                             }
   2673                             break;
   2674                         case 'u':
   2675                             if (strcmp("lti", s + 6) == 0)
   2676                                 return PIDX_CIPHER_PARAM_TLS1_MULTIBLOCK;
   2677                         }
   2678                         break;
   2679                     case 'n':
   2680                         if (strcmp("egotiated-version", s + 5) == 0)
   2681                             return PIDX_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION;
   2682                         break;
   2683                     case 's':
   2684                         switch(s[5]) {
   2685                         default:
   2686                             break;
   2687                         case 'i':
   2688                             switch(s[6]) {
   2689                             default:
   2690                                 break;
   2691                             case 'g':
   2692                                 switch(s[7]) {
   2693                                 default:
   2694                                     break;
   2695                                 case 'a':
   2696                                     switch(s[8]) {
   2697                                     default:
   2698                                         break;
   2699                                     case 'l':
   2700                                         switch(s[9]) {
   2701                                         default:
   2702                                             break;
   2703                                         case 'g':
   2704                                             switch(s[10]) {
   2705                                             default:
   2706                                                 break;
   2707                                             case '-':
   2708                                                 switch(s[11]) {
   2709                                                 default:
   2710                                                     break;
   2711                                                 case 'c':
   2712                                                     if (strcmp("ode-point", s + 12) == 0)
   2713                                                         return PIDX_CAPABILITY_TLS_SIGALG_CODE_POINT;
   2714                                                     break;
   2715                                                 case 'h':
   2716                                                     switch(s[12]) {
   2717                                                     default:
   2718                                                         break;
   2719                                                     case 'a':
   2720                                                         switch(s[13]) {
   2721                                                         default:
   2722                                                             break;
   2723                                                         case 's':
   2724                                                             switch(s[14]) {
   2725                                                             default:
   2726                                                                 break;
   2727                                                             case 'h':
   2728                                                                 switch(s[15]) {
   2729                                                                 default:
   2730                                                                     break;
   2731                                                                 case '-':
   2732                                                                     switch(s[16]) {
   2733                                                                     default:
   2734                                                                         break;
   2735                                                                     case 'n':
   2736                                                                         if (strcmp("ame", s + 17) == 0)
   2737                                                                             return PIDX_CAPABILITY_TLS_SIGALG_HASH_NAME;
   2738                                                                         break;
   2739                                                                     case 'o':
   2740                                                                         if (strcmp("id", s + 17) == 0)
   2741                                                                             return PIDX_CAPABILITY_TLS_SIGALG_HASH_OID;
   2742                                                                     }
   2743                                                                 }
   2744                                                             }
   2745                                                         }
   2746                                                     }
   2747                                                     break;
   2748                                                 case 'i':
   2749                                                     if (strcmp("ana-name", s + 12) == 0)
   2750                                                         return PIDX_CAPABILITY_TLS_SIGALG_IANA_NAME;
   2751                                                     break;
   2752                                                 case 'k':
   2753                                                     switch(s[12]) {
   2754                                                     default:
   2755                                                         break;
   2756                                                     case 'e':
   2757                                                         switch(s[13]) {
   2758                                                         default:
   2759                                                             break;
   2760                                                         case 'y':
   2761                                                             switch(s[14]) {
   2762                                                             default:
   2763                                                                 break;
   2764                                                             case 't':
   2765                                                                 switch(s[15]) {
   2766                                                                 default:
   2767                                                                     break;
   2768                                                                 case 'y':
   2769                                                                     switch(s[16]) {
   2770                                                                     default:
   2771                                                                         break;
   2772                                                                     case 'p':
   2773                                                                         switch(s[17]) {
   2774                                                                         default:
   2775                                                                             break;
   2776                                                                         case 'e':
   2777                                                                             switch(s[18]) {
   2778                                                                             default:
   2779                                                                                 break;
   2780                                                                             case '-':
   2781                                                                                 if (strcmp("oid", s + 19) == 0)
   2782                                                                                     return PIDX_CAPABILITY_TLS_SIGALG_KEYTYPE_OID;
   2783                                                                                 break;
   2784                                                                             case '\0':
   2785                                                                                 return PIDX_CAPABILITY_TLS_SIGALG_KEYTYPE;
   2786                                                                             }
   2787                                                                         }
   2788                                                                     }
   2789                                                                 }
   2790                                                             }
   2791                                                         }
   2792                                                     }
   2793                                                     break;
   2794                                                 case 'n':
   2795                                                     if (strcmp("ame", s + 12) == 0)
   2796                                                         return PIDX_CAPABILITY_TLS_SIGALG_NAME;
   2797                                                     break;
   2798                                                 case 'o':
   2799                                                     if (strcmp("id", s + 12) == 0)
   2800                                                         return PIDX_CAPABILITY_TLS_SIGALG_OID;
   2801                                                     break;
   2802                                                 case 's':
   2803                                                     switch(s[12]) {
   2804                                                     default:
   2805                                                         break;
   2806                                                     case 'e':
   2807                                                         if (strcmp("c-bits", s + 13) == 0)
   2808                                                             return PIDX_CAPABILITY_TLS_SIGALG_SECURITY_BITS;
   2809                                                         break;
   2810                                                     case 'i':
   2811                                                         switch(s[13]) {
   2812                                                         default:
   2813                                                             break;
   2814                                                         case 'g':
   2815                                                             switch(s[14]) {
   2816                                                             default:
   2817                                                                 break;
   2818                                                             case '-':
   2819                                                                 switch(s[15]) {
   2820                                                                 default:
   2821                                                                     break;
   2822                                                                 case 'n':
   2823                                                                     if (strcmp("ame", s + 16) == 0)
   2824                                                                         return PIDX_CAPABILITY_TLS_SIGALG_SIG_NAME;
   2825                                                                     break;
   2826                                                                 case 'o':
   2827                                                                     if (strcmp("id", s + 16) == 0)
   2828                                                                         return PIDX_CAPABILITY_TLS_SIGALG_SIG_OID;
   2829                                                                 }
   2830                                                             }
   2831                                                         }
   2832                                                     }
   2833                                                 }
   2834                                             }
   2835                                         }
   2836                                     }
   2837                                 }
   2838                             }
   2839                         }
   2840                         break;
   2841                     case 'v':
   2842                         if (strcmp("ersion", s + 5) == 0)
   2843                             return PIDX_CIPHER_PARAM_TLS_VERSION;
   2844                     }
   2845                     break;
   2846                 case '1':
   2847                     switch(s[4]) {
   2848                     default:
   2849                         break;
   2850                     case '-':
   2851                         switch(s[5]) {
   2852                         default:
   2853                             break;
   2854                         case 'p':
   2855                             switch(s[6]) {
   2856                             default:
   2857                                 break;
   2858                             case 'r':
   2859                                 switch(s[7]) {
   2860                                 default:
   2861                                     break;
   2862                                 case 'f':
   2863                                     switch(s[8]) {
   2864                                     default:
   2865                                         break;
   2866                                     case '-':
   2867                                         switch(s[9]) {
   2868                                         default:
   2869                                             break;
   2870                                         case 'd':
   2871                                             if (strcmp("igest-check", s + 10) == 0)
   2872                                                 return PIDX_PROV_PARAM_TLS1_PRF_DIGEST_CHECK;
   2873                                             break;
   2874                                         case 'e':
   2875                                             if (strcmp("ms-check", s + 10) == 0)
   2876                                                 return PIDX_PROV_PARAM_TLS1_PRF_EMS_CHECK;
   2877                                             break;
   2878                                         case 'k':
   2879                                             if (strcmp("ey-check", s + 10) == 0)
   2880                                                 return PIDX_PROV_PARAM_TLS1_PRF_KEY_CHECK;
   2881                                         }
   2882                                     }
   2883                                 }
   2884                             }
   2885                         }
   2886                         break;
   2887                     case '3':
   2888                         switch(s[5]) {
   2889                         default:
   2890                             break;
   2891                         case '-':
   2892                             switch(s[6]) {
   2893                             default:
   2894                                 break;
   2895                             case 'k':
   2896                                 switch(s[7]) {
   2897                                 default:
   2898                                     break;
   2899                                 case 'd':
   2900                                     switch(s[8]) {
   2901                                     default:
   2902                                         break;
   2903                                     case 'f':
   2904                                         switch(s[9]) {
   2905                                         default:
   2906                                             break;
   2907                                         case '-':
   2908                                             switch(s[10]) {
   2909                                             default:
   2910                                                 break;
   2911                                             case 'd':
   2912                                                 if (strcmp("igest-check", s + 11) == 0)
   2913                                                     return PIDX_PROV_PARAM_TLS13_KDF_DIGEST_CHECK;
   2914                                                 break;
   2915                                             case 'k':
   2916                                                 if (strcmp("ey-check", s + 11) == 0)
   2917                                                     return PIDX_PROV_PARAM_TLS13_KDF_KEY_CHECK;
   2918                                             }
   2919                                         }
   2920                                     }
   2921                                 }
   2922                             }
   2923                         }
   2924                         break;
   2925                     case 'm':
   2926                         switch(s[5]) {
   2927                         default:
   2928                             break;
   2929                         case 'u':
   2930                             switch(s[6]) {
   2931                             default:
   2932                                 break;
   2933                             case 'l':
   2934                                 switch(s[7]) {
   2935                                 default:
   2936                                     break;
   2937                                 case 't':
   2938                                     switch(s[8]) {
   2939                                     default:
   2940                                         break;
   2941                                     case 'i':
   2942                                         switch(s[9]) {
   2943                                         default:
   2944                                             break;
   2945                                         case '_':
   2946                                             switch(s[10]) {
   2947                                             default:
   2948                                                 break;
   2949                                             case 'a':
   2950                                                 switch(s[11]) {
   2951                                                 default:
   2952                                                     break;
   2953                                                 case 'a':
   2954                                                     switch(s[12]) {
   2955                                                     default:
   2956                                                         break;
   2957                                                     case 'd':
   2958                                                         switch(s[13]) {
   2959                                                         default:
   2960                                                             break;
   2961                                                         case 'p':
   2962                                                             if (strcmp("acklen", s + 14) == 0)
   2963                                                                 return PIDX_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD_PACKLEN;
   2964                                                             break;
   2965                                                         case '\0':
   2966                                                             return PIDX_CIPHER_PARAM_TLS1_MULTIBLOCK_AAD;
   2967                                                         }
   2968                                                     }
   2969                                                 }
   2970                                                 break;
   2971                                             case 'e':
   2972                                                 switch(s[11]) {
   2973                                                 default:
   2974                                                     break;
   2975                                                 case 'n':
   2976                                                     switch(s[12]) {
   2977                                                     default:
   2978                                                         break;
   2979                                                     case 'c':
   2980                                                         switch(s[13]) {
   2981                                                         default:
   2982                                                             break;
   2983                                                         case 'i':
   2984                                                             if (strcmp("n", s + 14) == 0)
   2985                                                                 return PIDX_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_IN;
   2986                                                             break;
   2987                                                         case 'l':
   2988                                                             if (strcmp("en", s + 14) == 0)
   2989                                                                 return PIDX_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC_LEN;
   2990                                                             break;
   2991                                                         case '\0':
   2992                                                             return PIDX_CIPHER_PARAM_TLS1_MULTIBLOCK_ENC;
   2993                                                         }
   2994                                                     }
   2995                                                 }
   2996                                                 break;
   2997                                             case 'i':
   2998                                                 if (strcmp("nterleave", s + 11) == 0)
   2999                                                     return PIDX_CIPHER_PARAM_TLS1_MULTIBLOCK_INTERLEAVE;
   3000                                                 break;
   3001                                             case 'm':
   3002                                                 switch(s[11]) {
   3003                                                 default:
   3004                                                     break;
   3005                                                 case 'a':
   3006                                                     switch(s[12]) {
   3007                                                     default:
   3008                                                         break;
   3009                                                     case 'x':
   3010                                                         switch(s[13]) {
   3011                                                         default:
   3012                                                             break;
   3013                                                         case 'b':
   3014                                                             if (strcmp("ufsz", s + 14) == 0)
   3015                                                                 return PIDX_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_BUFSIZE;
   3016                                                             break;
   3017                                                         case 's':
   3018                                                             if (strcmp("ndfrag", s + 14) == 0)
   3019                                                                 return PIDX_CIPHER_PARAM_TLS1_MULTIBLOCK_MAX_SEND_FRAGMENT;
   3020                                                         }
   3021                                                     }
   3022                                                 }
   3023                                             }
   3024                                         }
   3025                                     }
   3026                                 }
   3027                             }
   3028                         }
   3029                     }
   3030                     break;
   3031                 case 'a':
   3032                     switch(s[4]) {
   3033                     default:
   3034                         break;
   3035                     case 'a':
   3036                         switch(s[5]) {
   3037                         default:
   3038                             break;
   3039                         case 'd':
   3040                             switch(s[6]) {
   3041                             default:
   3042                                 break;
   3043                             case 'p':
   3044                                 if (strcmp("ad", s + 7) == 0)
   3045                                     return PIDX_CIPHER_PARAM_AEAD_TLS1_AAD_PAD;
   3046                                 break;
   3047                             case '\0':
   3048                                 return PIDX_CIPHER_PARAM_AEAD_TLS1_AAD;
   3049                             }
   3050                         }
   3051                     }
   3052                     break;
   3053                 case 'i':
   3054                     switch(s[4]) {
   3055                     default:
   3056                         break;
   3057                     case 'v':
   3058                         switch(s[5]) {
   3059                         default:
   3060                             break;
   3061                         case 'f':
   3062                             if (strcmp("ixed", s + 6) == 0)
   3063                                 return PIDX_CIPHER_PARAM_AEAD_TLS1_IV_FIXED;
   3064                             break;
   3065                         case 'g':
   3066                             if (strcmp("en", s + 6) == 0)
   3067                                 return PIDX_CIPHER_PARAM_AEAD_TLS1_GET_IV_GEN;
   3068                             break;
   3069                         case 'i':
   3070                             if (strcmp("nv", s + 6) == 0)
   3071                                 return PIDX_CIPHER_PARAM_AEAD_TLS1_SET_IV_INV;
   3072                         }
   3073                     }
   3074                     break;
   3075                 case 't':
   3076                     if (strcmp("ree", s + 4) == 0)
   3077                         return PIDX_LIBSSL_RECORD_LAYER_PARAM_TLSTREE;
   3078                 }
   3079             }
   3080             break;
   3081         case 'p':
   3082             switch(s[2]) {
   3083             default:
   3084                 break;
   3085             case '\0':
   3086                 return PIDX_PKEY_PARAM_EC_CHAR2_TP_BASIS;
   3087             }
   3088             break;
   3089         case 'y':
   3090             if (strcmp("pe", s + 2) == 0)
   3091                 return PIDX_PKEY_PARAM_FFC_TYPE;
   3092         }
   3093         break;
   3094     case 'u':
   3095         switch(s[1]) {
   3096         default:
   3097             break;
   3098         case 'k':
   3099             if (strcmp("m", s + 2) == 0)
   3100                 return PIDX_KDF_PARAM_UKM;
   3101             break;
   3102         case 'p':
   3103             if (strcmp("dated-iv", s + 2) == 0)
   3104                 return PIDX_CIPHER_PARAM_UPDATED_IV;
   3105             break;
   3106         case 's':
   3107             switch(s[2]) {
   3108             default:
   3109                 break;
   3110             case 'e':
   3111                 switch(s[3]) {
   3112                 default:
   3113                     break;
   3114                 case '-':
   3115                     switch(s[4]) {
   3116                     default:
   3117                         break;
   3118                     case 'b':
   3119                         if (strcmp("its", s + 5) == 0)
   3120                             return PIDX_CIPHER_PARAM_USE_BITS;
   3121                         break;
   3122                     case 'c':
   3123                         if (strcmp("ofactor-flag", s + 5) == 0)
   3124                             return PIDX_PKEY_PARAM_USE_COFACTOR_FLAG;
   3125                         break;
   3126                     case 'k':
   3127                         if (strcmp("eybits", s + 5) == 0)
   3128                             return PIDX_KDF_PARAM_X942_USE_KEYBITS;
   3129                         break;
   3130                     case 'l':
   3131                         switch(s[5]) {
   3132                         default:
   3133                             break;
   3134                         case '\0':
   3135                             return PIDX_KDF_PARAM_KBKDF_USE_L;
   3136                         }
   3137                         break;
   3138                     case 's':
   3139                         if (strcmp("eparator", s + 5) == 0)
   3140                             return PIDX_KDF_PARAM_KBKDF_USE_SEPARATOR;
   3141                     }
   3142                     break;
   3143                 case '_':
   3144                     switch(s[4]) {
   3145                     default:
   3146                         break;
   3147                     case 'd':
   3148                         if (strcmp("erivation_function", s + 5) == 0)
   3149                             return PIDX_DRBG_PARAM_USE_DF;
   3150                         break;
   3151                     case 'e':
   3152                         if (strcmp("tm", s + 5) == 0)
   3153                             return PIDX_LIBSSL_RECORD_LAYER_PARAM_USE_ETM;
   3154                     }
   3155                 }
   3156             }
   3157         }
   3158         break;
   3159     case 'v':
   3160         switch(s[1]) {
   3161         default:
   3162             break;
   3163         case 'a':
   3164             switch(s[2]) {
   3165             default:
   3166                 break;
   3167             case 'l':
   3168                 switch(s[3]) {
   3169                 default:
   3170                     break;
   3171                 case 'i':
   3172                     switch(s[4]) {
   3173                     default:
   3174                         break;
   3175                     case 'd':
   3176                         switch(s[5]) {
   3177                         default:
   3178                             break;
   3179                         case 'a':
   3180                             switch(s[6]) {
   3181                             default:
   3182                                 break;
   3183                             case 't':
   3184                                 switch(s[7]) {
   3185                                 default:
   3186                                     break;
   3187                                 case 'e':
   3188                                     switch(s[8]) {
   3189                                     default:
   3190                                         break;
   3191                                     case '-':
   3192                                         switch(s[9]) {
   3193                                         default:
   3194                                             break;
   3195                                         case 'g':
   3196                                             switch(s[10]) {
   3197                                             default:
   3198                                                 break;
   3199                                             case '\0':
   3200                                                 return PIDX_PKEY_PARAM_FFC_VALIDATE_G;
   3201                                             }
   3202                                             break;
   3203                                         case 'l':
   3204                                             if (strcmp("egacy", s + 10) == 0)
   3205                                                 return PIDX_PKEY_PARAM_FFC_VALIDATE_LEGACY;
   3206                                             break;
   3207                                         case 'p':
   3208                                             if (strcmp("q", s + 10) == 0)
   3209                                                 return PIDX_PKEY_PARAM_FFC_VALIDATE_PQ;
   3210                                         }
   3211                                     }
   3212                                 }
   3213                             }
   3214                         }
   3215                     }
   3216                 }
   3217             }
   3218             break;
   3219         case 'e':
   3220             switch(s[2]) {
   3221             default:
   3222                 break;
   3223             case 'r':
   3224                 switch(s[3]) {
   3225                 default:
   3226                     break;
   3227                 case 'i':
   3228                     if (strcmp("fy-message", s + 4) == 0)
   3229                         return PIDX_SIGNATURE_PARAM_FIPS_VERIFY_MESSAGE;
   3230                     break;
   3231                 case 's':
   3232                     if (strcmp("ion", s + 4) == 0)
   3233                         return PIDX_PROV_PARAM_VERSION;
   3234                 }
   3235             }
   3236         }
   3237         break;
   3238     case 'x':
   3239         switch(s[1]) {
   3240         default:
   3241             break;
   3242         case '9':
   3243             switch(s[2]) {
   3244             default:
   3245                 break;
   3246             case '4':
   3247                 if (strcmp("2kdf-key-check", s + 3) == 0)
   3248                     return PIDX_PROV_PARAM_X942KDF_KEY_CHECK;
   3249                 break;
   3250             case '6':
   3251                 switch(s[3]) {
   3252                 default:
   3253                     break;
   3254                 case '3':
   3255                     switch(s[4]) {
   3256                     default:
   3257                         break;
   3258                     case 'k':
   3259                         switch(s[5]) {
   3260                         default:
   3261                             break;
   3262                         case 'd':
   3263                             switch(s[6]) {
   3264                             default:
   3265                                 break;
   3266                             case 'f':
   3267                                 switch(s[7]) {
   3268                                 default:
   3269                                     break;
   3270                                 case '-':
   3271                                     switch(s[8]) {
   3272                                     default:
   3273                                         break;
   3274                                     case 'd':
   3275                                         if (strcmp("igest-check", s + 9) == 0)
   3276                                             return PIDX_PROV_PARAM_X963KDF_DIGEST_CHECK;
   3277                                         break;
   3278                                     case 'k':
   3279                                         if (strcmp("ey-check", s + 9) == 0)
   3280                                             return PIDX_PROV_PARAM_X963KDF_KEY_CHECK;
   3281                                     }
   3282                                 }
   3283                             }
   3284                         }
   3285                     }
   3286                 }
   3287             }
   3288             break;
   3289         case 'c':
   3290             if (strcmp("ghash", s + 2) == 0)
   3291                 return PIDX_KDF_PARAM_SSHKDF_XCGHASH;
   3292             break;
   3293         case 'o':
   3294             switch(s[2]) {
   3295             default:
   3296                 break;
   3297             case 'f':
   3298                 switch(s[3]) {
   3299                 default:
   3300                     break;
   3301                 case 'l':
   3302                     if (strcmp("en", s + 4) == 0)
   3303                         return PIDX_DIGEST_PARAM_XOFLEN;
   3304                     break;
   3305                 case '\0':
   3306                     return PIDX_MAC_PARAM_XOF;
   3307                 }
   3308             }
   3309             break;
   3310         case 'p':
   3311             switch(s[2]) {
   3312             default:
   3313                 break;
   3314             case '1':
   3315                 switch(s[3]) {
   3316                 default:
   3317                     break;
   3318                 case '\0':
   3319                     return PIDX_PKEY_PARAM_RSA_TEST_XP1;
   3320                 }
   3321                 break;
   3322             case '2':
   3323                 switch(s[3]) {
   3324                 default:
   3325                     break;
   3326                 case '\0':
   3327                     return PIDX_PKEY_PARAM_RSA_TEST_XP2;
   3328                 }
   3329                 break;
   3330             case '\0':
   3331                 return PIDX_PKEY_PARAM_RSA_TEST_XP;
   3332             }
   3333             break;
   3334         case 'q':
   3335             switch(s[2]) {
   3336             default:
   3337                 break;
   3338             case '1':
   3339                 switch(s[3]) {
   3340                 default:
   3341                     break;
   3342                 case '\0':
   3343                     return PIDX_PKEY_PARAM_RSA_TEST_XQ1;
   3344                 }
   3345                 break;
   3346             case '2':
   3347                 switch(s[3]) {
   3348                 default:
   3349                     break;
   3350                 case '\0':
   3351                     return PIDX_PKEY_PARAM_RSA_TEST_XQ2;
   3352                 }
   3353                 break;
   3354             case '\0':
   3355                 return PIDX_PKEY_PARAM_RSA_TEST_XQ;
   3356             }
   3357             break;
   3358         case 't':
   3359             if (strcmp("s_standard", s + 2) == 0)
   3360                 return PIDX_CIPHER_PARAM_XTS_STANDARD;
   3361         }
   3362     }
   3363     return -1;
   3364 }
   3365 
   3366 /* End of TRIE */
   3367