libsheepy

C lib for handling text files, strings and json like data structure with an object oriented system
git clone https://spartatek.se/git/libsheepy.git
Log | Files | Refs | README | LICENSE

libsheepyGenericsTest.c (313686B)

      1 #include "libsheepyObject.h"
      2 
      3 // the test is to compile the libsheepyObject.h generics, to run the test invoke gcc like this:
      4 // gcc -std=gnu11 -I ../release -o test.o -c libsheepyGenericsTest.c
      5 
      6 int main(int c, char **a) {
      7 {
      8   smallArrayt* self0;
      9   initiateG(self0);
     10   smallBoolt* self1;
     11   initiateG(self1);
     12   smallBytest* self2;
     13   initiateG(self2);
     14   smallContainert* self3;
     15   initiateG(self3);
     16   smallDictt* self4;
     17   initiateG(self4);
     18   smallDoublet* self5;
     19   initiateG(self5);
     20   smallIntt* self6;
     21   initiateG(self6);
     22   smallJsont* self7;
     23   initiateG(self7);
     24   smallStringt* self8;
     25   initiateG(self8);
     26   undefinedt* self9;
     27   initiateG(self9);
     28   smallArrayt** self10;
     29   initiateG(self10);
     30   smallBoolt** self11;
     31   initiateG(self11);
     32   smallBytest** self12;
     33   initiateG(self12);
     34   smallContainert** self13;
     35   initiateG(self13);
     36   smallDictt** self14;
     37   initiateG(self14);
     38   smallDoublet** self15;
     39   initiateG(self15);
     40   smallIntt** self16;
     41   initiateG(self16);
     42   smallJsont** self17;
     43   initiateG(self17);
     44   smallStringt** self18;
     45   initiateG(self18);
     46   undefinedt** self19;
     47   initiateG(self19);
     48 }
     49 {
     50   smallArrayt* value0;
     51   allocG(value0);
     52   bool value1;
     53   allocG(value1);
     54   void * value2;
     55   allocG(value2);
     56   smallDictt* value3;
     57   allocG(value3);
     58   double value4;
     59   allocG(value4);
     60   int64_t value5;
     61   allocG(value5);
     62   int32_t value6;
     63   allocG(value6);
     64   uint32_t value7;
     65   allocG(value7);
     66   uint64_t value8;
     67   allocG(value8);
     68   smallJsont* value9;
     69   allocG(value9);
     70   char * value10;
     71   allocG(value10);
     72   const char * value11;
     73   allocG(value11);
     74   char ** value12;
     75   allocG(value12);
     76   const char ** value13;
     77   allocG(value13);
     78 }
     79 {
     80   smallArrayt* self0;
     81   freeG(self0);
     82   smallBoolt* self1;
     83   freeG(self1);
     84   smallBytest* self2;
     85   freeG(self2);
     86   smallContainert* self3;
     87   freeG(self3);
     88   smallDictt* self4;
     89   freeG(self4);
     90   smallDoublet* self5;
     91   freeG(self5);
     92   smallIntt* self6;
     93   freeG(self6);
     94   smallJsont* self7;
     95   freeG(self7);
     96   smallStringt* self8;
     97   freeG(self8);
     98   undefinedt* self9;
     99   freeG(self9);
    100   char ** self10;
    101   freeG(self10);
    102   void* self11;
    103   freeG(self11);
    104 }
    105 {
    106   baset* obj0;
    107   getOTypeG(obj0);
    108   smallArrayt* obj1;
    109   getOTypeG(obj1);
    110   smallBoolt* obj2;
    111   getOTypeG(obj2);
    112   smallBytest* obj3;
    113   getOTypeG(obj3);
    114   smallDictt* obj4;
    115   getOTypeG(obj4);
    116   smallDoublet* obj5;
    117   getOTypeG(obj5);
    118   smallIntt* obj6;
    119   getOTypeG(obj6);
    120   smallJsont* obj7;
    121   getOTypeG(obj7);
    122   smallStringt* obj8;
    123   getOTypeG(obj8);
    124   smallContainert* obj9;
    125   getOTypeG(obj9);
    126   undefinedt* obj10;
    127   getOTypeG(obj10);
    128   bool obj11;
    129   getOTypeG(obj11);
    130   bool* obj12;
    131   getOTypeG(obj12);
    132   double obj13;
    133   getOTypeG(obj13);
    134   double* obj14;
    135   getOTypeG(obj14);
    136   float obj15;
    137   getOTypeG(obj15);
    138   float* obj16;
    139   getOTypeG(obj16);
    140   int64_t obj17;
    141   getOTypeG(obj17);
    142   int64_t* obj18;
    143   getOTypeG(obj18);
    144   int32_t obj19;
    145   getOTypeG(obj19);
    146   int32_t* obj20;
    147   getOTypeG(obj20);
    148   int16_t obj21;
    149   getOTypeG(obj21);
    150   int16_t* obj22;
    151   getOTypeG(obj22);
    152   int8_t obj23;
    153   getOTypeG(obj23);
    154   int8_t* obj24;
    155   getOTypeG(obj24);
    156   uint64_t obj25;
    157   getOTypeG(obj25);
    158   uint64_t* obj26;
    159   getOTypeG(obj26);
    160   uint32_t obj27;
    161   getOTypeG(obj27);
    162   uint32_t* obj28;
    163   getOTypeG(obj28);
    164   uint16_t obj29;
    165   getOTypeG(obj29);
    166   uint16_t* obj30;
    167   getOTypeG(obj30);
    168   uint8_t obj31;
    169   getOTypeG(obj31);
    170   uint8_t* obj32;
    171   getOTypeG(obj32);
    172   char obj33;
    173   getOTypeG(obj33);
    174   char* obj34;
    175   getOTypeG(obj34);
    176   const char* obj35;
    177   getOTypeG(obj35);
    178   char** obj36;
    179   getOTypeG(obj36);
    180   const char** obj37;
    181   getOTypeG(obj37);
    182   char*** obj38;
    183   getOTypeG(obj38);
    184   void* obj39;
    185   getOTypeG(obj39);
    186   FILE* obj40;
    187   getOTypeG(obj40);
    188   void* obj41;
    189   getOTypeG(obj41);
    190 }
    191 {
    192   smallArrayt* self1;
    193   char ** value0;
    194   setTopG(self1, value0);
    195   const char ** value1;
    196   setTopG(self1, value1);
    197   char ** value2;
    198   setTopG(self1, value2);
    199 }
    200 {
    201   smallBoolt* self2;
    202   bool value0;
    203   setTopG(self2, value0);
    204   double value1;
    205   setTopG(self2, value1);
    206   int64_t value2;
    207   setTopG(self2, value2);
    208   int32_t value3;
    209   setTopG(self2, value3);
    210   uint32_t value4;
    211   setTopG(self2, value4);
    212   uint64_t value5;
    213   setTopG(self2, value5);
    214   char* value6;
    215   setTopG(self2, value6);
    216   const char* value7;
    217   setTopG(self2, value7);
    218   smallBoolt* value8;
    219   setTopG(self2, value8);
    220   smallDoublet* value9;
    221   setTopG(self2, value9);
    222   smallIntt* value10;
    223   setTopG(self2, value10);
    224   smallJsont* value11;
    225   setTopG(self2, value11);
    226   smallStringt* value12;
    227   setTopG(self2, value12);
    228   bool value13;
    229   setTopG(self2, value13);
    230 }
    231 {
    232   smallContainert* self3;
    233   void * value0;
    234   setTopG(self3, value0);
    235 }
    236 {
    237   smallDoublet* self4;
    238   bool value0;
    239   setTopG(self4, value0);
    240   double value1;
    241   setTopG(self4, value1);
    242   int64_t value2;
    243   setTopG(self4, value2);
    244   int32_t value3;
    245   setTopG(self4, value3);
    246   uint32_t value4;
    247   setTopG(self4, value4);
    248   uint64_t value5;
    249   setTopG(self4, value5);
    250   char* value6;
    251   setTopG(self4, value6);
    252   const char* value7;
    253   setTopG(self4, value7);
    254   smallBoolt* value8;
    255   setTopG(self4, value8);
    256   smallDoublet* value9;
    257   setTopG(self4, value9);
    258   smallIntt* value10;
    259   setTopG(self4, value10);
    260   smallJsont* value11;
    261   setTopG(self4, value11);
    262   smallStringt* value12;
    263   setTopG(self4, value12);
    264   bool value13;
    265   setTopG(self4, value13);
    266 }
    267 {
    268   smallIntt* self5;
    269   bool value0;
    270   setTopG(self5, value0);
    271   double value1;
    272   setTopG(self5, value1);
    273   int64_t value2;
    274   setTopG(self5, value2);
    275   int32_t value3;
    276   setTopG(self5, value3);
    277   uint32_t value4;
    278   setTopG(self5, value4);
    279   uint64_t value5;
    280   setTopG(self5, value5);
    281   char* value6;
    282   setTopG(self5, value6);
    283   const char* value7;
    284   setTopG(self5, value7);
    285   smallBoolt* value8;
    286   setTopG(self5, value8);
    287   smallDoublet* value9;
    288   setTopG(self5, value9);
    289   smallIntt* value10;
    290   setTopG(self5, value10);
    291   smallJsont* value11;
    292   setTopG(self5, value11);
    293   smallStringt* value12;
    294   setTopG(self5, value12);
    295   bool value13;
    296   setTopG(self5, value13);
    297 }
    298 {
    299   smallStringt* self6;
    300   bool value0;
    301   setTopG(self6, value0);
    302   double value1;
    303   setTopG(self6, value1);
    304   int64_t value2;
    305   setTopG(self6, value2);
    306   int32_t value3;
    307   setTopG(self6, value3);
    308   uint32_t value4;
    309   setTopG(self6, value4);
    310   uint64_t value5;
    311   setTopG(self6, value5);
    312   char* value6;
    313   setTopG(self6, value6);
    314   char value7;
    315   setTopG(self6, value7);
    316   const char* value8;
    317   setTopG(self6, value8);
    318   smallArrayt* value9;
    319   setTopG(self6, value9);
    320   smallBoolt* value10;
    321   setTopG(self6, value10);
    322   smallDictt* value11;
    323   setTopG(self6, value11);
    324   smallDoublet* value12;
    325   setTopG(self6, value12);
    326   smallIntt* value13;
    327   setTopG(self6, value13);
    328   smallJsont* value14;
    329   setTopG(self6, value14);
    330   smallStringt* value15;
    331   setTopG(self6, value15);
    332   bool value16;
    333   setTopG(self6, value16);
    334 }
    335 {
    336   smallJsont* self7;
    337   baset* value0;
    338   setTopG(self7, value0);
    339   bool value1;
    340   setTopG(self7, value1);
    341   double value2;
    342   setTopG(self7, value2);
    343   int64_t value3;
    344   setTopG(self7, value3);
    345   int32_t value4;
    346   setTopG(self7, value4);
    347   uint64_t value5;
    348   setTopG(self7, value5);
    349   uint32_t value6;
    350   setTopG(self7, value6);
    351   char* value7;
    352   setTopG(self7, value7);
    353   char value8;
    354   setTopG(self7, value8);
    355   const char* value9;
    356   setTopG(self7, value9);
    357   char ** value10;
    358   setTopG(self7, value10);
    359   const char ** value11;
    360   setTopG(self7, value11);
    361   smallArrayt* value12;
    362   setTopG(self7, value12);
    363   smallBoolt* value13;
    364   setTopG(self7, value13);
    365   smallDictt* value14;
    366   setTopG(self7, value14);
    367   smallDoublet* value15;
    368   setTopG(self7, value15);
    369   smallIntt* value16;
    370   setTopG(self7, value16);
    371   smallJsont* value17;
    372   setTopG(self7, value17);
    373   smallStringt* value18;
    374   setTopG(self7, value18);
    375   baset * value19;
    376   setTopG(self7, value19);
    377 }
    378 {
    379   smallJsont* self1;
    380   baset* value0;
    381   setTopNFreeG(self1, value0);
    382   bool value1;
    383   setTopNFreeG(self1, value1);
    384   double value2;
    385   setTopNFreeG(self1, value2);
    386   int64_t value3;
    387   setTopNFreeG(self1, value3);
    388   char* value4;
    389   setTopNFreeG(self1, value4);
    390   smallDictt* value5;
    391   setTopNFreeG(self1, value5);
    392   smallArrayt* value6;
    393   setTopNFreeG(self1, value6);
    394   char ** value7;
    395   setTopNFreeG(self1, value7);
    396   smallBoolt* value8;
    397   setTopNFreeG(self1, value8);
    398   smallDoublet* value9;
    399   setTopNFreeG(self1, value9);
    400   smallIntt* value10;
    401   setTopNFreeG(self1, value10);
    402   smallJsont* value11;
    403   setTopNFreeG(self1, value11);
    404   smallStringt* value12;
    405   setTopNFreeG(self1, value12);
    406 }
    407 {
    408   smallJsont* self1;
    409   baset* returnType0;
    410   getTopG(self1, returnType0);
    411   undefinedt* returnType1;
    412   getTopG(self1, returnType1);
    413   bool returnType2;
    414   getTopG(self1, returnType2);
    415   bool* returnType3;
    416   getTopG(self1, returnType3);
    417   double returnType4;
    418   getTopG(self1, returnType4);
    419   double* returnType5;
    420   getTopG(self1, returnType5);
    421   int64_t returnType6;
    422   getTopG(self1, returnType6);
    423   int64_t* returnType7;
    424   getTopG(self1, returnType7);
    425   int32_t returnType8;
    426   getTopG(self1, returnType8);
    427   int32_t* returnType9;
    428   getTopG(self1, returnType9);
    429   uint64_t returnType10;
    430   getTopG(self1, returnType10);
    431   uint64_t* returnType11;
    432   getTopG(self1, returnType11);
    433   uint32_t returnType12;
    434   getTopG(self1, returnType12);
    435   uint32_t* returnType13;
    436   getTopG(self1, returnType13);
    437   char* returnType14;
    438   getTopG(self1, returnType14);
    439   smallDictt* returnType15;
    440   getTopG(self1, returnType15);
    441   smallArrayt* returnType16;
    442   getTopG(self1, returnType16);
    443   smallBoolt* returnType17;
    444   getTopG(self1, returnType17);
    445   smallDoublet* returnType18;
    446   getTopG(self1, returnType18);
    447   smallIntt* returnType19;
    448   getTopG(self1, returnType19);
    449   smallStringt* returnType20;
    450   getTopG(self1, returnType20);
    451 }
    452 {
    453   smallArrayt* self1;
    454   baset* value0;
    455   pushG(self1, value0);
    456   bool value1;
    457   pushG(self1, value1);
    458   double value2;
    459   pushG(self1, value2);
    460   int64_t value3;
    461   pushG(self1, value3);
    462   int32_t value4;
    463   pushG(self1, value4);
    464   uint32_t value5;
    465   pushG(self1, value5);
    466   uint64_t value6;
    467   pushG(self1, value6);
    468   char* value7;
    469   pushG(self1, value7);
    470   char value8;
    471   pushG(self1, value8);
    472   const char* value9;
    473   pushG(self1, value9);
    474   smallDictt* value10;
    475   pushG(self1, value10);
    476   smallArrayt* value11;
    477   pushG(self1, value11);
    478   char** value12;
    479   pushG(self1, value12);
    480   const char** value13;
    481   pushG(self1, value13);
    482   smallBoolt* value14;
    483   pushG(self1, value14);
    484   smallBytest* value15;
    485   pushG(self1, value15);
    486   smallDoublet* value16;
    487   pushG(self1, value16);
    488   smallIntt* value17;
    489   pushG(self1, value17);
    490   smallJsont* value18;
    491   pushG(self1, value18);
    492   smallStringt* value19;
    493   pushG(self1, value19);
    494   smallContainert* value20;
    495   pushG(self1, value20);
    496   undefinedt* value21;
    497   pushG(self1, value21);
    498   void * value22;
    499   pushG(self1, value22);
    500 }
    501 {
    502   smallJsont* self2;
    503   baset* value0;
    504   pushG(self2, value0);
    505   bool value1;
    506   pushG(self2, value1);
    507   double value2;
    508   pushG(self2, value2);
    509   int64_t value3;
    510   pushG(self2, value3);
    511   int32_t value4;
    512   pushG(self2, value4);
    513   uint32_t value5;
    514   pushG(self2, value5);
    515   uint64_t value6;
    516   pushG(self2, value6);
    517   char* value7;
    518   pushG(self2, value7);
    519   char value8;
    520   pushG(self2, value8);
    521   const char* value9;
    522   pushG(self2, value9);
    523   smallDictt* value10;
    524   pushG(self2, value10);
    525   smallArrayt* value11;
    526   pushG(self2, value11);
    527   char ** value12;
    528   pushG(self2, value12);
    529   const char ** value13;
    530   pushG(self2, value13);
    531   smallBoolt* value14;
    532   pushG(self2, value14);
    533   smallBytest* value15;
    534   pushG(self2, value15);
    535   smallDoublet* value16;
    536   pushG(self2, value16);
    537   smallIntt* value17;
    538   pushG(self2, value17);
    539   smallJsont* value18;
    540   pushG(self2, value18);
    541   smallStringt* value19;
    542   pushG(self2, value19);
    543   smallContainert* value20;
    544   pushG(self2, value20);
    545   undefinedt* value21;
    546   pushG(self2, value21);
    547   void * value22;
    548   pushG(self2, value22);
    549 }
    550 {
    551   smallBytest* self3;
    552   char value0;
    553   pushG(self3, value0);
    554 }
    555 {
    556   smallStringt* self4;
    557   smallStringt* value0;
    558   pushG(self4, value0);
    559   smallJsont* value1;
    560   pushG(self4, value1);
    561   char * value2;
    562   pushG(self4, value2);
    563   const char * value3;
    564   pushG(self4, value3);
    565   char value4;
    566   pushG(self4, value4);
    567   int value5;
    568   pushG(self4, value5);
    569   const char * value6;
    570   pushG(self4, value6);
    571 }
    572 {
    573   char ** self5;
    574   char * value0;
    575   pushG(self5, value0);
    576   const char * value1;
    577   pushG(self5, value1);
    578   char value2;
    579   pushG(self5, value2);
    580   int value3;
    581   pushG(self5, value3);
    582   const char * value4;
    583   pushG(self5, value4);
    584 }
    585 {
    586   char *** self6;
    587   char * value0;
    588   pushG(self6, value0);
    589   const char * value1;
    590   pushG(self6, value1);
    591   char value2;
    592   pushG(self6, value2);
    593   int value3;
    594   pushG(self6, value3);
    595   const char * value4;
    596   pushG(self6, value4);
    597 }
    598 {
    599   smallArrayt* self1;
    600   baset* value0;
    601   pushNFreeG(self1, value0);
    602   bool value1;
    603   pushNFreeG(self1, value1);
    604   double value2;
    605   pushNFreeG(self1, value2);
    606   int64_t value3;
    607   pushNFreeG(self1, value3);
    608   int32_t value4;
    609   pushNFreeG(self1, value4);
    610   uint32_t value5;
    611   pushNFreeG(self1, value5);
    612   uint64_t value6;
    613   pushNFreeG(self1, value6);
    614   char* value7;
    615   pushNFreeG(self1, value7);
    616   char value8;
    617   pushNFreeG(self1, value8);
    618   smallDictt* value9;
    619   pushNFreeG(self1, value9);
    620   smallArrayt* value10;
    621   pushNFreeG(self1, value10);
    622   char** value11;
    623   pushNFreeG(self1, value11);
    624   smallBoolt* value12;
    625   pushNFreeG(self1, value12);
    626   smallBytest* value13;
    627   pushNFreeG(self1, value13);
    628   smallDoublet* value14;
    629   pushNFreeG(self1, value14);
    630   smallIntt* value15;
    631   pushNFreeG(self1, value15);
    632   smallJsont* value16;
    633   pushNFreeG(self1, value16);
    634   smallStringt* value17;
    635   pushNFreeG(self1, value17);
    636   smallContainert* value18;
    637   pushNFreeG(self1, value18);
    638   undefinedt* value19;
    639   pushNFreeG(self1, value19);
    640   void * value20;
    641   pushNFreeG(self1, value20);
    642 }
    643 {
    644   smallJsont* self2;
    645   baset* value0;
    646   pushNFreeG(self2, value0);
    647   bool value1;
    648   pushNFreeG(self2, value1);
    649   double value2;
    650   pushNFreeG(self2, value2);
    651   int64_t value3;
    652   pushNFreeG(self2, value3);
    653   int32_t value4;
    654   pushNFreeG(self2, value4);
    655   uint32_t value5;
    656   pushNFreeG(self2, value5);
    657   uint64_t value6;
    658   pushNFreeG(self2, value6);
    659   char* value7;
    660   pushNFreeG(self2, value7);
    661   char value8;
    662   pushNFreeG(self2, value8);
    663   smallDictt* value9;
    664   pushNFreeG(self2, value9);
    665   smallArrayt* value10;
    666   pushNFreeG(self2, value10);
    667   char ** value11;
    668   pushNFreeG(self2, value11);
    669   smallBoolt* value12;
    670   pushNFreeG(self2, value12);
    671   smallBytest* value13;
    672   pushNFreeG(self2, value13);
    673   smallDoublet* value14;
    674   pushNFreeG(self2, value14);
    675   smallIntt* value15;
    676   pushNFreeG(self2, value15);
    677   smallJsont* value16;
    678   pushNFreeG(self2, value16);
    679   smallStringt* value17;
    680   pushNFreeG(self2, value17);
    681   smallContainert* value18;
    682   pushNFreeG(self2, value18);
    683   undefinedt* value19;
    684   pushNFreeG(self2, value19);
    685   void * value20;
    686   pushNFreeG(self2, value20);
    687 }
    688 {
    689   smallBytest* self3;
    690   char value0;
    691   pushNFreeG(self3, value0);
    692 }
    693 {
    694   smallStringt* self4;
    695   smallStringt* value0;
    696   pushNFreeG(self4, value0);
    697   smallJsont* value1;
    698   pushNFreeG(self4, value1);
    699   char * value2;
    700   pushNFreeG(self4, value2);
    701   char value3;
    702   pushNFreeG(self4, value3);
    703   int value4;
    704   pushNFreeG(self4, value4);
    705   char * value5;
    706   pushNFreeG(self4, value5);
    707 }
    708 {
    709   char ** self5;
    710   char * value0;
    711   pushNFreeG(self5, value0);
    712   char value1;
    713   pushNFreeG(self5, value1);
    714   int value2;
    715   pushNFreeG(self5, value2);
    716   char * value3;
    717   pushNFreeG(self5, value3);
    718 }
    719 {
    720   char *** self6;
    721   char * value0;
    722   pushNFreeG(self6, value0);
    723   char value1;
    724   pushNFreeG(self6, value1);
    725   int value2;
    726   pushNFreeG(self6, value2);
    727   char * value3;
    728   pushNFreeG(self6, value3);
    729 }
    730 {
    731   smallDictt* self1;
    732   char * key1;
    733   baset* value0;
    734   setG(self1, key1, value0);
    735   bool value1;
    736   setG(self1, key1, value1);
    737   double value2;
    738   setG(self1, key1, value2);
    739   int64_t value3;
    740   setG(self1, key1, value3);
    741   int32_t value4;
    742   setG(self1, key1, value4);
    743   uint32_t value5;
    744   setG(self1, key1, value5);
    745   uint64_t value6;
    746   setG(self1, key1, value6);
    747   char* value7;
    748   setG(self1, key1, value7);
    749   const char* value8;
    750   setG(self1, key1, value8);
    751   char value9;
    752   setG(self1, key1, value9);
    753   smallDictt* value10;
    754   setG(self1, key1, value10);
    755   smallArrayt* value11;
    756   setG(self1, key1, value11);
    757   char ** value12;
    758   setG(self1, key1, value12);
    759   const char ** value13;
    760   setG(self1, key1, value13);
    761   smallBoolt* value14;
    762   setG(self1, key1, value14);
    763   smallBytest* value15;
    764   setG(self1, key1, value15);
    765   smallDoublet* value16;
    766   setG(self1, key1, value16);
    767   smallIntt* value17;
    768   setG(self1, key1, value17);
    769   smallJsont* value18;
    770   setG(self1, key1, value18);
    771   smallStringt* value19;
    772   setG(self1, key1, value19);
    773   smallContainert* value20;
    774   setG(self1, key1, value20);
    775   undefinedt* value21;
    776   setG(self1, key1, value21);
    777   void * value22;
    778   setG(self1, key1, value22);
    779 }
    780 {
    781   smallDictt* self1;
    782   const char * key2;
    783   baset* value0;
    784   setG(self1, key2, value0);
    785   bool value1;
    786   setG(self1, key2, value1);
    787   double value2;
    788   setG(self1, key2, value2);
    789   int64_t value3;
    790   setG(self1, key2, value3);
    791   int32_t value4;
    792   setG(self1, key2, value4);
    793   uint32_t value5;
    794   setG(self1, key2, value5);
    795   uint64_t value6;
    796   setG(self1, key2, value6);
    797   char* value7;
    798   setG(self1, key2, value7);
    799   const char* value8;
    800   setG(self1, key2, value8);
    801   char value9;
    802   setG(self1, key2, value9);
    803   smallDictt* value10;
    804   setG(self1, key2, value10);
    805   smallArrayt* value11;
    806   setG(self1, key2, value11);
    807   char ** value12;
    808   setG(self1, key2, value12);
    809   const char ** value13;
    810   setG(self1, key2, value13);
    811   smallBoolt* value14;
    812   setG(self1, key2, value14);
    813   smallBytest* value15;
    814   setG(self1, key2, value15);
    815   smallDoublet* value16;
    816   setG(self1, key2, value16);
    817   smallIntt* value17;
    818   setG(self1, key2, value17);
    819   smallJsont* value18;
    820   setG(self1, key2, value18);
    821   smallStringt* value19;
    822   setG(self1, key2, value19);
    823   smallContainert* value20;
    824   setG(self1, key2, value20);
    825   undefinedt* value21;
    826   setG(self1, key2, value21);
    827   void * value22;
    828   setG(self1, key2, value22);
    829 }
    830 {
    831   smallDictt* self1;
    832   char key3;
    833   baset* value0;
    834   setG(self1, key3, value0);
    835   bool value1;
    836   setG(self1, key3, value1);
    837   double value2;
    838   setG(self1, key3, value2);
    839   int64_t value3;
    840   setG(self1, key3, value3);
    841   int32_t value4;
    842   setG(self1, key3, value4);
    843   uint32_t value5;
    844   setG(self1, key3, value5);
    845   uint64_t value6;
    846   setG(self1, key3, value6);
    847   char* value7;
    848   setG(self1, key3, value7);
    849   const char* value8;
    850   setG(self1, key3, value8);
    851   char value9;
    852   setG(self1, key3, value9);
    853   smallDictt* value10;
    854   setG(self1, key3, value10);
    855   smallArrayt* value11;
    856   setG(self1, key3, value11);
    857   char ** value12;
    858   setG(self1, key3, value12);
    859   const char ** value13;
    860   setG(self1, key3, value13);
    861   smallBoolt* value14;
    862   setG(self1, key3, value14);
    863   smallBytest* value15;
    864   setG(self1, key3, value15);
    865   smallDoublet* value16;
    866   setG(self1, key3, value16);
    867   smallIntt* value17;
    868   setG(self1, key3, value17);
    869   smallJsont* value18;
    870   setG(self1, key3, value18);
    871   smallStringt* value19;
    872   setG(self1, key3, value19);
    873   smallContainert* value20;
    874   setG(self1, key3, value20);
    875   undefinedt* value21;
    876   setG(self1, key3, value21);
    877   void * value22;
    878   setG(self1, key3, value22);
    879 }
    880 {
    881   smallDictt* self1;
    882   int key4;
    883   baset* value0;
    884   setG(self1, key4, value0);
    885   bool value1;
    886   setG(self1, key4, value1);
    887   double value2;
    888   setG(self1, key4, value2);
    889   int64_t value3;
    890   setG(self1, key4, value3);
    891   int32_t value4;
    892   setG(self1, key4, value4);
    893   uint32_t value5;
    894   setG(self1, key4, value5);
    895   uint64_t value6;
    896   setG(self1, key4, value6);
    897   char* value7;
    898   setG(self1, key4, value7);
    899   const char* value8;
    900   setG(self1, key4, value8);
    901   char value9;
    902   setG(self1, key4, value9);
    903   smallDictt* value10;
    904   setG(self1, key4, value10);
    905   smallArrayt* value11;
    906   setG(self1, key4, value11);
    907   char ** value12;
    908   setG(self1, key4, value12);
    909   const char ** value13;
    910   setG(self1, key4, value13);
    911   smallBoolt* value14;
    912   setG(self1, key4, value14);
    913   smallBytest* value15;
    914   setG(self1, key4, value15);
    915   smallDoublet* value16;
    916   setG(self1, key4, value16);
    917   smallIntt* value17;
    918   setG(self1, key4, value17);
    919   smallJsont* value18;
    920   setG(self1, key4, value18);
    921   smallStringt* value19;
    922   setG(self1, key4, value19);
    923   smallContainert* value20;
    924   setG(self1, key4, value20);
    925   undefinedt* value21;
    926   setG(self1, key4, value21);
    927   void * value22;
    928   setG(self1, key4, value22);
    929 }
    930 {
    931   smallDictt* self1;
    932   const char * key0;
    933   void * value0;
    934   setG(self1, key0, value0);
    935 }
    936 {
    937   smallArrayt* self2;
    938   int64_t key6;
    939   bool value0;
    940   setG(self2, key6, value0);
    941   double value1;
    942   setG(self2, key6, value1);
    943   int64_t value2;
    944   setG(self2, key6, value2);
    945   int32_t value3;
    946   setG(self2, key6, value3);
    947   uint32_t value4;
    948   setG(self2, key6, value4);
    949   uint64_t value5;
    950   setG(self2, key6, value5);
    951   char* value6;
    952   setG(self2, key6, value6);
    953   char value7;
    954   setG(self2, key6, value7);
    955   const char* value8;
    956   setG(self2, key6, value8);
    957   smallDictt* value9;
    958   setG(self2, key6, value9);
    959   smallArrayt* value10;
    960   setG(self2, key6, value10);
    961   char ** value11;
    962   setG(self2, key6, value11);
    963   const char ** value12;
    964   setG(self2, key6, value12);
    965   smallBoolt* value13;
    966   setG(self2, key6, value13);
    967   smallBytest* value14;
    968   setG(self2, key6, value14);
    969   smallDoublet* value15;
    970   setG(self2, key6, value15);
    971   smallIntt* value16;
    972   setG(self2, key6, value16);
    973   smallJsont* value17;
    974   setG(self2, key6, value17);
    975   smallStringt* value18;
    976   setG(self2, key6, value18);
    977   smallContainert* value19;
    978   setG(self2, key6, value19);
    979   undefinedt* value20;
    980   setG(self2, key6, value20);
    981   void * value21;
    982   setG(self2, key6, value21);
    983 }
    984 {
    985   smallJsont* self3;
    986   char * key7;
    987   baset* value0;
    988   setG(self3, key7, value0);
    989   bool value1;
    990   setG(self3, key7, value1);
    991   double value2;
    992   setG(self3, key7, value2);
    993   int64_t value3;
    994   setG(self3, key7, value3);
    995   int32_t value4;
    996   setG(self3, key7, value4);
    997   uint32_t value5;
    998   setG(self3, key7, value5);
    999   uint64_t value6;
   1000   setG(self3, key7, value6);
   1001   char* value7;
   1002   setG(self3, key7, value7);
   1003   const char* value8;
   1004   setG(self3, key7, value8);
   1005   char value9;
   1006   setG(self3, key7, value9);
   1007   smallDictt* value10;
   1008   setG(self3, key7, value10);
   1009   smallArrayt* value11;
   1010   setG(self3, key7, value11);
   1011   char ** value12;
   1012   setG(self3, key7, value12);
   1013   const char ** value13;
   1014   setG(self3, key7, value13);
   1015   smallBoolt* value14;
   1016   setG(self3, key7, value14);
   1017   smallBytest* value15;
   1018   setG(self3, key7, value15);
   1019   smallDoublet* value16;
   1020   setG(self3, key7, value16);
   1021   smallIntt* value17;
   1022   setG(self3, key7, value17);
   1023   smallJsont* value18;
   1024   setG(self3, key7, value18);
   1025   smallStringt* value19;
   1026   setG(self3, key7, value19);
   1027   smallContainert* value20;
   1028   setG(self3, key7, value20);
   1029   undefinedt* value21;
   1030   setG(self3, key7, value21);
   1031   void * value22;
   1032   setG(self3, key7, value22);
   1033 }
   1034 {
   1035   smallJsont* self3;
   1036   const char * key8;
   1037   baset* value0;
   1038   setG(self3, key8, value0);
   1039   bool value1;
   1040   setG(self3, key8, value1);
   1041   double value2;
   1042   setG(self3, key8, value2);
   1043   int64_t value3;
   1044   setG(self3, key8, value3);
   1045   int32_t value4;
   1046   setG(self3, key8, value4);
   1047   uint32_t value5;
   1048   setG(self3, key8, value5);
   1049   uint64_t value6;
   1050   setG(self3, key8, value6);
   1051   char* value7;
   1052   setG(self3, key8, value7);
   1053   const char* value8;
   1054   setG(self3, key8, value8);
   1055   char value9;
   1056   setG(self3, key8, value9);
   1057   smallDictt* value10;
   1058   setG(self3, key8, value10);
   1059   smallArrayt* value11;
   1060   setG(self3, key8, value11);
   1061   char ** value12;
   1062   setG(self3, key8, value12);
   1063   const char ** value13;
   1064   setG(self3, key8, value13);
   1065   smallBoolt* value14;
   1066   setG(self3, key8, value14);
   1067   smallBytest* value15;
   1068   setG(self3, key8, value15);
   1069   smallDoublet* value16;
   1070   setG(self3, key8, value16);
   1071   smallIntt* value17;
   1072   setG(self3, key8, value17);
   1073   smallJsont* value18;
   1074   setG(self3, key8, value18);
   1075   smallStringt* value19;
   1076   setG(self3, key8, value19);
   1077   smallContainert* value20;
   1078   setG(self3, key8, value20);
   1079   undefinedt* value21;
   1080   setG(self3, key8, value21);
   1081   void * value22;
   1082   setG(self3, key8, value22);
   1083 }
   1084 {
   1085   smallJsont* self3;
   1086   int64_t key9;
   1087   baset* value0;
   1088   setG(self3, key9, value0);
   1089   bool value1;
   1090   setG(self3, key9, value1);
   1091   double value2;
   1092   setG(self3, key9, value2);
   1093   int64_t value3;
   1094   setG(self3, key9, value3);
   1095   int32_t value4;
   1096   setG(self3, key9, value4);
   1097   uint32_t value5;
   1098   setG(self3, key9, value5);
   1099   uint64_t value6;
   1100   setG(self3, key9, value6);
   1101   char* value7;
   1102   setG(self3, key9, value7);
   1103   const char* value8;
   1104   setG(self3, key9, value8);
   1105   char value9;
   1106   setG(self3, key9, value9);
   1107   smallDictt* value10;
   1108   setG(self3, key9, value10);
   1109   smallArrayt* value11;
   1110   setG(self3, key9, value11);
   1111   char ** value12;
   1112   setG(self3, key9, value12);
   1113   const char ** value13;
   1114   setG(self3, key9, value13);
   1115   smallBoolt* value14;
   1116   setG(self3, key9, value14);
   1117   smallBytest* value15;
   1118   setG(self3, key9, value15);
   1119   smallDoublet* value16;
   1120   setG(self3, key9, value16);
   1121   smallIntt* value17;
   1122   setG(self3, key9, value17);
   1123   smallJsont* value18;
   1124   setG(self3, key9, value18);
   1125   smallStringt* value19;
   1126   setG(self3, key9, value19);
   1127   smallContainert* value20;
   1128   setG(self3, key9, value20);
   1129   undefinedt* value21;
   1130   setG(self3, key9, value21);
   1131   void * value22;
   1132   setG(self3, key9, value22);
   1133 }
   1134 {
   1135   smallJsont* self3;
   1136   int32_t key10;
   1137   baset* value0;
   1138   setG(self3, key10, value0);
   1139   bool value1;
   1140   setG(self3, key10, value1);
   1141   double value2;
   1142   setG(self3, key10, value2);
   1143   int64_t value3;
   1144   setG(self3, key10, value3);
   1145   int32_t value4;
   1146   setG(self3, key10, value4);
   1147   uint32_t value5;
   1148   setG(self3, key10, value5);
   1149   uint64_t value6;
   1150   setG(self3, key10, value6);
   1151   char* value7;
   1152   setG(self3, key10, value7);
   1153   const char* value8;
   1154   setG(self3, key10, value8);
   1155   char value9;
   1156   setG(self3, key10, value9);
   1157   smallDictt* value10;
   1158   setG(self3, key10, value10);
   1159   smallArrayt* value11;
   1160   setG(self3, key10, value11);
   1161   char ** value12;
   1162   setG(self3, key10, value12);
   1163   const char ** value13;
   1164   setG(self3, key10, value13);
   1165   smallBoolt* value14;
   1166   setG(self3, key10, value14);
   1167   smallBytest* value15;
   1168   setG(self3, key10, value15);
   1169   smallDoublet* value16;
   1170   setG(self3, key10, value16);
   1171   smallIntt* value17;
   1172   setG(self3, key10, value17);
   1173   smallJsont* value18;
   1174   setG(self3, key10, value18);
   1175   smallStringt* value19;
   1176   setG(self3, key10, value19);
   1177   smallContainert* value20;
   1178   setG(self3, key10, value20);
   1179   undefinedt* value21;
   1180   setG(self3, key10, value21);
   1181   void * value22;
   1182   setG(self3, key10, value22);
   1183 }
   1184 {
   1185   smallJsont* self3;
   1186   int16_t key11;
   1187   baset* value0;
   1188   setG(self3, key11, value0);
   1189   bool value1;
   1190   setG(self3, key11, value1);
   1191   double value2;
   1192   setG(self3, key11, value2);
   1193   int64_t value3;
   1194   setG(self3, key11, value3);
   1195   int32_t value4;
   1196   setG(self3, key11, value4);
   1197   uint32_t value5;
   1198   setG(self3, key11, value5);
   1199   uint64_t value6;
   1200   setG(self3, key11, value6);
   1201   char* value7;
   1202   setG(self3, key11, value7);
   1203   const char* value8;
   1204   setG(self3, key11, value8);
   1205   char value9;
   1206   setG(self3, key11, value9);
   1207   smallDictt* value10;
   1208   setG(self3, key11, value10);
   1209   smallArrayt* value11;
   1210   setG(self3, key11, value11);
   1211   char ** value12;
   1212   setG(self3, key11, value12);
   1213   const char ** value13;
   1214   setG(self3, key11, value13);
   1215   smallBoolt* value14;
   1216   setG(self3, key11, value14);
   1217   smallBytest* value15;
   1218   setG(self3, key11, value15);
   1219   smallDoublet* value16;
   1220   setG(self3, key11, value16);
   1221   smallIntt* value17;
   1222   setG(self3, key11, value17);
   1223   smallJsont* value18;
   1224   setG(self3, key11, value18);
   1225   smallStringt* value19;
   1226   setG(self3, key11, value19);
   1227   smallContainert* value20;
   1228   setG(self3, key11, value20);
   1229   undefinedt* value21;
   1230   setG(self3, key11, value21);
   1231   void * value22;
   1232   setG(self3, key11, value22);
   1233 }
   1234 {
   1235   smallJsont* self3;
   1236   int8_t key12;
   1237   baset* value0;
   1238   setG(self3, key12, value0);
   1239   bool value1;
   1240   setG(self3, key12, value1);
   1241   double value2;
   1242   setG(self3, key12, value2);
   1243   int64_t value3;
   1244   setG(self3, key12, value3);
   1245   int32_t value4;
   1246   setG(self3, key12, value4);
   1247   uint32_t value5;
   1248   setG(self3, key12, value5);
   1249   uint64_t value6;
   1250   setG(self3, key12, value6);
   1251   char* value7;
   1252   setG(self3, key12, value7);
   1253   const char* value8;
   1254   setG(self3, key12, value8);
   1255   char value9;
   1256   setG(self3, key12, value9);
   1257   smallDictt* value10;
   1258   setG(self3, key12, value10);
   1259   smallArrayt* value11;
   1260   setG(self3, key12, value11);
   1261   char ** value12;
   1262   setG(self3, key12, value12);
   1263   const char ** value13;
   1264   setG(self3, key12, value13);
   1265   smallBoolt* value14;
   1266   setG(self3, key12, value14);
   1267   smallBytest* value15;
   1268   setG(self3, key12, value15);
   1269   smallDoublet* value16;
   1270   setG(self3, key12, value16);
   1271   smallIntt* value17;
   1272   setG(self3, key12, value17);
   1273   smallJsont* value18;
   1274   setG(self3, key12, value18);
   1275   smallStringt* value19;
   1276   setG(self3, key12, value19);
   1277   smallContainert* value20;
   1278   setG(self3, key12, value20);
   1279   undefinedt* value21;
   1280   setG(self3, key12, value21);
   1281   void * value22;
   1282   setG(self3, key12, value22);
   1283 }
   1284 {
   1285   smallJsont* self3;
   1286   char key13;
   1287   baset* value0;
   1288   setG(self3, key13, value0);
   1289   bool value1;
   1290   setG(self3, key13, value1);
   1291   double value2;
   1292   setG(self3, key13, value2);
   1293   int64_t value3;
   1294   setG(self3, key13, value3);
   1295   int32_t value4;
   1296   setG(self3, key13, value4);
   1297   uint32_t value5;
   1298   setG(self3, key13, value5);
   1299   uint64_t value6;
   1300   setG(self3, key13, value6);
   1301   char* value7;
   1302   setG(self3, key13, value7);
   1303   const char* value8;
   1304   setG(self3, key13, value8);
   1305   char value9;
   1306   setG(self3, key13, value9);
   1307   smallDictt* value10;
   1308   setG(self3, key13, value10);
   1309   smallArrayt* value11;
   1310   setG(self3, key13, value11);
   1311   char ** value12;
   1312   setG(self3, key13, value12);
   1313   const char ** value13;
   1314   setG(self3, key13, value13);
   1315   smallBoolt* value14;
   1316   setG(self3, key13, value14);
   1317   smallBytest* value15;
   1318   setG(self3, key13, value15);
   1319   smallDoublet* value16;
   1320   setG(self3, key13, value16);
   1321   smallIntt* value17;
   1322   setG(self3, key13, value17);
   1323   smallJsont* value18;
   1324   setG(self3, key13, value18);
   1325   smallStringt* value19;
   1326   setG(self3, key13, value19);
   1327   smallContainert* value20;
   1328   setG(self3, key13, value20);
   1329   undefinedt* value21;
   1330   setG(self3, key13, value21);
   1331   void * value22;
   1332   setG(self3, key13, value22);
   1333 }
   1334 {
   1335   smallJsont* self3;
   1336   uint64_t key14;
   1337   baset* value0;
   1338   setG(self3, key14, value0);
   1339   bool value1;
   1340   setG(self3, key14, value1);
   1341   double value2;
   1342   setG(self3, key14, value2);
   1343   int64_t value3;
   1344   setG(self3, key14, value3);
   1345   int32_t value4;
   1346   setG(self3, key14, value4);
   1347   uint32_t value5;
   1348   setG(self3, key14, value5);
   1349   uint64_t value6;
   1350   setG(self3, key14, value6);
   1351   char* value7;
   1352   setG(self3, key14, value7);
   1353   const char* value8;
   1354   setG(self3, key14, value8);
   1355   char value9;
   1356   setG(self3, key14, value9);
   1357   smallDictt* value10;
   1358   setG(self3, key14, value10);
   1359   smallArrayt* value11;
   1360   setG(self3, key14, value11);
   1361   char ** value12;
   1362   setG(self3, key14, value12);
   1363   const char ** value13;
   1364   setG(self3, key14, value13);
   1365   smallBoolt* value14;
   1366   setG(self3, key14, value14);
   1367   smallBytest* value15;
   1368   setG(self3, key14, value15);
   1369   smallDoublet* value16;
   1370   setG(self3, key14, value16);
   1371   smallIntt* value17;
   1372   setG(self3, key14, value17);
   1373   smallJsont* value18;
   1374   setG(self3, key14, value18);
   1375   smallStringt* value19;
   1376   setG(self3, key14, value19);
   1377   smallContainert* value20;
   1378   setG(self3, key14, value20);
   1379   undefinedt* value21;
   1380   setG(self3, key14, value21);
   1381   void * value22;
   1382   setG(self3, key14, value22);
   1383 }
   1384 {
   1385   smallJsont* self3;
   1386   uint32_t key15;
   1387   baset* value0;
   1388   setG(self3, key15, value0);
   1389   bool value1;
   1390   setG(self3, key15, value1);
   1391   double value2;
   1392   setG(self3, key15, value2);
   1393   int64_t value3;
   1394   setG(self3, key15, value3);
   1395   int32_t value4;
   1396   setG(self3, key15, value4);
   1397   uint32_t value5;
   1398   setG(self3, key15, value5);
   1399   uint64_t value6;
   1400   setG(self3, key15, value6);
   1401   char* value7;
   1402   setG(self3, key15, value7);
   1403   const char* value8;
   1404   setG(self3, key15, value8);
   1405   char value9;
   1406   setG(self3, key15, value9);
   1407   smallDictt* value10;
   1408   setG(self3, key15, value10);
   1409   smallArrayt* value11;
   1410   setG(self3, key15, value11);
   1411   char ** value12;
   1412   setG(self3, key15, value12);
   1413   const char ** value13;
   1414   setG(self3, key15, value13);
   1415   smallBoolt* value14;
   1416   setG(self3, key15, value14);
   1417   smallBytest* value15;
   1418   setG(self3, key15, value15);
   1419   smallDoublet* value16;
   1420   setG(self3, key15, value16);
   1421   smallIntt* value17;
   1422   setG(self3, key15, value17);
   1423   smallJsont* value18;
   1424   setG(self3, key15, value18);
   1425   smallStringt* value19;
   1426   setG(self3, key15, value19);
   1427   smallContainert* value20;
   1428   setG(self3, key15, value20);
   1429   undefinedt* value21;
   1430   setG(self3, key15, value21);
   1431   void * value22;
   1432   setG(self3, key15, value22);
   1433 }
   1434 {
   1435   smallJsont* self3;
   1436   uint16_t key16;
   1437   baset* value0;
   1438   setG(self3, key16, value0);
   1439   bool value1;
   1440   setG(self3, key16, value1);
   1441   double value2;
   1442   setG(self3, key16, value2);
   1443   int64_t value3;
   1444   setG(self3, key16, value3);
   1445   int32_t value4;
   1446   setG(self3, key16, value4);
   1447   uint32_t value5;
   1448   setG(self3, key16, value5);
   1449   uint64_t value6;
   1450   setG(self3, key16, value6);
   1451   char* value7;
   1452   setG(self3, key16, value7);
   1453   const char* value8;
   1454   setG(self3, key16, value8);
   1455   char value9;
   1456   setG(self3, key16, value9);
   1457   smallDictt* value10;
   1458   setG(self3, key16, value10);
   1459   smallArrayt* value11;
   1460   setG(self3, key16, value11);
   1461   char ** value12;
   1462   setG(self3, key16, value12);
   1463   const char ** value13;
   1464   setG(self3, key16, value13);
   1465   smallBoolt* value14;
   1466   setG(self3, key16, value14);
   1467   smallBytest* value15;
   1468   setG(self3, key16, value15);
   1469   smallDoublet* value16;
   1470   setG(self3, key16, value16);
   1471   smallIntt* value17;
   1472   setG(self3, key16, value17);
   1473   smallJsont* value18;
   1474   setG(self3, key16, value18);
   1475   smallStringt* value19;
   1476   setG(self3, key16, value19);
   1477   smallContainert* value20;
   1478   setG(self3, key16, value20);
   1479   undefinedt* value21;
   1480   setG(self3, key16, value21);
   1481   void * value22;
   1482   setG(self3, key16, value22);
   1483 }
   1484 {
   1485   smallJsont* self3;
   1486   uint8_t key17;
   1487   baset* value0;
   1488   setG(self3, key17, value0);
   1489   bool value1;
   1490   setG(self3, key17, value1);
   1491   double value2;
   1492   setG(self3, key17, value2);
   1493   int64_t value3;
   1494   setG(self3, key17, value3);
   1495   int32_t value4;
   1496   setG(self3, key17, value4);
   1497   uint32_t value5;
   1498   setG(self3, key17, value5);
   1499   uint64_t value6;
   1500   setG(self3, key17, value6);
   1501   char* value7;
   1502   setG(self3, key17, value7);
   1503   const char* value8;
   1504   setG(self3, key17, value8);
   1505   char value9;
   1506   setG(self3, key17, value9);
   1507   smallDictt* value10;
   1508   setG(self3, key17, value10);
   1509   smallArrayt* value11;
   1510   setG(self3, key17, value11);
   1511   char ** value12;
   1512   setG(self3, key17, value12);
   1513   const char ** value13;
   1514   setG(self3, key17, value13);
   1515   smallBoolt* value14;
   1516   setG(self3, key17, value14);
   1517   smallBytest* value15;
   1518   setG(self3, key17, value15);
   1519   smallDoublet* value16;
   1520   setG(self3, key17, value16);
   1521   smallIntt* value17;
   1522   setG(self3, key17, value17);
   1523   smallJsont* value18;
   1524   setG(self3, key17, value18);
   1525   smallStringt* value19;
   1526   setG(self3, key17, value19);
   1527   smallContainert* value20;
   1528   setG(self3, key17, value20);
   1529   undefinedt* value21;
   1530   setG(self3, key17, value21);
   1531   void * value22;
   1532   setG(self3, key17, value22);
   1533 }
   1534 {
   1535   smallStringt* self4;
   1536   int64_t key18;
   1537   char value0;
   1538   setG(self4, key18, value0);
   1539 }
   1540 {
   1541   char * self5;
   1542   int64_t key19;
   1543   char value0;
   1544   setG(self5, key19, value0);
   1545 }
   1546 {
   1547   char ** self6;
   1548   int64_t key20;
   1549   char value0;
   1550   setG(self6, key20, value0);
   1551   int value1;
   1552   setG(self6, key20, value1);
   1553   char * value2;
   1554   setG(self6, key20, value2);
   1555 }
   1556 {
   1557   smallDictt* self1;
   1558   char* key1;
   1559   baset* value0;
   1560   setNFreeG(self1, key1, value0);
   1561   bool value1;
   1562   setNFreeG(self1, key1, value1);
   1563   double value2;
   1564   setNFreeG(self1, key1, value2);
   1565   int64_t value3;
   1566   setNFreeG(self1, key1, value3);
   1567   int32_t value4;
   1568   setNFreeG(self1, key1, value4);
   1569   uint32_t value5;
   1570   setNFreeG(self1, key1, value5);
   1571   uint64_t value6;
   1572   setNFreeG(self1, key1, value6);
   1573   char* value7;
   1574   setNFreeG(self1, key1, value7);
   1575   smallDictt* value8;
   1576   setNFreeG(self1, key1, value8);
   1577   smallArrayt* value9;
   1578   setNFreeG(self1, key1, value9);
   1579   char ** value10;
   1580   setNFreeG(self1, key1, value10);
   1581   smallBoolt* value11;
   1582   setNFreeG(self1, key1, value11);
   1583   smallBytest* value12;
   1584   setNFreeG(self1, key1, value12);
   1585   smallDoublet* value13;
   1586   setNFreeG(self1, key1, value13);
   1587   smallIntt* value14;
   1588   setNFreeG(self1, key1, value14);
   1589   smallJsont* value15;
   1590   setNFreeG(self1, key1, value15);
   1591   smallStringt* value16;
   1592   setNFreeG(self1, key1, value16);
   1593   smallContainert* value17;
   1594   setNFreeG(self1, key1, value17);
   1595   undefinedt* value18;
   1596   setNFreeG(self1, key1, value18);
   1597   void * value19;
   1598   setNFreeG(self1, key1, value19);
   1599 }
   1600 {
   1601   smallDictt* self1;
   1602   const char* key2;
   1603   baset* value0;
   1604   setNFreeG(self1, key2, value0);
   1605   bool value1;
   1606   setNFreeG(self1, key2, value1);
   1607   double value2;
   1608   setNFreeG(self1, key2, value2);
   1609   int64_t value3;
   1610   setNFreeG(self1, key2, value3);
   1611   int32_t value4;
   1612   setNFreeG(self1, key2, value4);
   1613   uint32_t value5;
   1614   setNFreeG(self1, key2, value5);
   1615   uint64_t value6;
   1616   setNFreeG(self1, key2, value6);
   1617   char* value7;
   1618   setNFreeG(self1, key2, value7);
   1619   smallDictt* value8;
   1620   setNFreeG(self1, key2, value8);
   1621   smallArrayt* value9;
   1622   setNFreeG(self1, key2, value9);
   1623   char ** value10;
   1624   setNFreeG(self1, key2, value10);
   1625   smallBoolt* value11;
   1626   setNFreeG(self1, key2, value11);
   1627   smallBytest* value12;
   1628   setNFreeG(self1, key2, value12);
   1629   smallDoublet* value13;
   1630   setNFreeG(self1, key2, value13);
   1631   smallIntt* value14;
   1632   setNFreeG(self1, key2, value14);
   1633   smallJsont* value15;
   1634   setNFreeG(self1, key2, value15);
   1635   smallStringt* value16;
   1636   setNFreeG(self1, key2, value16);
   1637   smallContainert* value17;
   1638   setNFreeG(self1, key2, value17);
   1639   undefinedt* value18;
   1640   setNFreeG(self1, key2, value18);
   1641   void * value19;
   1642   setNFreeG(self1, key2, value19);
   1643 }
   1644 {
   1645   smallDictt* self1;
   1646   char key3;
   1647   baset* value0;
   1648   setNFreeG(self1, key3, value0);
   1649   bool value1;
   1650   setNFreeG(self1, key3, value1);
   1651   double value2;
   1652   setNFreeG(self1, key3, value2);
   1653   int64_t value3;
   1654   setNFreeG(self1, key3, value3);
   1655   int32_t value4;
   1656   setNFreeG(self1, key3, value4);
   1657   uint32_t value5;
   1658   setNFreeG(self1, key3, value5);
   1659   uint64_t value6;
   1660   setNFreeG(self1, key3, value6);
   1661   char* value7;
   1662   setNFreeG(self1, key3, value7);
   1663   smallDictt* value8;
   1664   setNFreeG(self1, key3, value8);
   1665   smallArrayt* value9;
   1666   setNFreeG(self1, key3, value9);
   1667   char ** value10;
   1668   setNFreeG(self1, key3, value10);
   1669   smallBoolt* value11;
   1670   setNFreeG(self1, key3, value11);
   1671   smallBytest* value12;
   1672   setNFreeG(self1, key3, value12);
   1673   smallDoublet* value13;
   1674   setNFreeG(self1, key3, value13);
   1675   smallIntt* value14;
   1676   setNFreeG(self1, key3, value14);
   1677   smallJsont* value15;
   1678   setNFreeG(self1, key3, value15);
   1679   smallStringt* value16;
   1680   setNFreeG(self1, key3, value16);
   1681   smallContainert* value17;
   1682   setNFreeG(self1, key3, value17);
   1683   undefinedt* value18;
   1684   setNFreeG(self1, key3, value18);
   1685   void * value19;
   1686   setNFreeG(self1, key3, value19);
   1687 }
   1688 {
   1689   smallDictt* self1;
   1690   int key4;
   1691   baset* value0;
   1692   setNFreeG(self1, key4, value0);
   1693   bool value1;
   1694   setNFreeG(self1, key4, value1);
   1695   double value2;
   1696   setNFreeG(self1, key4, value2);
   1697   int64_t value3;
   1698   setNFreeG(self1, key4, value3);
   1699   int32_t value4;
   1700   setNFreeG(self1, key4, value4);
   1701   uint32_t value5;
   1702   setNFreeG(self1, key4, value5);
   1703   uint64_t value6;
   1704   setNFreeG(self1, key4, value6);
   1705   char* value7;
   1706   setNFreeG(self1, key4, value7);
   1707   smallDictt* value8;
   1708   setNFreeG(self1, key4, value8);
   1709   smallArrayt* value9;
   1710   setNFreeG(self1, key4, value9);
   1711   char ** value10;
   1712   setNFreeG(self1, key4, value10);
   1713   smallBoolt* value11;
   1714   setNFreeG(self1, key4, value11);
   1715   smallBytest* value12;
   1716   setNFreeG(self1, key4, value12);
   1717   smallDoublet* value13;
   1718   setNFreeG(self1, key4, value13);
   1719   smallIntt* value14;
   1720   setNFreeG(self1, key4, value14);
   1721   smallJsont* value15;
   1722   setNFreeG(self1, key4, value15);
   1723   smallStringt* value16;
   1724   setNFreeG(self1, key4, value16);
   1725   smallContainert* value17;
   1726   setNFreeG(self1, key4, value17);
   1727   undefinedt* value18;
   1728   setNFreeG(self1, key4, value18);
   1729   void * value19;
   1730   setNFreeG(self1, key4, value19);
   1731 }
   1732 {
   1733   smallDictt* self1;
   1734   const char * key0;
   1735   void * value0;
   1736   setNFreeG(self1, key0, value0);
   1737 }
   1738 {
   1739   smallArrayt* self2;
   1740   int64_t key6;
   1741   bool value0;
   1742   setNFreeG(self2, key6, value0);
   1743   double value1;
   1744   setNFreeG(self2, key6, value1);
   1745   int64_t value2;
   1746   setNFreeG(self2, key6, value2);
   1747   int32_t value3;
   1748   setNFreeG(self2, key6, value3);
   1749   uint32_t value4;
   1750   setNFreeG(self2, key6, value4);
   1751   uint64_t value5;
   1752   setNFreeG(self2, key6, value5);
   1753   char* value6;
   1754   setNFreeG(self2, key6, value6);
   1755   smallDictt* value7;
   1756   setNFreeG(self2, key6, value7);
   1757   smallArrayt* value8;
   1758   setNFreeG(self2, key6, value8);
   1759   char ** value9;
   1760   setNFreeG(self2, key6, value9);
   1761   smallBoolt* value10;
   1762   setNFreeG(self2, key6, value10);
   1763   smallBytest* value11;
   1764   setNFreeG(self2, key6, value11);
   1765   smallDoublet* value12;
   1766   setNFreeG(self2, key6, value12);
   1767   smallIntt* value13;
   1768   setNFreeG(self2, key6, value13);
   1769   smallJsont* value14;
   1770   setNFreeG(self2, key6, value14);
   1771   smallStringt* value15;
   1772   setNFreeG(self2, key6, value15);
   1773   smallContainert* value16;
   1774   setNFreeG(self2, key6, value16);
   1775   undefinedt* value17;
   1776   setNFreeG(self2, key6, value17);
   1777   void * value18;
   1778   setNFreeG(self2, key6, value18);
   1779 }
   1780 {
   1781   smallJsont* self3;
   1782   char * key7;
   1783   baset* value0;
   1784   setNFreeG(self3, key7, value0);
   1785   bool value1;
   1786   setNFreeG(self3, key7, value1);
   1787   double value2;
   1788   setNFreeG(self3, key7, value2);
   1789   int64_t value3;
   1790   setNFreeG(self3, key7, value3);
   1791   int32_t value4;
   1792   setNFreeG(self3, key7, value4);
   1793   uint32_t value5;
   1794   setNFreeG(self3, key7, value5);
   1795   uint64_t value6;
   1796   setNFreeG(self3, key7, value6);
   1797   char* value7;
   1798   setNFreeG(self3, key7, value7);
   1799   smallDictt* value8;
   1800   setNFreeG(self3, key7, value8);
   1801   smallArrayt* value9;
   1802   setNFreeG(self3, key7, value9);
   1803   char ** value10;
   1804   setNFreeG(self3, key7, value10);
   1805   smallBoolt* value11;
   1806   setNFreeG(self3, key7, value11);
   1807   smallBytest* value12;
   1808   setNFreeG(self3, key7, value12);
   1809   smallDoublet* value13;
   1810   setNFreeG(self3, key7, value13);
   1811   smallIntt* value14;
   1812   setNFreeG(self3, key7, value14);
   1813   smallJsont* value15;
   1814   setNFreeG(self3, key7, value15);
   1815   smallStringt* value16;
   1816   setNFreeG(self3, key7, value16);
   1817   smallContainert* value17;
   1818   setNFreeG(self3, key7, value17);
   1819   undefinedt* value18;
   1820   setNFreeG(self3, key7, value18);
   1821   void * value19;
   1822   setNFreeG(self3, key7, value19);
   1823 }
   1824 {
   1825   smallJsont* self3;
   1826   const char * key8;
   1827   baset* value0;
   1828   setNFreeG(self3, key8, value0);
   1829   bool value1;
   1830   setNFreeG(self3, key8, value1);
   1831   double value2;
   1832   setNFreeG(self3, key8, value2);
   1833   int64_t value3;
   1834   setNFreeG(self3, key8, value3);
   1835   int32_t value4;
   1836   setNFreeG(self3, key8, value4);
   1837   uint32_t value5;
   1838   setNFreeG(self3, key8, value5);
   1839   uint64_t value6;
   1840   setNFreeG(self3, key8, value6);
   1841   char* value7;
   1842   setNFreeG(self3, key8, value7);
   1843   smallDictt* value8;
   1844   setNFreeG(self3, key8, value8);
   1845   smallArrayt* value9;
   1846   setNFreeG(self3, key8, value9);
   1847   char ** value10;
   1848   setNFreeG(self3, key8, value10);
   1849   smallBoolt* value11;
   1850   setNFreeG(self3, key8, value11);
   1851   smallBytest* value12;
   1852   setNFreeG(self3, key8, value12);
   1853   smallDoublet* value13;
   1854   setNFreeG(self3, key8, value13);
   1855   smallIntt* value14;
   1856   setNFreeG(self3, key8, value14);
   1857   smallJsont* value15;
   1858   setNFreeG(self3, key8, value15);
   1859   smallStringt* value16;
   1860   setNFreeG(self3, key8, value16);
   1861   smallContainert* value17;
   1862   setNFreeG(self3, key8, value17);
   1863   undefinedt* value18;
   1864   setNFreeG(self3, key8, value18);
   1865   void * value19;
   1866   setNFreeG(self3, key8, value19);
   1867 }
   1868 {
   1869   smallJsont* self3;
   1870   int64_t key9;
   1871   baset* value0;
   1872   setNFreeG(self3, key9, value0);
   1873   bool value1;
   1874   setNFreeG(self3, key9, value1);
   1875   double value2;
   1876   setNFreeG(self3, key9, value2);
   1877   int64_t value3;
   1878   setNFreeG(self3, key9, value3);
   1879   int32_t value4;
   1880   setNFreeG(self3, key9, value4);
   1881   uint32_t value5;
   1882   setNFreeG(self3, key9, value5);
   1883   uint64_t value6;
   1884   setNFreeG(self3, key9, value6);
   1885   char* value7;
   1886   setNFreeG(self3, key9, value7);
   1887   smallDictt* value8;
   1888   setNFreeG(self3, key9, value8);
   1889   smallArrayt* value9;
   1890   setNFreeG(self3, key9, value9);
   1891   char ** value10;
   1892   setNFreeG(self3, key9, value10);
   1893   smallBoolt* value11;
   1894   setNFreeG(self3, key9, value11);
   1895   smallBytest* value12;
   1896   setNFreeG(self3, key9, value12);
   1897   smallDoublet* value13;
   1898   setNFreeG(self3, key9, value13);
   1899   smallIntt* value14;
   1900   setNFreeG(self3, key9, value14);
   1901   smallJsont* value15;
   1902   setNFreeG(self3, key9, value15);
   1903   smallStringt* value16;
   1904   setNFreeG(self3, key9, value16);
   1905   smallContainert* value17;
   1906   setNFreeG(self3, key9, value17);
   1907   undefinedt* value18;
   1908   setNFreeG(self3, key9, value18);
   1909   void * value19;
   1910   setNFreeG(self3, key9, value19);
   1911 }
   1912 {
   1913   smallJsont* self3;
   1914   int32_t key10;
   1915   baset* value0;
   1916   setNFreeG(self3, key10, value0);
   1917   bool value1;
   1918   setNFreeG(self3, key10, value1);
   1919   double value2;
   1920   setNFreeG(self3, key10, value2);
   1921   int64_t value3;
   1922   setNFreeG(self3, key10, value3);
   1923   int32_t value4;
   1924   setNFreeG(self3, key10, value4);
   1925   uint32_t value5;
   1926   setNFreeG(self3, key10, value5);
   1927   uint64_t value6;
   1928   setNFreeG(self3, key10, value6);
   1929   char* value7;
   1930   setNFreeG(self3, key10, value7);
   1931   smallDictt* value8;
   1932   setNFreeG(self3, key10, value8);
   1933   smallArrayt* value9;
   1934   setNFreeG(self3, key10, value9);
   1935   char ** value10;
   1936   setNFreeG(self3, key10, value10);
   1937   smallBoolt* value11;
   1938   setNFreeG(self3, key10, value11);
   1939   smallBytest* value12;
   1940   setNFreeG(self3, key10, value12);
   1941   smallDoublet* value13;
   1942   setNFreeG(self3, key10, value13);
   1943   smallIntt* value14;
   1944   setNFreeG(self3, key10, value14);
   1945   smallJsont* value15;
   1946   setNFreeG(self3, key10, value15);
   1947   smallStringt* value16;
   1948   setNFreeG(self3, key10, value16);
   1949   smallContainert* value17;
   1950   setNFreeG(self3, key10, value17);
   1951   undefinedt* value18;
   1952   setNFreeG(self3, key10, value18);
   1953   void * value19;
   1954   setNFreeG(self3, key10, value19);
   1955 }
   1956 {
   1957   smallJsont* self3;
   1958   int16_t key11;
   1959   baset* value0;
   1960   setNFreeG(self3, key11, value0);
   1961   bool value1;
   1962   setNFreeG(self3, key11, value1);
   1963   double value2;
   1964   setNFreeG(self3, key11, value2);
   1965   int64_t value3;
   1966   setNFreeG(self3, key11, value3);
   1967   int32_t value4;
   1968   setNFreeG(self3, key11, value4);
   1969   uint32_t value5;
   1970   setNFreeG(self3, key11, value5);
   1971   uint64_t value6;
   1972   setNFreeG(self3, key11, value6);
   1973   char* value7;
   1974   setNFreeG(self3, key11, value7);
   1975   smallDictt* value8;
   1976   setNFreeG(self3, key11, value8);
   1977   smallArrayt* value9;
   1978   setNFreeG(self3, key11, value9);
   1979   char ** value10;
   1980   setNFreeG(self3, key11, value10);
   1981   smallBoolt* value11;
   1982   setNFreeG(self3, key11, value11);
   1983   smallBytest* value12;
   1984   setNFreeG(self3, key11, value12);
   1985   smallDoublet* value13;
   1986   setNFreeG(self3, key11, value13);
   1987   smallIntt* value14;
   1988   setNFreeG(self3, key11, value14);
   1989   smallJsont* value15;
   1990   setNFreeG(self3, key11, value15);
   1991   smallStringt* value16;
   1992   setNFreeG(self3, key11, value16);
   1993   smallContainert* value17;
   1994   setNFreeG(self3, key11, value17);
   1995   undefinedt* value18;
   1996   setNFreeG(self3, key11, value18);
   1997   void * value19;
   1998   setNFreeG(self3, key11, value19);
   1999 }
   2000 {
   2001   smallJsont* self3;
   2002   int8_t key12;
   2003   baset* value0;
   2004   setNFreeG(self3, key12, value0);
   2005   bool value1;
   2006   setNFreeG(self3, key12, value1);
   2007   double value2;
   2008   setNFreeG(self3, key12, value2);
   2009   int64_t value3;
   2010   setNFreeG(self3, key12, value3);
   2011   int32_t value4;
   2012   setNFreeG(self3, key12, value4);
   2013   uint32_t value5;
   2014   setNFreeG(self3, key12, value5);
   2015   uint64_t value6;
   2016   setNFreeG(self3, key12, value6);
   2017   char* value7;
   2018   setNFreeG(self3, key12, value7);
   2019   smallDictt* value8;
   2020   setNFreeG(self3, key12, value8);
   2021   smallArrayt* value9;
   2022   setNFreeG(self3, key12, value9);
   2023   char ** value10;
   2024   setNFreeG(self3, key12, value10);
   2025   smallBoolt* value11;
   2026   setNFreeG(self3, key12, value11);
   2027   smallBytest* value12;
   2028   setNFreeG(self3, key12, value12);
   2029   smallDoublet* value13;
   2030   setNFreeG(self3, key12, value13);
   2031   smallIntt* value14;
   2032   setNFreeG(self3, key12, value14);
   2033   smallJsont* value15;
   2034   setNFreeG(self3, key12, value15);
   2035   smallStringt* value16;
   2036   setNFreeG(self3, key12, value16);
   2037   smallContainert* value17;
   2038   setNFreeG(self3, key12, value17);
   2039   undefinedt* value18;
   2040   setNFreeG(self3, key12, value18);
   2041   void * value19;
   2042   setNFreeG(self3, key12, value19);
   2043 }
   2044 {
   2045   smallJsont* self3;
   2046   char key13;
   2047   baset* value0;
   2048   setNFreeG(self3, key13, value0);
   2049   bool value1;
   2050   setNFreeG(self3, key13, value1);
   2051   double value2;
   2052   setNFreeG(self3, key13, value2);
   2053   int64_t value3;
   2054   setNFreeG(self3, key13, value3);
   2055   int32_t value4;
   2056   setNFreeG(self3, key13, value4);
   2057   uint32_t value5;
   2058   setNFreeG(self3, key13, value5);
   2059   uint64_t value6;
   2060   setNFreeG(self3, key13, value6);
   2061   char* value7;
   2062   setNFreeG(self3, key13, value7);
   2063   smallDictt* value8;
   2064   setNFreeG(self3, key13, value8);
   2065   smallArrayt* value9;
   2066   setNFreeG(self3, key13, value9);
   2067   char ** value10;
   2068   setNFreeG(self3, key13, value10);
   2069   smallBoolt* value11;
   2070   setNFreeG(self3, key13, value11);
   2071   smallBytest* value12;
   2072   setNFreeG(self3, key13, value12);
   2073   smallDoublet* value13;
   2074   setNFreeG(self3, key13, value13);
   2075   smallIntt* value14;
   2076   setNFreeG(self3, key13, value14);
   2077   smallJsont* value15;
   2078   setNFreeG(self3, key13, value15);
   2079   smallStringt* value16;
   2080   setNFreeG(self3, key13, value16);
   2081   smallContainert* value17;
   2082   setNFreeG(self3, key13, value17);
   2083   undefinedt* value18;
   2084   setNFreeG(self3, key13, value18);
   2085   void * value19;
   2086   setNFreeG(self3, key13, value19);
   2087 }
   2088 {
   2089   smallJsont* self3;
   2090   uint64_t key14;
   2091   baset* value0;
   2092   setNFreeG(self3, key14, value0);
   2093   bool value1;
   2094   setNFreeG(self3, key14, value1);
   2095   double value2;
   2096   setNFreeG(self3, key14, value2);
   2097   int64_t value3;
   2098   setNFreeG(self3, key14, value3);
   2099   int32_t value4;
   2100   setNFreeG(self3, key14, value4);
   2101   uint32_t value5;
   2102   setNFreeG(self3, key14, value5);
   2103   uint64_t value6;
   2104   setNFreeG(self3, key14, value6);
   2105   char* value7;
   2106   setNFreeG(self3, key14, value7);
   2107   smallDictt* value8;
   2108   setNFreeG(self3, key14, value8);
   2109   smallArrayt* value9;
   2110   setNFreeG(self3, key14, value9);
   2111   char ** value10;
   2112   setNFreeG(self3, key14, value10);
   2113   smallBoolt* value11;
   2114   setNFreeG(self3, key14, value11);
   2115   smallBytest* value12;
   2116   setNFreeG(self3, key14, value12);
   2117   smallDoublet* value13;
   2118   setNFreeG(self3, key14, value13);
   2119   smallIntt* value14;
   2120   setNFreeG(self3, key14, value14);
   2121   smallJsont* value15;
   2122   setNFreeG(self3, key14, value15);
   2123   smallStringt* value16;
   2124   setNFreeG(self3, key14, value16);
   2125   smallContainert* value17;
   2126   setNFreeG(self3, key14, value17);
   2127   undefinedt* value18;
   2128   setNFreeG(self3, key14, value18);
   2129   void * value19;
   2130   setNFreeG(self3, key14, value19);
   2131 }
   2132 {
   2133   smallJsont* self3;
   2134   uint32_t key15;
   2135   baset* value0;
   2136   setNFreeG(self3, key15, value0);
   2137   bool value1;
   2138   setNFreeG(self3, key15, value1);
   2139   double value2;
   2140   setNFreeG(self3, key15, value2);
   2141   int64_t value3;
   2142   setNFreeG(self3, key15, value3);
   2143   int32_t value4;
   2144   setNFreeG(self3, key15, value4);
   2145   uint32_t value5;
   2146   setNFreeG(self3, key15, value5);
   2147   uint64_t value6;
   2148   setNFreeG(self3, key15, value6);
   2149   char* value7;
   2150   setNFreeG(self3, key15, value7);
   2151   smallDictt* value8;
   2152   setNFreeG(self3, key15, value8);
   2153   smallArrayt* value9;
   2154   setNFreeG(self3, key15, value9);
   2155   char ** value10;
   2156   setNFreeG(self3, key15, value10);
   2157   smallBoolt* value11;
   2158   setNFreeG(self3, key15, value11);
   2159   smallBytest* value12;
   2160   setNFreeG(self3, key15, value12);
   2161   smallDoublet* value13;
   2162   setNFreeG(self3, key15, value13);
   2163   smallIntt* value14;
   2164   setNFreeG(self3, key15, value14);
   2165   smallJsont* value15;
   2166   setNFreeG(self3, key15, value15);
   2167   smallStringt* value16;
   2168   setNFreeG(self3, key15, value16);
   2169   smallContainert* value17;
   2170   setNFreeG(self3, key15, value17);
   2171   undefinedt* value18;
   2172   setNFreeG(self3, key15, value18);
   2173   void * value19;
   2174   setNFreeG(self3, key15, value19);
   2175 }
   2176 {
   2177   smallJsont* self3;
   2178   uint16_t key16;
   2179   baset* value0;
   2180   setNFreeG(self3, key16, value0);
   2181   bool value1;
   2182   setNFreeG(self3, key16, value1);
   2183   double value2;
   2184   setNFreeG(self3, key16, value2);
   2185   int64_t value3;
   2186   setNFreeG(self3, key16, value3);
   2187   int32_t value4;
   2188   setNFreeG(self3, key16, value4);
   2189   uint32_t value5;
   2190   setNFreeG(self3, key16, value5);
   2191   uint64_t value6;
   2192   setNFreeG(self3, key16, value6);
   2193   char* value7;
   2194   setNFreeG(self3, key16, value7);
   2195   smallDictt* value8;
   2196   setNFreeG(self3, key16, value8);
   2197   smallArrayt* value9;
   2198   setNFreeG(self3, key16, value9);
   2199   char ** value10;
   2200   setNFreeG(self3, key16, value10);
   2201   smallBoolt* value11;
   2202   setNFreeG(self3, key16, value11);
   2203   smallBytest* value12;
   2204   setNFreeG(self3, key16, value12);
   2205   smallDoublet* value13;
   2206   setNFreeG(self3, key16, value13);
   2207   smallIntt* value14;
   2208   setNFreeG(self3, key16, value14);
   2209   smallJsont* value15;
   2210   setNFreeG(self3, key16, value15);
   2211   smallStringt* value16;
   2212   setNFreeG(self3, key16, value16);
   2213   smallContainert* value17;
   2214   setNFreeG(self3, key16, value17);
   2215   undefinedt* value18;
   2216   setNFreeG(self3, key16, value18);
   2217   void * value19;
   2218   setNFreeG(self3, key16, value19);
   2219 }
   2220 {
   2221   smallJsont* self3;
   2222   uint8_t key17;
   2223   baset* value0;
   2224   setNFreeG(self3, key17, value0);
   2225   bool value1;
   2226   setNFreeG(self3, key17, value1);
   2227   double value2;
   2228   setNFreeG(self3, key17, value2);
   2229   int64_t value3;
   2230   setNFreeG(self3, key17, value3);
   2231   int32_t value4;
   2232   setNFreeG(self3, key17, value4);
   2233   uint32_t value5;
   2234   setNFreeG(self3, key17, value5);
   2235   uint64_t value6;
   2236   setNFreeG(self3, key17, value6);
   2237   char* value7;
   2238   setNFreeG(self3, key17, value7);
   2239   smallDictt* value8;
   2240   setNFreeG(self3, key17, value8);
   2241   smallArrayt* value9;
   2242   setNFreeG(self3, key17, value9);
   2243   char ** value10;
   2244   setNFreeG(self3, key17, value10);
   2245   smallBoolt* value11;
   2246   setNFreeG(self3, key17, value11);
   2247   smallBytest* value12;
   2248   setNFreeG(self3, key17, value12);
   2249   smallDoublet* value13;
   2250   setNFreeG(self3, key17, value13);
   2251   smallIntt* value14;
   2252   setNFreeG(self3, key17, value14);
   2253   smallJsont* value15;
   2254   setNFreeG(self3, key17, value15);
   2255   smallStringt* value16;
   2256   setNFreeG(self3, key17, value16);
   2257   smallContainert* value17;
   2258   setNFreeG(self3, key17, value17);
   2259   undefinedt* value18;
   2260   setNFreeG(self3, key17, value18);
   2261   void * value19;
   2262   setNFreeG(self3, key17, value19);
   2263 }
   2264 {
   2265   smallStringt* self4;
   2266   int64_t key18;
   2267   char value0;
   2268   setNFreeG(self4, key18, value0);
   2269 }
   2270 {
   2271   char * self5;
   2272   int64_t key19;
   2273   char value0;
   2274   setNFreeG(self5, key19, value0);
   2275 }
   2276 {
   2277   char ** self6;
   2278   int64_t key20;
   2279   char value0;
   2280   setNFreeG(self6, key20, value0);
   2281   int value1;
   2282   setNFreeG(self6, key20, value1);
   2283   char * value2;
   2284   setNFreeG(self6, key20, value2);
   2285 }
   2286 {
   2287   smallDictt* self1;
   2288   char * key1;
   2289   smallDictt* value0;
   2290   setPG(self1, key1, value0);
   2291   smallArrayt* value1;
   2292   setPG(self1, key1, value1);
   2293   smallJsont* value2;
   2294   setPG(self1, key1, value2);
   2295   smallStringt* value3;
   2296   setPG(self1, key1, value3);
   2297   smallDictt * value4;
   2298   setPG(self1, key1, value4);
   2299 }
   2300 {
   2301   smallDictt* self1;
   2302   const char * key2;
   2303   smallDictt* value0;
   2304   setPG(self1, key2, value0);
   2305   smallArrayt* value1;
   2306   setPG(self1, key2, value1);
   2307   smallJsont* value2;
   2308   setPG(self1, key2, value2);
   2309   smallStringt* value3;
   2310   setPG(self1, key2, value3);
   2311   smallDictt * value4;
   2312   setPG(self1, key2, value4);
   2313 }
   2314 {
   2315   smallDictt* self1;
   2316   char key3;
   2317   smallDictt* value0;
   2318   setPG(self1, key3, value0);
   2319   smallArrayt* value1;
   2320   setPG(self1, key3, value1);
   2321   smallJsont* value2;
   2322   setPG(self1, key3, value2);
   2323   smallStringt* value3;
   2324   setPG(self1, key3, value3);
   2325   smallDictt * value4;
   2326   setPG(self1, key3, value4);
   2327 }
   2328 {
   2329   smallDictt* self1;
   2330   int key4;
   2331   smallDictt* value0;
   2332   setPG(self1, key4, value0);
   2333   smallArrayt* value1;
   2334   setPG(self1, key4, value1);
   2335   smallJsont* value2;
   2336   setPG(self1, key4, value2);
   2337   smallStringt* value3;
   2338   setPG(self1, key4, value3);
   2339   smallDictt * value4;
   2340   setPG(self1, key4, value4);
   2341 }
   2342 {
   2343   smallDictt* self1;
   2344   const char * key0;
   2345   smallDictt * value0;
   2346   setPG(self1, key0, value0);
   2347 }
   2348 {
   2349   smallArrayt* self2;
   2350   int64_t key6;
   2351   smallArrayt* value0;
   2352   setPG(self2, key6, value0);
   2353   smallJsont* value1;
   2354   setPG(self2, key6, value1);
   2355   smallStringt* value2;
   2356   setPG(self2, key6, value2);
   2357   smallDictt * value3;
   2358   setPG(self2, key6, value3);
   2359 }
   2360 {
   2361   smallJsont* self3;
   2362   char * key7;
   2363   smallDictt* value0;
   2364   setPG(self3, key7, value0);
   2365   smallArrayt* value1;
   2366   setPG(self3, key7, value1);
   2367   smallJsont* value2;
   2368   setPG(self3, key7, value2);
   2369   smallStringt* value3;
   2370   setPG(self3, key7, value3);
   2371   smallDictt * value4;
   2372   setPG(self3, key7, value4);
   2373 }
   2374 {
   2375   smallJsont* self3;
   2376   const char * key8;
   2377   smallDictt* value0;
   2378   setPG(self3, key8, value0);
   2379   smallArrayt* value1;
   2380   setPG(self3, key8, value1);
   2381   smallJsont* value2;
   2382   setPG(self3, key8, value2);
   2383   smallStringt* value3;
   2384   setPG(self3, key8, value3);
   2385   smallDictt * value4;
   2386   setPG(self3, key8, value4);
   2387 }
   2388 {
   2389   smallJsont* self3;
   2390   int64_t key9;
   2391   smallDictt* value0;
   2392   setPG(self3, key9, value0);
   2393   smallArrayt* value1;
   2394   setPG(self3, key9, value1);
   2395   smallJsont* value2;
   2396   setPG(self3, key9, value2);
   2397   smallStringt* value3;
   2398   setPG(self3, key9, value3);
   2399   smallDictt * value4;
   2400   setPG(self3, key9, value4);
   2401 }
   2402 {
   2403   smallJsont* self3;
   2404   int32_t key10;
   2405   smallDictt* value0;
   2406   setPG(self3, key10, value0);
   2407   smallArrayt* value1;
   2408   setPG(self3, key10, value1);
   2409   smallJsont* value2;
   2410   setPG(self3, key10, value2);
   2411   smallStringt* value3;
   2412   setPG(self3, key10, value3);
   2413   smallDictt * value4;
   2414   setPG(self3, key10, value4);
   2415 }
   2416 {
   2417   smallJsont* self3;
   2418   int16_t key11;
   2419   smallDictt* value0;
   2420   setPG(self3, key11, value0);
   2421   smallArrayt* value1;
   2422   setPG(self3, key11, value1);
   2423   smallJsont* value2;
   2424   setPG(self3, key11, value2);
   2425   smallStringt* value3;
   2426   setPG(self3, key11, value3);
   2427   smallDictt * value4;
   2428   setPG(self3, key11, value4);
   2429 }
   2430 {
   2431   smallJsont* self3;
   2432   int8_t key12;
   2433   smallDictt* value0;
   2434   setPG(self3, key12, value0);
   2435   smallArrayt* value1;
   2436   setPG(self3, key12, value1);
   2437   smallJsont* value2;
   2438   setPG(self3, key12, value2);
   2439   smallStringt* value3;
   2440   setPG(self3, key12, value3);
   2441   smallDictt * value4;
   2442   setPG(self3, key12, value4);
   2443 }
   2444 {
   2445   smallJsont* self3;
   2446   uint64_t key13;
   2447   smallDictt* value0;
   2448   setPG(self3, key13, value0);
   2449   smallArrayt* value1;
   2450   setPG(self3, key13, value1);
   2451   smallJsont* value2;
   2452   setPG(self3, key13, value2);
   2453   smallStringt* value3;
   2454   setPG(self3, key13, value3);
   2455   smallDictt * value4;
   2456   setPG(self3, key13, value4);
   2457 }
   2458 {
   2459   smallJsont* self3;
   2460   uint32_t key14;
   2461   smallDictt* value0;
   2462   setPG(self3, key14, value0);
   2463   smallArrayt* value1;
   2464   setPG(self3, key14, value1);
   2465   smallJsont* value2;
   2466   setPG(self3, key14, value2);
   2467   smallStringt* value3;
   2468   setPG(self3, key14, value3);
   2469   smallDictt * value4;
   2470   setPG(self3, key14, value4);
   2471 }
   2472 {
   2473   smallJsont* self3;
   2474   uint16_t key15;
   2475   smallDictt* value0;
   2476   setPG(self3, key15, value0);
   2477   smallArrayt* value1;
   2478   setPG(self3, key15, value1);
   2479   smallJsont* value2;
   2480   setPG(self3, key15, value2);
   2481   smallStringt* value3;
   2482   setPG(self3, key15, value3);
   2483   smallDictt * value4;
   2484   setPG(self3, key15, value4);
   2485 }
   2486 {
   2487   smallJsont* self3;
   2488   uint8_t key16;
   2489   smallDictt* value0;
   2490   setPG(self3, key16, value0);
   2491   smallArrayt* value1;
   2492   setPG(self3, key16, value1);
   2493   smallJsont* value2;
   2494   setPG(self3, key16, value2);
   2495   smallStringt* value3;
   2496   setPG(self3, key16, value3);
   2497   smallDictt * value4;
   2498   setPG(self3, key16, value4);
   2499 }
   2500 {
   2501   smallJsont* self3;
   2502   const char * key0;
   2503   smallDictt * value0;
   2504   setPG(self3, key0, value0);
   2505 }
   2506 {
   2507   char ** self4;
   2508   int64_t key18;
   2509   char value0;
   2510   setPG(self4, key18, value0);
   2511   int value1;
   2512   setPG(self4, key18, value1);
   2513   char * value2;
   2514   setPG(self4, key18, value2);
   2515 }
   2516 {
   2517   smallDictt* self1;
   2518   char * key1;
   2519   smallDictt* value0;
   2520   setNFreePG(self1, key1, value0);
   2521   smallArrayt* value1;
   2522   setNFreePG(self1, key1, value1);
   2523   smallJsont* value2;
   2524   setNFreePG(self1, key1, value2);
   2525   smallStringt* value3;
   2526   setNFreePG(self1, key1, value3);
   2527   smallDictt * value4;
   2528   setNFreePG(self1, key1, value4);
   2529 }
   2530 {
   2531   smallDictt* self1;
   2532   const char * key2;
   2533   smallDictt* value0;
   2534   setNFreePG(self1, key2, value0);
   2535   smallArrayt* value1;
   2536   setNFreePG(self1, key2, value1);
   2537   smallJsont* value2;
   2538   setNFreePG(self1, key2, value2);
   2539   smallStringt* value3;
   2540   setNFreePG(self1, key2, value3);
   2541   smallDictt * value4;
   2542   setNFreePG(self1, key2, value4);
   2543 }
   2544 {
   2545   smallDictt* self1;
   2546   char key3;
   2547   smallDictt* value0;
   2548   setNFreePG(self1, key3, value0);
   2549   smallArrayt* value1;
   2550   setNFreePG(self1, key3, value1);
   2551   smallJsont* value2;
   2552   setNFreePG(self1, key3, value2);
   2553   smallStringt* value3;
   2554   setNFreePG(self1, key3, value3);
   2555   smallDictt * value4;
   2556   setNFreePG(self1, key3, value4);
   2557 }
   2558 {
   2559   smallDictt* self1;
   2560   int key4;
   2561   smallDictt* value0;
   2562   setNFreePG(self1, key4, value0);
   2563   smallArrayt* value1;
   2564   setNFreePG(self1, key4, value1);
   2565   smallJsont* value2;
   2566   setNFreePG(self1, key4, value2);
   2567   smallStringt* value3;
   2568   setNFreePG(self1, key4, value3);
   2569   smallDictt * value4;
   2570   setNFreePG(self1, key4, value4);
   2571 }
   2572 {
   2573   smallDictt* self1;
   2574   const char * key0;
   2575   smallDictt * value0;
   2576   setNFreePG(self1, key0, value0);
   2577 }
   2578 {
   2579   smallArrayt* self2;
   2580   int64_t key6;
   2581   smallArrayt* value0;
   2582   setNFreePG(self2, key6, value0);
   2583   smallJsont* value1;
   2584   setNFreePG(self2, key6, value1);
   2585   smallStringt* value2;
   2586   setNFreePG(self2, key6, value2);
   2587   smallDictt * value3;
   2588   setNFreePG(self2, key6, value3);
   2589 }
   2590 {
   2591   smallJsont* self3;
   2592   char * key7;
   2593   smallDictt* value0;
   2594   setNFreePG(self3, key7, value0);
   2595   smallArrayt* value1;
   2596   setNFreePG(self3, key7, value1);
   2597   smallJsont* value2;
   2598   setNFreePG(self3, key7, value2);
   2599   smallStringt* value3;
   2600   setNFreePG(self3, key7, value3);
   2601   smallDictt * value4;
   2602   setNFreePG(self3, key7, value4);
   2603 }
   2604 {
   2605   smallJsont* self3;
   2606   const char * key8;
   2607   smallDictt* value0;
   2608   setNFreePG(self3, key8, value0);
   2609   smallArrayt* value1;
   2610   setNFreePG(self3, key8, value1);
   2611   smallJsont* value2;
   2612   setNFreePG(self3, key8, value2);
   2613   smallStringt* value3;
   2614   setNFreePG(self3, key8, value3);
   2615   smallDictt * value4;
   2616   setNFreePG(self3, key8, value4);
   2617 }
   2618 {
   2619   smallJsont* self3;
   2620   int64_t key9;
   2621   smallDictt* value0;
   2622   setNFreePG(self3, key9, value0);
   2623   smallArrayt* value1;
   2624   setNFreePG(self3, key9, value1);
   2625   smallJsont* value2;
   2626   setNFreePG(self3, key9, value2);
   2627   smallStringt* value3;
   2628   setNFreePG(self3, key9, value3);
   2629   smallDictt * value4;
   2630   setNFreePG(self3, key9, value4);
   2631 }
   2632 {
   2633   smallJsont* self3;
   2634   int32_t key10;
   2635   smallDictt* value0;
   2636   setNFreePG(self3, key10, value0);
   2637   smallArrayt* value1;
   2638   setNFreePG(self3, key10, value1);
   2639   smallJsont* value2;
   2640   setNFreePG(self3, key10, value2);
   2641   smallStringt* value3;
   2642   setNFreePG(self3, key10, value3);
   2643   smallDictt * value4;
   2644   setNFreePG(self3, key10, value4);
   2645 }
   2646 {
   2647   smallJsont* self3;
   2648   int16_t key11;
   2649   smallDictt* value0;
   2650   setNFreePG(self3, key11, value0);
   2651   smallArrayt* value1;
   2652   setNFreePG(self3, key11, value1);
   2653   smallJsont* value2;
   2654   setNFreePG(self3, key11, value2);
   2655   smallStringt* value3;
   2656   setNFreePG(self3, key11, value3);
   2657   smallDictt * value4;
   2658   setNFreePG(self3, key11, value4);
   2659 }
   2660 {
   2661   smallJsont* self3;
   2662   int8_t key12;
   2663   smallDictt* value0;
   2664   setNFreePG(self3, key12, value0);
   2665   smallArrayt* value1;
   2666   setNFreePG(self3, key12, value1);
   2667   smallJsont* value2;
   2668   setNFreePG(self3, key12, value2);
   2669   smallStringt* value3;
   2670   setNFreePG(self3, key12, value3);
   2671   smallDictt * value4;
   2672   setNFreePG(self3, key12, value4);
   2673 }
   2674 {
   2675   smallJsont* self3;
   2676   uint64_t key13;
   2677   smallDictt* value0;
   2678   setNFreePG(self3, key13, value0);
   2679   smallArrayt* value1;
   2680   setNFreePG(self3, key13, value1);
   2681   smallJsont* value2;
   2682   setNFreePG(self3, key13, value2);
   2683   smallStringt* value3;
   2684   setNFreePG(self3, key13, value3);
   2685   smallDictt * value4;
   2686   setNFreePG(self3, key13, value4);
   2687 }
   2688 {
   2689   smallJsont* self3;
   2690   uint32_t key14;
   2691   smallDictt* value0;
   2692   setNFreePG(self3, key14, value0);
   2693   smallArrayt* value1;
   2694   setNFreePG(self3, key14, value1);
   2695   smallJsont* value2;
   2696   setNFreePG(self3, key14, value2);
   2697   smallStringt* value3;
   2698   setNFreePG(self3, key14, value3);
   2699   smallDictt * value4;
   2700   setNFreePG(self3, key14, value4);
   2701 }
   2702 {
   2703   smallJsont* self3;
   2704   uint16_t key15;
   2705   smallDictt* value0;
   2706   setNFreePG(self3, key15, value0);
   2707   smallArrayt* value1;
   2708   setNFreePG(self3, key15, value1);
   2709   smallJsont* value2;
   2710   setNFreePG(self3, key15, value2);
   2711   smallStringt* value3;
   2712   setNFreePG(self3, key15, value3);
   2713   smallDictt * value4;
   2714   setNFreePG(self3, key15, value4);
   2715 }
   2716 {
   2717   smallJsont* self3;
   2718   uint8_t key16;
   2719   smallDictt* value0;
   2720   setNFreePG(self3, key16, value0);
   2721   smallArrayt* value1;
   2722   setNFreePG(self3, key16, value1);
   2723   smallJsont* value2;
   2724   setNFreePG(self3, key16, value2);
   2725   smallStringt* value3;
   2726   setNFreePG(self3, key16, value3);
   2727   smallDictt * value4;
   2728   setNFreePG(self3, key16, value4);
   2729 }
   2730 {
   2731   smallJsont* self3;
   2732   const char * key0;
   2733   smallDictt * value0;
   2734   setNFreePG(self3, key0, value0);
   2735 }
   2736 {
   2737   char ** self4;
   2738   int64_t key18;
   2739   char value0;
   2740   setNFreePG(self4, key18, value0);
   2741   int value1;
   2742   setNFreePG(self4, key18, value1);
   2743   char * value2;
   2744   setNFreePG(self4, key18, value2);
   2745 }
   2746 {
   2747   smallDictt* self1;
   2748   char * key1;
   2749   baset* returnType0;
   2750   getG(self1, returnType0, key1);
   2751   undefinedt* returnType1;
   2752   getG(self1, returnType1, key1);
   2753   bool returnType2;
   2754   getG(self1, returnType2, key1);
   2755   bool* returnType3;
   2756   getG(self1, returnType3, key1);
   2757   double returnType4;
   2758   getG(self1, returnType4, key1);
   2759   double* returnType5;
   2760   getG(self1, returnType5, key1);
   2761   int64_t returnType6;
   2762   getG(self1, returnType6, key1);
   2763   int64_t* returnType7;
   2764   getG(self1, returnType7, key1);
   2765   int32_t returnType8;
   2766   getG(self1, returnType8, key1);
   2767   int32_t* returnType9;
   2768   getG(self1, returnType9, key1);
   2769   uint64_t returnType10;
   2770   getG(self1, returnType10, key1);
   2771   uint64_t* returnType11;
   2772   getG(self1, returnType11, key1);
   2773   uint32_t returnType12;
   2774   getG(self1, returnType12, key1);
   2775   uint32_t* returnType13;
   2776   getG(self1, returnType13, key1);
   2777   char* returnType14;
   2778   getG(self1, returnType14, key1);
   2779   smallDictt* returnType15;
   2780   getG(self1, returnType15, key1);
   2781   smallArrayt* returnType16;
   2782   getG(self1, returnType16, key1);
   2783   smallBoolt* returnType17;
   2784   getG(self1, returnType17, key1);
   2785   smallBytest* returnType18;
   2786   getG(self1, returnType18, key1);
   2787   smallDoublet* returnType19;
   2788   getG(self1, returnType19, key1);
   2789   smallIntt* returnType20;
   2790   getG(self1, returnType20, key1);
   2791   smallJsont* returnType21;
   2792   getG(self1, returnType21, key1);
   2793   smallStringt* returnType22;
   2794   getG(self1, returnType22, key1);
   2795   void* returnType23;
   2796   getG(self1, returnType23, key1);
   2797   smallContainert* returnType24;
   2798   getG(self1, returnType24, key1);
   2799   baset* returnType25;
   2800   getG(self1, returnType25, key1);
   2801 }
   2802 {
   2803   smallDictt* self1;
   2804   const char * key2;
   2805   baset* returnType0;
   2806   getG(self1, returnType0, key2);
   2807   undefinedt* returnType1;
   2808   getG(self1, returnType1, key2);
   2809   bool returnType2;
   2810   getG(self1, returnType2, key2);
   2811   bool* returnType3;
   2812   getG(self1, returnType3, key2);
   2813   double returnType4;
   2814   getG(self1, returnType4, key2);
   2815   double* returnType5;
   2816   getG(self1, returnType5, key2);
   2817   int64_t returnType6;
   2818   getG(self1, returnType6, key2);
   2819   int64_t* returnType7;
   2820   getG(self1, returnType7, key2);
   2821   int32_t returnType8;
   2822   getG(self1, returnType8, key2);
   2823   int32_t* returnType9;
   2824   getG(self1, returnType9, key2);
   2825   uint64_t returnType10;
   2826   getG(self1, returnType10, key2);
   2827   uint64_t* returnType11;
   2828   getG(self1, returnType11, key2);
   2829   uint32_t returnType12;
   2830   getG(self1, returnType12, key2);
   2831   uint32_t* returnType13;
   2832   getG(self1, returnType13, key2);
   2833   char* returnType14;
   2834   getG(self1, returnType14, key2);
   2835   smallDictt* returnType15;
   2836   getG(self1, returnType15, key2);
   2837   smallArrayt* returnType16;
   2838   getG(self1, returnType16, key2);
   2839   smallBoolt* returnType17;
   2840   getG(self1, returnType17, key2);
   2841   smallBytest* returnType18;
   2842   getG(self1, returnType18, key2);
   2843   smallDoublet* returnType19;
   2844   getG(self1, returnType19, key2);
   2845   smallIntt* returnType20;
   2846   getG(self1, returnType20, key2);
   2847   smallJsont* returnType21;
   2848   getG(self1, returnType21, key2);
   2849   smallStringt* returnType22;
   2850   getG(self1, returnType22, key2);
   2851   void* returnType23;
   2852   getG(self1, returnType23, key2);
   2853   smallContainert* returnType24;
   2854   getG(self1, returnType24, key2);
   2855   baset* returnType25;
   2856   getG(self1, returnType25, key2);
   2857 }
   2858 {
   2859   smallDictt* self1;
   2860   char key3;
   2861   baset* returnType0;
   2862   getG(self1, returnType0, key3);
   2863   undefinedt* returnType1;
   2864   getG(self1, returnType1, key3);
   2865   bool returnType2;
   2866   getG(self1, returnType2, key3);
   2867   bool* returnType3;
   2868   getG(self1, returnType3, key3);
   2869   double returnType4;
   2870   getG(self1, returnType4, key3);
   2871   double* returnType5;
   2872   getG(self1, returnType5, key3);
   2873   int64_t returnType6;
   2874   getG(self1, returnType6, key3);
   2875   int64_t* returnType7;
   2876   getG(self1, returnType7, key3);
   2877   int32_t returnType8;
   2878   getG(self1, returnType8, key3);
   2879   int32_t* returnType9;
   2880   getG(self1, returnType9, key3);
   2881   uint64_t returnType10;
   2882   getG(self1, returnType10, key3);
   2883   uint64_t* returnType11;
   2884   getG(self1, returnType11, key3);
   2885   uint32_t returnType12;
   2886   getG(self1, returnType12, key3);
   2887   uint32_t* returnType13;
   2888   getG(self1, returnType13, key3);
   2889   char* returnType14;
   2890   getG(self1, returnType14, key3);
   2891   smallDictt* returnType15;
   2892   getG(self1, returnType15, key3);
   2893   smallArrayt* returnType16;
   2894   getG(self1, returnType16, key3);
   2895   smallBoolt* returnType17;
   2896   getG(self1, returnType17, key3);
   2897   smallBytest* returnType18;
   2898   getG(self1, returnType18, key3);
   2899   smallDoublet* returnType19;
   2900   getG(self1, returnType19, key3);
   2901   smallIntt* returnType20;
   2902   getG(self1, returnType20, key3);
   2903   smallJsont* returnType21;
   2904   getG(self1, returnType21, key3);
   2905   smallStringt* returnType22;
   2906   getG(self1, returnType22, key3);
   2907   void* returnType23;
   2908   getG(self1, returnType23, key3);
   2909   smallContainert* returnType24;
   2910   getG(self1, returnType24, key3);
   2911   baset* returnType25;
   2912   getG(self1, returnType25, key3);
   2913 }
   2914 {
   2915   smallDictt* self1;
   2916   int key4;
   2917   baset* returnType0;
   2918   getG(self1, returnType0, key4);
   2919   undefinedt* returnType1;
   2920   getG(self1, returnType1, key4);
   2921   bool returnType2;
   2922   getG(self1, returnType2, key4);
   2923   bool* returnType3;
   2924   getG(self1, returnType3, key4);
   2925   double returnType4;
   2926   getG(self1, returnType4, key4);
   2927   double* returnType5;
   2928   getG(self1, returnType5, key4);
   2929   int64_t returnType6;
   2930   getG(self1, returnType6, key4);
   2931   int64_t* returnType7;
   2932   getG(self1, returnType7, key4);
   2933   int32_t returnType8;
   2934   getG(self1, returnType8, key4);
   2935   int32_t* returnType9;
   2936   getG(self1, returnType9, key4);
   2937   uint64_t returnType10;
   2938   getG(self1, returnType10, key4);
   2939   uint64_t* returnType11;
   2940   getG(self1, returnType11, key4);
   2941   uint32_t returnType12;
   2942   getG(self1, returnType12, key4);
   2943   uint32_t* returnType13;
   2944   getG(self1, returnType13, key4);
   2945   char* returnType14;
   2946   getG(self1, returnType14, key4);
   2947   smallDictt* returnType15;
   2948   getG(self1, returnType15, key4);
   2949   smallArrayt* returnType16;
   2950   getG(self1, returnType16, key4);
   2951   smallBoolt* returnType17;
   2952   getG(self1, returnType17, key4);
   2953   smallBytest* returnType18;
   2954   getG(self1, returnType18, key4);
   2955   smallDoublet* returnType19;
   2956   getG(self1, returnType19, key4);
   2957   smallIntt* returnType20;
   2958   getG(self1, returnType20, key4);
   2959   smallJsont* returnType21;
   2960   getG(self1, returnType21, key4);
   2961   smallStringt* returnType22;
   2962   getG(self1, returnType22, key4);
   2963   void* returnType23;
   2964   getG(self1, returnType23, key4);
   2965   smallContainert* returnType24;
   2966   getG(self1, returnType24, key4);
   2967   baset* returnType25;
   2968   getG(self1, returnType25, key4);
   2969 }
   2970 {
   2971   smallDictt* self1;
   2972   const char * key0;
   2973   baset* returnType0;
   2974   getG(self1, returnType0, key0);
   2975 }
   2976 {
   2977   smallArrayt* self2;
   2978   int64_t key6;
   2979   baset* returnType0;
   2980   getG(self2, returnType0, key6);
   2981   undefinedt* returnType1;
   2982   getG(self2, returnType1, key6);
   2983   bool returnType2;
   2984   getG(self2, returnType2, key6);
   2985   bool* returnType3;
   2986   getG(self2, returnType3, key6);
   2987   double returnType4;
   2988   getG(self2, returnType4, key6);
   2989   double* returnType5;
   2990   getG(self2, returnType5, key6);
   2991   int64_t returnType6;
   2992   getG(self2, returnType6, key6);
   2993   int64_t* returnType7;
   2994   getG(self2, returnType7, key6);
   2995   int32_t returnType8;
   2996   getG(self2, returnType8, key6);
   2997   int32_t* returnType9;
   2998   getG(self2, returnType9, key6);
   2999   uint64_t returnType10;
   3000   getG(self2, returnType10, key6);
   3001   uint64_t* returnType11;
   3002   getG(self2, returnType11, key6);
   3003   uint32_t returnType12;
   3004   getG(self2, returnType12, key6);
   3005   uint32_t* returnType13;
   3006   getG(self2, returnType13, key6);
   3007   char* returnType14;
   3008   getG(self2, returnType14, key6);
   3009   smallDictt* returnType15;
   3010   getG(self2, returnType15, key6);
   3011   smallArrayt* returnType16;
   3012   getG(self2, returnType16, key6);
   3013   smallBoolt* returnType17;
   3014   getG(self2, returnType17, key6);
   3015   smallBytest* returnType18;
   3016   getG(self2, returnType18, key6);
   3017   smallDoublet* returnType19;
   3018   getG(self2, returnType19, key6);
   3019   smallIntt* returnType20;
   3020   getG(self2, returnType20, key6);
   3021   smallJsont* returnType21;
   3022   getG(self2, returnType21, key6);
   3023   smallStringt* returnType22;
   3024   getG(self2, returnType22, key6);
   3025   void* returnType23;
   3026   getG(self2, returnType23, key6);
   3027   smallContainert* returnType24;
   3028   getG(self2, returnType24, key6);
   3029   baset* returnType25;
   3030   getG(self2, returnType25, key6);
   3031 }
   3032 {
   3033   smallJsont* self3;
   3034   char * key7;
   3035   baset* returnType0;
   3036   getG(self3, returnType0, key7);
   3037   undefinedt* returnType1;
   3038   getG(self3, returnType1, key7);
   3039   bool returnType2;
   3040   getG(self3, returnType2, key7);
   3041   bool* returnType3;
   3042   getG(self3, returnType3, key7);
   3043   double returnType4;
   3044   getG(self3, returnType4, key7);
   3045   double* returnType5;
   3046   getG(self3, returnType5, key7);
   3047   int64_t returnType6;
   3048   getG(self3, returnType6, key7);
   3049   int64_t* returnType7;
   3050   getG(self3, returnType7, key7);
   3051   int32_t returnType8;
   3052   getG(self3, returnType8, key7);
   3053   int32_t* returnType9;
   3054   getG(self3, returnType9, key7);
   3055   uint64_t returnType10;
   3056   getG(self3, returnType10, key7);
   3057   uint64_t* returnType11;
   3058   getG(self3, returnType11, key7);
   3059   uint32_t returnType12;
   3060   getG(self3, returnType12, key7);
   3061   uint32_t* returnType13;
   3062   getG(self3, returnType13, key7);
   3063   char* returnType14;
   3064   getG(self3, returnType14, key7);
   3065   smallDictt* returnType15;
   3066   getG(self3, returnType15, key7);
   3067   smallArrayt* returnType16;
   3068   getG(self3, returnType16, key7);
   3069   smallBoolt* returnType17;
   3070   getG(self3, returnType17, key7);
   3071   smallBytest* returnType18;
   3072   getG(self3, returnType18, key7);
   3073   smallDoublet* returnType19;
   3074   getG(self3, returnType19, key7);
   3075   smallIntt* returnType20;
   3076   getG(self3, returnType20, key7);
   3077   smallJsont* returnType21;
   3078   getG(self3, returnType21, key7);
   3079   smallStringt* returnType22;
   3080   getG(self3, returnType22, key7);
   3081   void* returnType23;
   3082   getG(self3, returnType23, key7);
   3083   smallContainert* returnType24;
   3084   getG(self3, returnType24, key7);
   3085   baset* returnType25;
   3086   getG(self3, returnType25, key7);
   3087 }
   3088 {
   3089   smallJsont* self3;
   3090   const char * key8;
   3091   baset* returnType0;
   3092   getG(self3, returnType0, key8);
   3093   undefinedt* returnType1;
   3094   getG(self3, returnType1, key8);
   3095   bool returnType2;
   3096   getG(self3, returnType2, key8);
   3097   bool* returnType3;
   3098   getG(self3, returnType3, key8);
   3099   double returnType4;
   3100   getG(self3, returnType4, key8);
   3101   double* returnType5;
   3102   getG(self3, returnType5, key8);
   3103   int64_t returnType6;
   3104   getG(self3, returnType6, key8);
   3105   int64_t* returnType7;
   3106   getG(self3, returnType7, key8);
   3107   int32_t returnType8;
   3108   getG(self3, returnType8, key8);
   3109   int32_t* returnType9;
   3110   getG(self3, returnType9, key8);
   3111   uint64_t returnType10;
   3112   getG(self3, returnType10, key8);
   3113   uint64_t* returnType11;
   3114   getG(self3, returnType11, key8);
   3115   uint32_t returnType12;
   3116   getG(self3, returnType12, key8);
   3117   uint32_t* returnType13;
   3118   getG(self3, returnType13, key8);
   3119   char* returnType14;
   3120   getG(self3, returnType14, key8);
   3121   smallDictt* returnType15;
   3122   getG(self3, returnType15, key8);
   3123   smallArrayt* returnType16;
   3124   getG(self3, returnType16, key8);
   3125   smallBoolt* returnType17;
   3126   getG(self3, returnType17, key8);
   3127   smallBytest* returnType18;
   3128   getG(self3, returnType18, key8);
   3129   smallDoublet* returnType19;
   3130   getG(self3, returnType19, key8);
   3131   smallIntt* returnType20;
   3132   getG(self3, returnType20, key8);
   3133   smallJsont* returnType21;
   3134   getG(self3, returnType21, key8);
   3135   smallStringt* returnType22;
   3136   getG(self3, returnType22, key8);
   3137   void* returnType23;
   3138   getG(self3, returnType23, key8);
   3139   smallContainert* returnType24;
   3140   getG(self3, returnType24, key8);
   3141   baset* returnType25;
   3142   getG(self3, returnType25, key8);
   3143 }
   3144 {
   3145   smallJsont* self3;
   3146   int64_t key9;
   3147   baset* returnType0;
   3148   getG(self3, returnType0, key9);
   3149   undefinedt* returnType1;
   3150   getG(self3, returnType1, key9);
   3151   bool returnType2;
   3152   getG(self3, returnType2, key9);
   3153   bool* returnType3;
   3154   getG(self3, returnType3, key9);
   3155   double returnType4;
   3156   getG(self3, returnType4, key9);
   3157   double* returnType5;
   3158   getG(self3, returnType5, key9);
   3159   int64_t returnType6;
   3160   getG(self3, returnType6, key9);
   3161   int64_t* returnType7;
   3162   getG(self3, returnType7, key9);
   3163   int32_t returnType8;
   3164   getG(self3, returnType8, key9);
   3165   int32_t* returnType9;
   3166   getG(self3, returnType9, key9);
   3167   uint64_t returnType10;
   3168   getG(self3, returnType10, key9);
   3169   uint64_t* returnType11;
   3170   getG(self3, returnType11, key9);
   3171   uint32_t returnType12;
   3172   getG(self3, returnType12, key9);
   3173   uint32_t* returnType13;
   3174   getG(self3, returnType13, key9);
   3175   char* returnType14;
   3176   getG(self3, returnType14, key9);
   3177   smallDictt* returnType15;
   3178   getG(self3, returnType15, key9);
   3179   smallArrayt* returnType16;
   3180   getG(self3, returnType16, key9);
   3181   smallBoolt* returnType17;
   3182   getG(self3, returnType17, key9);
   3183   smallBytest* returnType18;
   3184   getG(self3, returnType18, key9);
   3185   smallDoublet* returnType19;
   3186   getG(self3, returnType19, key9);
   3187   smallIntt* returnType20;
   3188   getG(self3, returnType20, key9);
   3189   smallJsont* returnType21;
   3190   getG(self3, returnType21, key9);
   3191   smallStringt* returnType22;
   3192   getG(self3, returnType22, key9);
   3193   void* returnType23;
   3194   getG(self3, returnType23, key9);
   3195   smallContainert* returnType24;
   3196   getG(self3, returnType24, key9);
   3197   baset* returnType25;
   3198   getG(self3, returnType25, key9);
   3199 }
   3200 {
   3201   smallJsont* self3;
   3202   int32_t key10;
   3203   baset* returnType0;
   3204   getG(self3, returnType0, key10);
   3205   undefinedt* returnType1;
   3206   getG(self3, returnType1, key10);
   3207   bool returnType2;
   3208   getG(self3, returnType2, key10);
   3209   bool* returnType3;
   3210   getG(self3, returnType3, key10);
   3211   double returnType4;
   3212   getG(self3, returnType4, key10);
   3213   double* returnType5;
   3214   getG(self3, returnType5, key10);
   3215   int64_t returnType6;
   3216   getG(self3, returnType6, key10);
   3217   int64_t* returnType7;
   3218   getG(self3, returnType7, key10);
   3219   int32_t returnType8;
   3220   getG(self3, returnType8, key10);
   3221   int32_t* returnType9;
   3222   getG(self3, returnType9, key10);
   3223   uint64_t returnType10;
   3224   getG(self3, returnType10, key10);
   3225   uint64_t* returnType11;
   3226   getG(self3, returnType11, key10);
   3227   uint32_t returnType12;
   3228   getG(self3, returnType12, key10);
   3229   uint32_t* returnType13;
   3230   getG(self3, returnType13, key10);
   3231   char* returnType14;
   3232   getG(self3, returnType14, key10);
   3233   smallDictt* returnType15;
   3234   getG(self3, returnType15, key10);
   3235   smallArrayt* returnType16;
   3236   getG(self3, returnType16, key10);
   3237   smallBoolt* returnType17;
   3238   getG(self3, returnType17, key10);
   3239   smallBytest* returnType18;
   3240   getG(self3, returnType18, key10);
   3241   smallDoublet* returnType19;
   3242   getG(self3, returnType19, key10);
   3243   smallIntt* returnType20;
   3244   getG(self3, returnType20, key10);
   3245   smallJsont* returnType21;
   3246   getG(self3, returnType21, key10);
   3247   smallStringt* returnType22;
   3248   getG(self3, returnType22, key10);
   3249   void* returnType23;
   3250   getG(self3, returnType23, key10);
   3251   smallContainert* returnType24;
   3252   getG(self3, returnType24, key10);
   3253   baset* returnType25;
   3254   getG(self3, returnType25, key10);
   3255 }
   3256 {
   3257   smallJsont* self3;
   3258   int16_t key11;
   3259   baset* returnType0;
   3260   getG(self3, returnType0, key11);
   3261   undefinedt* returnType1;
   3262   getG(self3, returnType1, key11);
   3263   bool returnType2;
   3264   getG(self3, returnType2, key11);
   3265   bool* returnType3;
   3266   getG(self3, returnType3, key11);
   3267   double returnType4;
   3268   getG(self3, returnType4, key11);
   3269   double* returnType5;
   3270   getG(self3, returnType5, key11);
   3271   int64_t returnType6;
   3272   getG(self3, returnType6, key11);
   3273   int64_t* returnType7;
   3274   getG(self3, returnType7, key11);
   3275   int32_t returnType8;
   3276   getG(self3, returnType8, key11);
   3277   int32_t* returnType9;
   3278   getG(self3, returnType9, key11);
   3279   uint64_t returnType10;
   3280   getG(self3, returnType10, key11);
   3281   uint64_t* returnType11;
   3282   getG(self3, returnType11, key11);
   3283   uint32_t returnType12;
   3284   getG(self3, returnType12, key11);
   3285   uint32_t* returnType13;
   3286   getG(self3, returnType13, key11);
   3287   char* returnType14;
   3288   getG(self3, returnType14, key11);
   3289   smallDictt* returnType15;
   3290   getG(self3, returnType15, key11);
   3291   smallArrayt* returnType16;
   3292   getG(self3, returnType16, key11);
   3293   smallBoolt* returnType17;
   3294   getG(self3, returnType17, key11);
   3295   smallBytest* returnType18;
   3296   getG(self3, returnType18, key11);
   3297   smallDoublet* returnType19;
   3298   getG(self3, returnType19, key11);
   3299   smallIntt* returnType20;
   3300   getG(self3, returnType20, key11);
   3301   smallJsont* returnType21;
   3302   getG(self3, returnType21, key11);
   3303   smallStringt* returnType22;
   3304   getG(self3, returnType22, key11);
   3305   void* returnType23;
   3306   getG(self3, returnType23, key11);
   3307   smallContainert* returnType24;
   3308   getG(self3, returnType24, key11);
   3309   baset* returnType25;
   3310   getG(self3, returnType25, key11);
   3311 }
   3312 {
   3313   smallJsont* self3;
   3314   int8_t key12;
   3315   baset* returnType0;
   3316   getG(self3, returnType0, key12);
   3317   undefinedt* returnType1;
   3318   getG(self3, returnType1, key12);
   3319   bool returnType2;
   3320   getG(self3, returnType2, key12);
   3321   bool* returnType3;
   3322   getG(self3, returnType3, key12);
   3323   double returnType4;
   3324   getG(self3, returnType4, key12);
   3325   double* returnType5;
   3326   getG(self3, returnType5, key12);
   3327   int64_t returnType6;
   3328   getG(self3, returnType6, key12);
   3329   int64_t* returnType7;
   3330   getG(self3, returnType7, key12);
   3331   int32_t returnType8;
   3332   getG(self3, returnType8, key12);
   3333   int32_t* returnType9;
   3334   getG(self3, returnType9, key12);
   3335   uint64_t returnType10;
   3336   getG(self3, returnType10, key12);
   3337   uint64_t* returnType11;
   3338   getG(self3, returnType11, key12);
   3339   uint32_t returnType12;
   3340   getG(self3, returnType12, key12);
   3341   uint32_t* returnType13;
   3342   getG(self3, returnType13, key12);
   3343   char* returnType14;
   3344   getG(self3, returnType14, key12);
   3345   smallDictt* returnType15;
   3346   getG(self3, returnType15, key12);
   3347   smallArrayt* returnType16;
   3348   getG(self3, returnType16, key12);
   3349   smallBoolt* returnType17;
   3350   getG(self3, returnType17, key12);
   3351   smallBytest* returnType18;
   3352   getG(self3, returnType18, key12);
   3353   smallDoublet* returnType19;
   3354   getG(self3, returnType19, key12);
   3355   smallIntt* returnType20;
   3356   getG(self3, returnType20, key12);
   3357   smallJsont* returnType21;
   3358   getG(self3, returnType21, key12);
   3359   smallStringt* returnType22;
   3360   getG(self3, returnType22, key12);
   3361   void* returnType23;
   3362   getG(self3, returnType23, key12);
   3363   smallContainert* returnType24;
   3364   getG(self3, returnType24, key12);
   3365   baset* returnType25;
   3366   getG(self3, returnType25, key12);
   3367 }
   3368 {
   3369   smallJsont* self3;
   3370   uint64_t key13;
   3371   baset* returnType0;
   3372   getG(self3, returnType0, key13);
   3373   undefinedt* returnType1;
   3374   getG(self3, returnType1, key13);
   3375   bool returnType2;
   3376   getG(self3, returnType2, key13);
   3377   bool* returnType3;
   3378   getG(self3, returnType3, key13);
   3379   double returnType4;
   3380   getG(self3, returnType4, key13);
   3381   double* returnType5;
   3382   getG(self3, returnType5, key13);
   3383   int64_t returnType6;
   3384   getG(self3, returnType6, key13);
   3385   int64_t* returnType7;
   3386   getG(self3, returnType7, key13);
   3387   int32_t returnType8;
   3388   getG(self3, returnType8, key13);
   3389   int32_t* returnType9;
   3390   getG(self3, returnType9, key13);
   3391   uint64_t returnType10;
   3392   getG(self3, returnType10, key13);
   3393   uint64_t* returnType11;
   3394   getG(self3, returnType11, key13);
   3395   uint32_t returnType12;
   3396   getG(self3, returnType12, key13);
   3397   uint32_t* returnType13;
   3398   getG(self3, returnType13, key13);
   3399   char* returnType14;
   3400   getG(self3, returnType14, key13);
   3401   smallDictt* returnType15;
   3402   getG(self3, returnType15, key13);
   3403   smallArrayt* returnType16;
   3404   getG(self3, returnType16, key13);
   3405   smallBoolt* returnType17;
   3406   getG(self3, returnType17, key13);
   3407   smallBytest* returnType18;
   3408   getG(self3, returnType18, key13);
   3409   smallDoublet* returnType19;
   3410   getG(self3, returnType19, key13);
   3411   smallIntt* returnType20;
   3412   getG(self3, returnType20, key13);
   3413   smallJsont* returnType21;
   3414   getG(self3, returnType21, key13);
   3415   smallStringt* returnType22;
   3416   getG(self3, returnType22, key13);
   3417   void* returnType23;
   3418   getG(self3, returnType23, key13);
   3419   smallContainert* returnType24;
   3420   getG(self3, returnType24, key13);
   3421   baset* returnType25;
   3422   getG(self3, returnType25, key13);
   3423 }
   3424 {
   3425   smallJsont* self3;
   3426   uint32_t key14;
   3427   baset* returnType0;
   3428   getG(self3, returnType0, key14);
   3429   undefinedt* returnType1;
   3430   getG(self3, returnType1, key14);
   3431   bool returnType2;
   3432   getG(self3, returnType2, key14);
   3433   bool* returnType3;
   3434   getG(self3, returnType3, key14);
   3435   double returnType4;
   3436   getG(self3, returnType4, key14);
   3437   double* returnType5;
   3438   getG(self3, returnType5, key14);
   3439   int64_t returnType6;
   3440   getG(self3, returnType6, key14);
   3441   int64_t* returnType7;
   3442   getG(self3, returnType7, key14);
   3443   int32_t returnType8;
   3444   getG(self3, returnType8, key14);
   3445   int32_t* returnType9;
   3446   getG(self3, returnType9, key14);
   3447   uint64_t returnType10;
   3448   getG(self3, returnType10, key14);
   3449   uint64_t* returnType11;
   3450   getG(self3, returnType11, key14);
   3451   uint32_t returnType12;
   3452   getG(self3, returnType12, key14);
   3453   uint32_t* returnType13;
   3454   getG(self3, returnType13, key14);
   3455   char* returnType14;
   3456   getG(self3, returnType14, key14);
   3457   smallDictt* returnType15;
   3458   getG(self3, returnType15, key14);
   3459   smallArrayt* returnType16;
   3460   getG(self3, returnType16, key14);
   3461   smallBoolt* returnType17;
   3462   getG(self3, returnType17, key14);
   3463   smallBytest* returnType18;
   3464   getG(self3, returnType18, key14);
   3465   smallDoublet* returnType19;
   3466   getG(self3, returnType19, key14);
   3467   smallIntt* returnType20;
   3468   getG(self3, returnType20, key14);
   3469   smallJsont* returnType21;
   3470   getG(self3, returnType21, key14);
   3471   smallStringt* returnType22;
   3472   getG(self3, returnType22, key14);
   3473   void* returnType23;
   3474   getG(self3, returnType23, key14);
   3475   smallContainert* returnType24;
   3476   getG(self3, returnType24, key14);
   3477   baset* returnType25;
   3478   getG(self3, returnType25, key14);
   3479 }
   3480 {
   3481   smallJsont* self3;
   3482   uint16_t key15;
   3483   baset* returnType0;
   3484   getG(self3, returnType0, key15);
   3485   undefinedt* returnType1;
   3486   getG(self3, returnType1, key15);
   3487   bool returnType2;
   3488   getG(self3, returnType2, key15);
   3489   bool* returnType3;
   3490   getG(self3, returnType3, key15);
   3491   double returnType4;
   3492   getG(self3, returnType4, key15);
   3493   double* returnType5;
   3494   getG(self3, returnType5, key15);
   3495   int64_t returnType6;
   3496   getG(self3, returnType6, key15);
   3497   int64_t* returnType7;
   3498   getG(self3, returnType7, key15);
   3499   int32_t returnType8;
   3500   getG(self3, returnType8, key15);
   3501   int32_t* returnType9;
   3502   getG(self3, returnType9, key15);
   3503   uint64_t returnType10;
   3504   getG(self3, returnType10, key15);
   3505   uint64_t* returnType11;
   3506   getG(self3, returnType11, key15);
   3507   uint32_t returnType12;
   3508   getG(self3, returnType12, key15);
   3509   uint32_t* returnType13;
   3510   getG(self3, returnType13, key15);
   3511   char* returnType14;
   3512   getG(self3, returnType14, key15);
   3513   smallDictt* returnType15;
   3514   getG(self3, returnType15, key15);
   3515   smallArrayt* returnType16;
   3516   getG(self3, returnType16, key15);
   3517   smallBoolt* returnType17;
   3518   getG(self3, returnType17, key15);
   3519   smallBytest* returnType18;
   3520   getG(self3, returnType18, key15);
   3521   smallDoublet* returnType19;
   3522   getG(self3, returnType19, key15);
   3523   smallIntt* returnType20;
   3524   getG(self3, returnType20, key15);
   3525   smallJsont* returnType21;
   3526   getG(self3, returnType21, key15);
   3527   smallStringt* returnType22;
   3528   getG(self3, returnType22, key15);
   3529   void* returnType23;
   3530   getG(self3, returnType23, key15);
   3531   smallContainert* returnType24;
   3532   getG(self3, returnType24, key15);
   3533   baset* returnType25;
   3534   getG(self3, returnType25, key15);
   3535 }
   3536 {
   3537   smallJsont* self3;
   3538   uint8_t key16;
   3539   baset* returnType0;
   3540   getG(self3, returnType0, key16);
   3541   undefinedt* returnType1;
   3542   getG(self3, returnType1, key16);
   3543   bool returnType2;
   3544   getG(self3, returnType2, key16);
   3545   bool* returnType3;
   3546   getG(self3, returnType3, key16);
   3547   double returnType4;
   3548   getG(self3, returnType4, key16);
   3549   double* returnType5;
   3550   getG(self3, returnType5, key16);
   3551   int64_t returnType6;
   3552   getG(self3, returnType6, key16);
   3553   int64_t* returnType7;
   3554   getG(self3, returnType7, key16);
   3555   int32_t returnType8;
   3556   getG(self3, returnType8, key16);
   3557   int32_t* returnType9;
   3558   getG(self3, returnType9, key16);
   3559   uint64_t returnType10;
   3560   getG(self3, returnType10, key16);
   3561   uint64_t* returnType11;
   3562   getG(self3, returnType11, key16);
   3563   uint32_t returnType12;
   3564   getG(self3, returnType12, key16);
   3565   uint32_t* returnType13;
   3566   getG(self3, returnType13, key16);
   3567   char* returnType14;
   3568   getG(self3, returnType14, key16);
   3569   smallDictt* returnType15;
   3570   getG(self3, returnType15, key16);
   3571   smallArrayt* returnType16;
   3572   getG(self3, returnType16, key16);
   3573   smallBoolt* returnType17;
   3574   getG(self3, returnType17, key16);
   3575   smallBytest* returnType18;
   3576   getG(self3, returnType18, key16);
   3577   smallDoublet* returnType19;
   3578   getG(self3, returnType19, key16);
   3579   smallIntt* returnType20;
   3580   getG(self3, returnType20, key16);
   3581   smallJsont* returnType21;
   3582   getG(self3, returnType21, key16);
   3583   smallStringt* returnType22;
   3584   getG(self3, returnType22, key16);
   3585   void* returnType23;
   3586   getG(self3, returnType23, key16);
   3587   smallContainert* returnType24;
   3588   getG(self3, returnType24, key16);
   3589   baset* returnType25;
   3590   getG(self3, returnType25, key16);
   3591 }
   3592 {
   3593   smallJsont* self3;
   3594   const char * key0;
   3595   baset* returnType0;
   3596   getG(self3, returnType0, key0);
   3597 }
   3598 {
   3599   smallBytest* self4;
   3600   uint32_t key18;
   3601   char returnType0;
   3602   getG(self4, returnType0, key18);
   3603 }
   3604 {
   3605   smallStringt* self5;
   3606   int64_t key19;
   3607   char returnType0;
   3608   getG(self5, returnType0, key19);
   3609 }
   3610 {
   3611   smallBoolt* self6;
   3612   int64_t key20;
   3613   bool returnType0;
   3614   getG(self6, returnType0, key20);
   3615   bool* returnType1;
   3616   getG(self6, returnType1, key20);
   3617   bool* returnType2;
   3618   getG(self6, returnType2, key20);
   3619 }
   3620 {
   3621   smallContainert* self7;
   3622   int64_t key21;
   3623   void* returnType0;
   3624   getG(self7, returnType0, key21);
   3625 }
   3626 {
   3627   smallDoublet* self8;
   3628   int64_t key22;
   3629   double returnType0;
   3630   getG(self8, returnType0, key22);
   3631   double* returnType1;
   3632   getG(self8, returnType1, key22);
   3633   double* returnType2;
   3634   getG(self8, returnType2, key22);
   3635 }
   3636 {
   3637   smallIntt* self9;
   3638   int64_t key23;
   3639   int64_t returnType0;
   3640   getG(self9, returnType0, key23);
   3641   int64_t* returnType1;
   3642   getG(self9, returnType1, key23);
   3643   int32_t returnType2;
   3644   getG(self9, returnType2, key23);
   3645   int32_t* returnType3;
   3646   getG(self9, returnType3, key23);
   3647   uint64_t returnType4;
   3648   getG(self9, returnType4, key23);
   3649   uint64_t* returnType5;
   3650   getG(self9, returnType5, key23);
   3651   uint32_t returnType6;
   3652   getG(self9, returnType6, key23);
   3653   uint32_t* returnType7;
   3654   getG(self9, returnType7, key23);
   3655   int64_t* returnType8;
   3656   getG(self9, returnType8, key23);
   3657 }
   3658 {
   3659   char * self10;
   3660   int64_t key24;
   3661   int returnType0;
   3662   getG(self10, returnType0, key24);
   3663 }
   3664 {
   3665   const char * self11;
   3666   int64_t key25;
   3667   int returnType0;
   3668   getG(self11, returnType0, key25);
   3669 }
   3670 {
   3671   char ** self12;
   3672   int64_t key26;
   3673   int returnType0;
   3674   getG(self12, returnType0, key26);
   3675 }
   3676 {
   3677   const char ** self13;
   3678   int64_t key27;
   3679   int returnType0;
   3680   getG(self13, returnType0, key27);
   3681 }
   3682 {
   3683   smallDictt* self1;
   3684   char * key1;
   3685   baset* returnType0;
   3686   getNDupG(self1, returnType0, key1);
   3687   undefinedt* returnType1;
   3688   getNDupG(self1, returnType1, key1);
   3689   bool returnType2;
   3690   getNDupG(self1, returnType2, key1);
   3691   double returnType3;
   3692   getNDupG(self1, returnType3, key1);
   3693   int64_t returnType4;
   3694   getNDupG(self1, returnType4, key1);
   3695   int32_t returnType5;
   3696   getNDupG(self1, returnType5, key1);
   3697   uint64_t returnType6;
   3698   getNDupG(self1, returnType6, key1);
   3699   uint32_t returnType7;
   3700   getNDupG(self1, returnType7, key1);
   3701   char* returnType8;
   3702   getNDupG(self1, returnType8, key1);
   3703   smallDictt* returnType9;
   3704   getNDupG(self1, returnType9, key1);
   3705   smallArrayt* returnType10;
   3706   getNDupG(self1, returnType10, key1);
   3707   smallBoolt* returnType11;
   3708   getNDupG(self1, returnType11, key1);
   3709   smallBytest* returnType12;
   3710   getNDupG(self1, returnType12, key1);
   3711   smallDoublet* returnType13;
   3712   getNDupG(self1, returnType13, key1);
   3713   smallIntt* returnType14;
   3714   getNDupG(self1, returnType14, key1);
   3715   smallJsont* returnType15;
   3716   getNDupG(self1, returnType15, key1);
   3717   smallStringt* returnType16;
   3718   getNDupG(self1, returnType16, key1);
   3719   void* returnType17;
   3720   getNDupG(self1, returnType17, key1);
   3721   smallContainert* returnType18;
   3722   getNDupG(self1, returnType18, key1);
   3723   baset* returnType19;
   3724   getNDupG(self1, returnType19, key1);
   3725 }
   3726 {
   3727   smallDictt* self1;
   3728   const char * key2;
   3729   baset* returnType0;
   3730   getNDupG(self1, returnType0, key2);
   3731   undefinedt* returnType1;
   3732   getNDupG(self1, returnType1, key2);
   3733   bool returnType2;
   3734   getNDupG(self1, returnType2, key2);
   3735   double returnType3;
   3736   getNDupG(self1, returnType3, key2);
   3737   int64_t returnType4;
   3738   getNDupG(self1, returnType4, key2);
   3739   int32_t returnType5;
   3740   getNDupG(self1, returnType5, key2);
   3741   uint64_t returnType6;
   3742   getNDupG(self1, returnType6, key2);
   3743   uint32_t returnType7;
   3744   getNDupG(self1, returnType7, key2);
   3745   char* returnType8;
   3746   getNDupG(self1, returnType8, key2);
   3747   smallDictt* returnType9;
   3748   getNDupG(self1, returnType9, key2);
   3749   smallArrayt* returnType10;
   3750   getNDupG(self1, returnType10, key2);
   3751   smallBoolt* returnType11;
   3752   getNDupG(self1, returnType11, key2);
   3753   smallBytest* returnType12;
   3754   getNDupG(self1, returnType12, key2);
   3755   smallDoublet* returnType13;
   3756   getNDupG(self1, returnType13, key2);
   3757   smallIntt* returnType14;
   3758   getNDupG(self1, returnType14, key2);
   3759   smallJsont* returnType15;
   3760   getNDupG(self1, returnType15, key2);
   3761   smallStringt* returnType16;
   3762   getNDupG(self1, returnType16, key2);
   3763   void* returnType17;
   3764   getNDupG(self1, returnType17, key2);
   3765   smallContainert* returnType18;
   3766   getNDupG(self1, returnType18, key2);
   3767   baset* returnType19;
   3768   getNDupG(self1, returnType19, key2);
   3769 }
   3770 {
   3771   smallDictt* self1;
   3772   char key3;
   3773   baset* returnType0;
   3774   getNDupG(self1, returnType0, key3);
   3775   undefinedt* returnType1;
   3776   getNDupG(self1, returnType1, key3);
   3777   bool returnType2;
   3778   getNDupG(self1, returnType2, key3);
   3779   double returnType3;
   3780   getNDupG(self1, returnType3, key3);
   3781   int64_t returnType4;
   3782   getNDupG(self1, returnType4, key3);
   3783   int32_t returnType5;
   3784   getNDupG(self1, returnType5, key3);
   3785   uint64_t returnType6;
   3786   getNDupG(self1, returnType6, key3);
   3787   uint32_t returnType7;
   3788   getNDupG(self1, returnType7, key3);
   3789   char* returnType8;
   3790   getNDupG(self1, returnType8, key3);
   3791   smallDictt* returnType9;
   3792   getNDupG(self1, returnType9, key3);
   3793   smallArrayt* returnType10;
   3794   getNDupG(self1, returnType10, key3);
   3795   smallBoolt* returnType11;
   3796   getNDupG(self1, returnType11, key3);
   3797   smallBytest* returnType12;
   3798   getNDupG(self1, returnType12, key3);
   3799   smallDoublet* returnType13;
   3800   getNDupG(self1, returnType13, key3);
   3801   smallIntt* returnType14;
   3802   getNDupG(self1, returnType14, key3);
   3803   smallJsont* returnType15;
   3804   getNDupG(self1, returnType15, key3);
   3805   smallStringt* returnType16;
   3806   getNDupG(self1, returnType16, key3);
   3807   void* returnType17;
   3808   getNDupG(self1, returnType17, key3);
   3809   smallContainert* returnType18;
   3810   getNDupG(self1, returnType18, key3);
   3811   baset* returnType19;
   3812   getNDupG(self1, returnType19, key3);
   3813 }
   3814 {
   3815   smallDictt* self1;
   3816   int key4;
   3817   baset* returnType0;
   3818   getNDupG(self1, returnType0, key4);
   3819   undefinedt* returnType1;
   3820   getNDupG(self1, returnType1, key4);
   3821   bool returnType2;
   3822   getNDupG(self1, returnType2, key4);
   3823   double returnType3;
   3824   getNDupG(self1, returnType3, key4);
   3825   int64_t returnType4;
   3826   getNDupG(self1, returnType4, key4);
   3827   int32_t returnType5;
   3828   getNDupG(self1, returnType5, key4);
   3829   uint64_t returnType6;
   3830   getNDupG(self1, returnType6, key4);
   3831   uint32_t returnType7;
   3832   getNDupG(self1, returnType7, key4);
   3833   char* returnType8;
   3834   getNDupG(self1, returnType8, key4);
   3835   smallDictt* returnType9;
   3836   getNDupG(self1, returnType9, key4);
   3837   smallArrayt* returnType10;
   3838   getNDupG(self1, returnType10, key4);
   3839   smallBoolt* returnType11;
   3840   getNDupG(self1, returnType11, key4);
   3841   smallBytest* returnType12;
   3842   getNDupG(self1, returnType12, key4);
   3843   smallDoublet* returnType13;
   3844   getNDupG(self1, returnType13, key4);
   3845   smallIntt* returnType14;
   3846   getNDupG(self1, returnType14, key4);
   3847   smallJsont* returnType15;
   3848   getNDupG(self1, returnType15, key4);
   3849   smallStringt* returnType16;
   3850   getNDupG(self1, returnType16, key4);
   3851   void* returnType17;
   3852   getNDupG(self1, returnType17, key4);
   3853   smallContainert* returnType18;
   3854   getNDupG(self1, returnType18, key4);
   3855   baset* returnType19;
   3856   getNDupG(self1, returnType19, key4);
   3857 }
   3858 {
   3859   smallDictt* self1;
   3860   const char * key0;
   3861   baset* returnType0;
   3862   getNDupG(self1, returnType0, key0);
   3863 }
   3864 {
   3865   smallArrayt* self2;
   3866   int64_t key6;
   3867   baset* returnType0;
   3868   getNDupG(self2, returnType0, key6);
   3869   undefinedt* returnType1;
   3870   getNDupG(self2, returnType1, key6);
   3871   bool returnType2;
   3872   getNDupG(self2, returnType2, key6);
   3873   double returnType3;
   3874   getNDupG(self2, returnType3, key6);
   3875   int64_t returnType4;
   3876   getNDupG(self2, returnType4, key6);
   3877   int32_t returnType5;
   3878   getNDupG(self2, returnType5, key6);
   3879   uint64_t returnType6;
   3880   getNDupG(self2, returnType6, key6);
   3881   uint32_t returnType7;
   3882   getNDupG(self2, returnType7, key6);
   3883   char* returnType8;
   3884   getNDupG(self2, returnType8, key6);
   3885   smallDictt* returnType9;
   3886   getNDupG(self2, returnType9, key6);
   3887   smallArrayt* returnType10;
   3888   getNDupG(self2, returnType10, key6);
   3889   smallBoolt* returnType11;
   3890   getNDupG(self2, returnType11, key6);
   3891   smallBytest* returnType12;
   3892   getNDupG(self2, returnType12, key6);
   3893   smallDoublet* returnType13;
   3894   getNDupG(self2, returnType13, key6);
   3895   smallIntt* returnType14;
   3896   getNDupG(self2, returnType14, key6);
   3897   smallJsont* returnType15;
   3898   getNDupG(self2, returnType15, key6);
   3899   smallStringt* returnType16;
   3900   getNDupG(self2, returnType16, key6);
   3901   void* returnType17;
   3902   getNDupG(self2, returnType17, key6);
   3903   smallContainert* returnType18;
   3904   getNDupG(self2, returnType18, key6);
   3905   baset* returnType19;
   3906   getNDupG(self2, returnType19, key6);
   3907 }
   3908 {
   3909   smallJsont* self3;
   3910   char * key7;
   3911   baset* returnType0;
   3912   getNDupG(self3, returnType0, key7);
   3913   undefinedt* returnType1;
   3914   getNDupG(self3, returnType1, key7);
   3915   bool returnType2;
   3916   getNDupG(self3, returnType2, key7);
   3917   double returnType3;
   3918   getNDupG(self3, returnType3, key7);
   3919   int64_t returnType4;
   3920   getNDupG(self3, returnType4, key7);
   3921   int32_t returnType5;
   3922   getNDupG(self3, returnType5, key7);
   3923   uint64_t returnType6;
   3924   getNDupG(self3, returnType6, key7);
   3925   uint32_t returnType7;
   3926   getNDupG(self3, returnType7, key7);
   3927   char* returnType8;
   3928   getNDupG(self3, returnType8, key7);
   3929   smallDictt* returnType9;
   3930   getNDupG(self3, returnType9, key7);
   3931   smallArrayt* returnType10;
   3932   getNDupG(self3, returnType10, key7);
   3933   smallBoolt* returnType11;
   3934   getNDupG(self3, returnType11, key7);
   3935   smallBytest* returnType12;
   3936   getNDupG(self3, returnType12, key7);
   3937   smallDoublet* returnType13;
   3938   getNDupG(self3, returnType13, key7);
   3939   smallIntt* returnType14;
   3940   getNDupG(self3, returnType14, key7);
   3941   smallJsont* returnType15;
   3942   getNDupG(self3, returnType15, key7);
   3943   smallStringt* returnType16;
   3944   getNDupG(self3, returnType16, key7);
   3945   void* returnType17;
   3946   getNDupG(self3, returnType17, key7);
   3947   smallContainert* returnType18;
   3948   getNDupG(self3, returnType18, key7);
   3949   baset* returnType19;
   3950   getNDupG(self3, returnType19, key7);
   3951 }
   3952 {
   3953   smallJsont* self3;
   3954   const char * key8;
   3955   baset* returnType0;
   3956   getNDupG(self3, returnType0, key8);
   3957   undefinedt* returnType1;
   3958   getNDupG(self3, returnType1, key8);
   3959   bool returnType2;
   3960   getNDupG(self3, returnType2, key8);
   3961   double returnType3;
   3962   getNDupG(self3, returnType3, key8);
   3963   int64_t returnType4;
   3964   getNDupG(self3, returnType4, key8);
   3965   int32_t returnType5;
   3966   getNDupG(self3, returnType5, key8);
   3967   uint64_t returnType6;
   3968   getNDupG(self3, returnType6, key8);
   3969   uint32_t returnType7;
   3970   getNDupG(self3, returnType7, key8);
   3971   char* returnType8;
   3972   getNDupG(self3, returnType8, key8);
   3973   smallDictt* returnType9;
   3974   getNDupG(self3, returnType9, key8);
   3975   smallArrayt* returnType10;
   3976   getNDupG(self3, returnType10, key8);
   3977   smallBoolt* returnType11;
   3978   getNDupG(self3, returnType11, key8);
   3979   smallBytest* returnType12;
   3980   getNDupG(self3, returnType12, key8);
   3981   smallDoublet* returnType13;
   3982   getNDupG(self3, returnType13, key8);
   3983   smallIntt* returnType14;
   3984   getNDupG(self3, returnType14, key8);
   3985   smallJsont* returnType15;
   3986   getNDupG(self3, returnType15, key8);
   3987   smallStringt* returnType16;
   3988   getNDupG(self3, returnType16, key8);
   3989   void* returnType17;
   3990   getNDupG(self3, returnType17, key8);
   3991   smallContainert* returnType18;
   3992   getNDupG(self3, returnType18, key8);
   3993   baset* returnType19;
   3994   getNDupG(self3, returnType19, key8);
   3995 }
   3996 {
   3997   smallJsont* self3;
   3998   int64_t key9;
   3999   baset* returnType0;
   4000   getNDupG(self3, returnType0, key9);
   4001   undefinedt* returnType1;
   4002   getNDupG(self3, returnType1, key9);
   4003   bool returnType2;
   4004   getNDupG(self3, returnType2, key9);
   4005   double returnType3;
   4006   getNDupG(self3, returnType3, key9);
   4007   int64_t returnType4;
   4008   getNDupG(self3, returnType4, key9);
   4009   int32_t returnType5;
   4010   getNDupG(self3, returnType5, key9);
   4011   uint64_t returnType6;
   4012   getNDupG(self3, returnType6, key9);
   4013   uint32_t returnType7;
   4014   getNDupG(self3, returnType7, key9);
   4015   char* returnType8;
   4016   getNDupG(self3, returnType8, key9);
   4017   smallDictt* returnType9;
   4018   getNDupG(self3, returnType9, key9);
   4019   smallArrayt* returnType10;
   4020   getNDupG(self3, returnType10, key9);
   4021   smallBoolt* returnType11;
   4022   getNDupG(self3, returnType11, key9);
   4023   smallBytest* returnType12;
   4024   getNDupG(self3, returnType12, key9);
   4025   smallDoublet* returnType13;
   4026   getNDupG(self3, returnType13, key9);
   4027   smallIntt* returnType14;
   4028   getNDupG(self3, returnType14, key9);
   4029   smallJsont* returnType15;
   4030   getNDupG(self3, returnType15, key9);
   4031   smallStringt* returnType16;
   4032   getNDupG(self3, returnType16, key9);
   4033   void* returnType17;
   4034   getNDupG(self3, returnType17, key9);
   4035   smallContainert* returnType18;
   4036   getNDupG(self3, returnType18, key9);
   4037   baset* returnType19;
   4038   getNDupG(self3, returnType19, key9);
   4039 }
   4040 {
   4041   smallJsont* self3;
   4042   int32_t key10;
   4043   baset* returnType0;
   4044   getNDupG(self3, returnType0, key10);
   4045   undefinedt* returnType1;
   4046   getNDupG(self3, returnType1, key10);
   4047   bool returnType2;
   4048   getNDupG(self3, returnType2, key10);
   4049   double returnType3;
   4050   getNDupG(self3, returnType3, key10);
   4051   int64_t returnType4;
   4052   getNDupG(self3, returnType4, key10);
   4053   int32_t returnType5;
   4054   getNDupG(self3, returnType5, key10);
   4055   uint64_t returnType6;
   4056   getNDupG(self3, returnType6, key10);
   4057   uint32_t returnType7;
   4058   getNDupG(self3, returnType7, key10);
   4059   char* returnType8;
   4060   getNDupG(self3, returnType8, key10);
   4061   smallDictt* returnType9;
   4062   getNDupG(self3, returnType9, key10);
   4063   smallArrayt* returnType10;
   4064   getNDupG(self3, returnType10, key10);
   4065   smallBoolt* returnType11;
   4066   getNDupG(self3, returnType11, key10);
   4067   smallBytest* returnType12;
   4068   getNDupG(self3, returnType12, key10);
   4069   smallDoublet* returnType13;
   4070   getNDupG(self3, returnType13, key10);
   4071   smallIntt* returnType14;
   4072   getNDupG(self3, returnType14, key10);
   4073   smallJsont* returnType15;
   4074   getNDupG(self3, returnType15, key10);
   4075   smallStringt* returnType16;
   4076   getNDupG(self3, returnType16, key10);
   4077   void* returnType17;
   4078   getNDupG(self3, returnType17, key10);
   4079   smallContainert* returnType18;
   4080   getNDupG(self3, returnType18, key10);
   4081   baset* returnType19;
   4082   getNDupG(self3, returnType19, key10);
   4083 }
   4084 {
   4085   smallJsont* self3;
   4086   int16_t key11;
   4087   baset* returnType0;
   4088   getNDupG(self3, returnType0, key11);
   4089   undefinedt* returnType1;
   4090   getNDupG(self3, returnType1, key11);
   4091   bool returnType2;
   4092   getNDupG(self3, returnType2, key11);
   4093   double returnType3;
   4094   getNDupG(self3, returnType3, key11);
   4095   int64_t returnType4;
   4096   getNDupG(self3, returnType4, key11);
   4097   int32_t returnType5;
   4098   getNDupG(self3, returnType5, key11);
   4099   uint64_t returnType6;
   4100   getNDupG(self3, returnType6, key11);
   4101   uint32_t returnType7;
   4102   getNDupG(self3, returnType7, key11);
   4103   char* returnType8;
   4104   getNDupG(self3, returnType8, key11);
   4105   smallDictt* returnType9;
   4106   getNDupG(self3, returnType9, key11);
   4107   smallArrayt* returnType10;
   4108   getNDupG(self3, returnType10, key11);
   4109   smallBoolt* returnType11;
   4110   getNDupG(self3, returnType11, key11);
   4111   smallBytest* returnType12;
   4112   getNDupG(self3, returnType12, key11);
   4113   smallDoublet* returnType13;
   4114   getNDupG(self3, returnType13, key11);
   4115   smallIntt* returnType14;
   4116   getNDupG(self3, returnType14, key11);
   4117   smallJsont* returnType15;
   4118   getNDupG(self3, returnType15, key11);
   4119   smallStringt* returnType16;
   4120   getNDupG(self3, returnType16, key11);
   4121   void* returnType17;
   4122   getNDupG(self3, returnType17, key11);
   4123   smallContainert* returnType18;
   4124   getNDupG(self3, returnType18, key11);
   4125   baset* returnType19;
   4126   getNDupG(self3, returnType19, key11);
   4127 }
   4128 {
   4129   smallJsont* self3;
   4130   int8_t key12;
   4131   baset* returnType0;
   4132   getNDupG(self3, returnType0, key12);
   4133   undefinedt* returnType1;
   4134   getNDupG(self3, returnType1, key12);
   4135   bool returnType2;
   4136   getNDupG(self3, returnType2, key12);
   4137   double returnType3;
   4138   getNDupG(self3, returnType3, key12);
   4139   int64_t returnType4;
   4140   getNDupG(self3, returnType4, key12);
   4141   int32_t returnType5;
   4142   getNDupG(self3, returnType5, key12);
   4143   uint64_t returnType6;
   4144   getNDupG(self3, returnType6, key12);
   4145   uint32_t returnType7;
   4146   getNDupG(self3, returnType7, key12);
   4147   char* returnType8;
   4148   getNDupG(self3, returnType8, key12);
   4149   smallDictt* returnType9;
   4150   getNDupG(self3, returnType9, key12);
   4151   smallArrayt* returnType10;
   4152   getNDupG(self3, returnType10, key12);
   4153   smallBoolt* returnType11;
   4154   getNDupG(self3, returnType11, key12);
   4155   smallBytest* returnType12;
   4156   getNDupG(self3, returnType12, key12);
   4157   smallDoublet* returnType13;
   4158   getNDupG(self3, returnType13, key12);
   4159   smallIntt* returnType14;
   4160   getNDupG(self3, returnType14, key12);
   4161   smallJsont* returnType15;
   4162   getNDupG(self3, returnType15, key12);
   4163   smallStringt* returnType16;
   4164   getNDupG(self3, returnType16, key12);
   4165   void* returnType17;
   4166   getNDupG(self3, returnType17, key12);
   4167   smallContainert* returnType18;
   4168   getNDupG(self3, returnType18, key12);
   4169   baset* returnType19;
   4170   getNDupG(self3, returnType19, key12);
   4171 }
   4172 {
   4173   smallJsont* self3;
   4174   uint64_t key13;
   4175   baset* returnType0;
   4176   getNDupG(self3, returnType0, key13);
   4177   undefinedt* returnType1;
   4178   getNDupG(self3, returnType1, key13);
   4179   bool returnType2;
   4180   getNDupG(self3, returnType2, key13);
   4181   double returnType3;
   4182   getNDupG(self3, returnType3, key13);
   4183   int64_t returnType4;
   4184   getNDupG(self3, returnType4, key13);
   4185   int32_t returnType5;
   4186   getNDupG(self3, returnType5, key13);
   4187   uint64_t returnType6;
   4188   getNDupG(self3, returnType6, key13);
   4189   uint32_t returnType7;
   4190   getNDupG(self3, returnType7, key13);
   4191   char* returnType8;
   4192   getNDupG(self3, returnType8, key13);
   4193   smallDictt* returnType9;
   4194   getNDupG(self3, returnType9, key13);
   4195   smallArrayt* returnType10;
   4196   getNDupG(self3, returnType10, key13);
   4197   smallBoolt* returnType11;
   4198   getNDupG(self3, returnType11, key13);
   4199   smallBytest* returnType12;
   4200   getNDupG(self3, returnType12, key13);
   4201   smallDoublet* returnType13;
   4202   getNDupG(self3, returnType13, key13);
   4203   smallIntt* returnType14;
   4204   getNDupG(self3, returnType14, key13);
   4205   smallJsont* returnType15;
   4206   getNDupG(self3, returnType15, key13);
   4207   smallStringt* returnType16;
   4208   getNDupG(self3, returnType16, key13);
   4209   void* returnType17;
   4210   getNDupG(self3, returnType17, key13);
   4211   smallContainert* returnType18;
   4212   getNDupG(self3, returnType18, key13);
   4213   baset* returnType19;
   4214   getNDupG(self3, returnType19, key13);
   4215 }
   4216 {
   4217   smallJsont* self3;
   4218   uint32_t key14;
   4219   baset* returnType0;
   4220   getNDupG(self3, returnType0, key14);
   4221   undefinedt* returnType1;
   4222   getNDupG(self3, returnType1, key14);
   4223   bool returnType2;
   4224   getNDupG(self3, returnType2, key14);
   4225   double returnType3;
   4226   getNDupG(self3, returnType3, key14);
   4227   int64_t returnType4;
   4228   getNDupG(self3, returnType4, key14);
   4229   int32_t returnType5;
   4230   getNDupG(self3, returnType5, key14);
   4231   uint64_t returnType6;
   4232   getNDupG(self3, returnType6, key14);
   4233   uint32_t returnType7;
   4234   getNDupG(self3, returnType7, key14);
   4235   char* returnType8;
   4236   getNDupG(self3, returnType8, key14);
   4237   smallDictt* returnType9;
   4238   getNDupG(self3, returnType9, key14);
   4239   smallArrayt* returnType10;
   4240   getNDupG(self3, returnType10, key14);
   4241   smallBoolt* returnType11;
   4242   getNDupG(self3, returnType11, key14);
   4243   smallBytest* returnType12;
   4244   getNDupG(self3, returnType12, key14);
   4245   smallDoublet* returnType13;
   4246   getNDupG(self3, returnType13, key14);
   4247   smallIntt* returnType14;
   4248   getNDupG(self3, returnType14, key14);
   4249   smallJsont* returnType15;
   4250   getNDupG(self3, returnType15, key14);
   4251   smallStringt* returnType16;
   4252   getNDupG(self3, returnType16, key14);
   4253   void* returnType17;
   4254   getNDupG(self3, returnType17, key14);
   4255   smallContainert* returnType18;
   4256   getNDupG(self3, returnType18, key14);
   4257   baset* returnType19;
   4258   getNDupG(self3, returnType19, key14);
   4259 }
   4260 {
   4261   smallJsont* self3;
   4262   uint16_t key15;
   4263   baset* returnType0;
   4264   getNDupG(self3, returnType0, key15);
   4265   undefinedt* returnType1;
   4266   getNDupG(self3, returnType1, key15);
   4267   bool returnType2;
   4268   getNDupG(self3, returnType2, key15);
   4269   double returnType3;
   4270   getNDupG(self3, returnType3, key15);
   4271   int64_t returnType4;
   4272   getNDupG(self3, returnType4, key15);
   4273   int32_t returnType5;
   4274   getNDupG(self3, returnType5, key15);
   4275   uint64_t returnType6;
   4276   getNDupG(self3, returnType6, key15);
   4277   uint32_t returnType7;
   4278   getNDupG(self3, returnType7, key15);
   4279   char* returnType8;
   4280   getNDupG(self3, returnType8, key15);
   4281   smallDictt* returnType9;
   4282   getNDupG(self3, returnType9, key15);
   4283   smallArrayt* returnType10;
   4284   getNDupG(self3, returnType10, key15);
   4285   smallBoolt* returnType11;
   4286   getNDupG(self3, returnType11, key15);
   4287   smallBytest* returnType12;
   4288   getNDupG(self3, returnType12, key15);
   4289   smallDoublet* returnType13;
   4290   getNDupG(self3, returnType13, key15);
   4291   smallIntt* returnType14;
   4292   getNDupG(self3, returnType14, key15);
   4293   smallJsont* returnType15;
   4294   getNDupG(self3, returnType15, key15);
   4295   smallStringt* returnType16;
   4296   getNDupG(self3, returnType16, key15);
   4297   void* returnType17;
   4298   getNDupG(self3, returnType17, key15);
   4299   smallContainert* returnType18;
   4300   getNDupG(self3, returnType18, key15);
   4301   baset* returnType19;
   4302   getNDupG(self3, returnType19, key15);
   4303 }
   4304 {
   4305   smallJsont* self3;
   4306   uint8_t key16;
   4307   baset* returnType0;
   4308   getNDupG(self3, returnType0, key16);
   4309   undefinedt* returnType1;
   4310   getNDupG(self3, returnType1, key16);
   4311   bool returnType2;
   4312   getNDupG(self3, returnType2, key16);
   4313   double returnType3;
   4314   getNDupG(self3, returnType3, key16);
   4315   int64_t returnType4;
   4316   getNDupG(self3, returnType4, key16);
   4317   int32_t returnType5;
   4318   getNDupG(self3, returnType5, key16);
   4319   uint64_t returnType6;
   4320   getNDupG(self3, returnType6, key16);
   4321   uint32_t returnType7;
   4322   getNDupG(self3, returnType7, key16);
   4323   char* returnType8;
   4324   getNDupG(self3, returnType8, key16);
   4325   smallDictt* returnType9;
   4326   getNDupG(self3, returnType9, key16);
   4327   smallArrayt* returnType10;
   4328   getNDupG(self3, returnType10, key16);
   4329   smallBoolt* returnType11;
   4330   getNDupG(self3, returnType11, key16);
   4331   smallBytest* returnType12;
   4332   getNDupG(self3, returnType12, key16);
   4333   smallDoublet* returnType13;
   4334   getNDupG(self3, returnType13, key16);
   4335   smallIntt* returnType14;
   4336   getNDupG(self3, returnType14, key16);
   4337   smallJsont* returnType15;
   4338   getNDupG(self3, returnType15, key16);
   4339   smallStringt* returnType16;
   4340   getNDupG(self3, returnType16, key16);
   4341   void* returnType17;
   4342   getNDupG(self3, returnType17, key16);
   4343   smallContainert* returnType18;
   4344   getNDupG(self3, returnType18, key16);
   4345   baset* returnType19;
   4346   getNDupG(self3, returnType19, key16);
   4347 }
   4348 {
   4349   smallJsont* self3;
   4350   const char * key0;
   4351   baset* returnType0;
   4352   getNDupG(self3, returnType0, key0);
   4353 }
   4354 {
   4355   smallBytest* self4;
   4356   uint32_t key18;
   4357   char returnType0;
   4358   getNDupG(self4, returnType0, key18);
   4359 }
   4360 {
   4361   smallStringt* self5;
   4362   int64_t key19;
   4363   char returnType0;
   4364   getNDupG(self5, returnType0, key19);
   4365 }
   4366 {
   4367   smallBoolt* self6;
   4368   int64_t key20;
   4369   bool returnType0;
   4370   getNDupG(self6, returnType0, key20);
   4371 }
   4372 {
   4373   smallContainert* self7;
   4374   int64_t key21;
   4375   void* returnType0;
   4376   getNDupG(self7, returnType0, key21);
   4377 }
   4378 {
   4379   smallDoublet* self8;
   4380   int64_t key22;
   4381   double returnType0;
   4382   getNDupG(self8, returnType0, key22);
   4383 }
   4384 {
   4385   smallIntt* self9;
   4386   int64_t key23;
   4387   int64_t returnType0;
   4388   getNDupG(self9, returnType0, key23);
   4389   int32_t returnType1;
   4390   getNDupG(self9, returnType1, key23);
   4391   uint64_t returnType2;
   4392   getNDupG(self9, returnType2, key23);
   4393   uint32_t returnType3;
   4394   getNDupG(self9, returnType3, key23);
   4395   int64_t returnType4;
   4396   getNDupG(self9, returnType4, key23);
   4397 }
   4398 {
   4399   char * self10;
   4400   int64_t key24;
   4401   int returnType0;
   4402   getNDupG(self10, returnType0, key24);
   4403 }
   4404 {
   4405   const char * self11;
   4406   int64_t key25;
   4407   int returnType0;
   4408   getNDupG(self11, returnType0, key25);
   4409 }
   4410 {
   4411   char ** self12;
   4412   int64_t key26;
   4413   int returnType0;
   4414   getNDupG(self12, returnType0, key26);
   4415 }
   4416 {
   4417   const char ** self13;
   4418   int64_t key27;
   4419   int returnType0;
   4420   getNDupG(self13, returnType0, key27);
   4421 }
   4422 {
   4423   smallDictt* self1;
   4424   const char * key0;
   4425   getNumG(self1, key0);
   4426 }
   4427 {
   4428   smallArrayt* self2;
   4429   int64_t key0;
   4430   getNumG(self2, key0);
   4431 }
   4432 {
   4433   smallJsont* self3;
   4434   char* key0;
   4435   getNumG(self3, key0);
   4436   const char* key1;
   4437   getNumG(self3, key1);
   4438   int64_t key2;
   4439   getNumG(self3, key2);
   4440   int32_t key3;
   4441   getNumG(self3, key3);
   4442   int16_t key4;
   4443   getNumG(self3, key4);
   4444   int8_t key5;
   4445   getNumG(self3, key5);
   4446   uint64_t key6;
   4447   getNumG(self3, key6);
   4448   uint32_t key7;
   4449   getNumG(self3, key7);
   4450   uint16_t key8;
   4451   getNumG(self3, key8);
   4452   uint8_t key9;
   4453   getNumG(self3, key9);
   4454 }
   4455 {
   4456   smallDictt* self1;
   4457   smallDictt* obj0;
   4458   appendG(self1, obj0);
   4459   smallJsont* obj1;
   4460   appendG(self1, obj1);
   4461   smallDictt * obj2;
   4462   appendG(self1, obj2);
   4463 }
   4464 {
   4465   smallArrayt* self2;
   4466   smallArrayt * obj0;
   4467   appendG(self2, obj0);
   4468   smallJsont * obj1;
   4469   appendG(self2, obj1);
   4470   char ** obj2;
   4471   appendG(self2, obj2);
   4472   const char ** obj3;
   4473   appendG(self2, obj3);
   4474   smallArrayt * obj4;
   4475   appendG(self2, obj4);
   4476 }
   4477 {
   4478   smallJsont* self3;
   4479   smallArrayt * obj0;
   4480   appendG(self3, obj0);
   4481   char ** obj1;
   4482   appendG(self3, obj1);
   4483   const char ** obj2;
   4484   appendG(self3, obj2);
   4485   smallDictt * obj3;
   4486   appendG(self3, obj3);
   4487   smallJsont * obj4;
   4488   appendG(self3, obj4);
   4489   smallJsont * obj5;
   4490   appendG(self3, obj5);
   4491 }
   4492 {
   4493   smallStringt* self4;
   4494   smallStringt* obj0;
   4495   appendG(self4, obj0);
   4496   smallJsont* obj1;
   4497   appendG(self4, obj1);
   4498   char * obj2;
   4499   appendG(self4, obj2);
   4500   char obj3;
   4501   appendG(self4, obj3);
   4502   int obj4;
   4503   appendG(self4, obj4);
   4504   const char * obj5;
   4505   appendG(self4, obj5);
   4506 }
   4507 {
   4508   char self5;
   4509   const char * obj0;
   4510   appendG(self5, obj0);
   4511 }
   4512 {
   4513   int self6;
   4514   const char * obj0;
   4515   appendG(self6, obj0);
   4516 }
   4517 {
   4518   char * self7;
   4519   char * obj0;
   4520   appendG(self7, obj0);
   4521   const char * obj1;
   4522   appendG(self7, obj1);
   4523   char obj2;
   4524   appendG(self7, obj2);
   4525   int obj3;
   4526   appendG(self7, obj3);
   4527   const char * obj4;
   4528   appendG(self7, obj4);
   4529 }
   4530 {
   4531   const char * self8;
   4532   char * obj0;
   4533   appendG(self8, obj0);
   4534   const char * obj1;
   4535   appendG(self8, obj1);
   4536   char obj2;
   4537   appendG(self8, obj2);
   4538   int obj3;
   4539   appendG(self8, obj3);
   4540   const char * obj4;
   4541   appendG(self8, obj4);
   4542 }
   4543 {
   4544   char ** self9;
   4545   char * obj0;
   4546   appendG(self9, obj0);
   4547   const char * obj1;
   4548   appendG(self9, obj1);
   4549   char obj2;
   4550   appendG(self9, obj2);
   4551   int obj3;
   4552   appendG(self9, obj3);
   4553   const char * obj4;
   4554   appendG(self9, obj4);
   4555 }
   4556 {
   4557   char *** self10;
   4558   char ** obj0;
   4559   appendG(self10, obj0);
   4560 }
   4561 {
   4562   smallDictt* self1;
   4563   smallDictt* obj0;
   4564   appendNSmashG(self1, obj0);
   4565   smallJsont* obj1;
   4566   appendNSmashG(self1, obj1);
   4567   smallDictt * obj2;
   4568   appendNSmashG(self1, obj2);
   4569 }
   4570 {
   4571   smallArrayt* self2;
   4572   smallArrayt * obj0;
   4573   appendNSmashG(self2, obj0);
   4574   smallJsont * obj1;
   4575   appendNSmashG(self2, obj1);
   4576   char ** obj2;
   4577   appendNSmashG(self2, obj2);
   4578   smallArrayt * obj3;
   4579   appendNSmashG(self2, obj3);
   4580 }
   4581 {
   4582   smallJsont* self3;
   4583   smallArrayt * obj0;
   4584   appendNSmashG(self3, obj0);
   4585   char ** obj1;
   4586   appendNSmashG(self3, obj1);
   4587   smallDictt * obj2;
   4588   appendNSmashG(self3, obj2);
   4589   smallJsont * obj3;
   4590   appendNSmashG(self3, obj3);
   4591   smallJsont * obj4;
   4592   appendNSmashG(self3, obj4);
   4593 }
   4594 {
   4595   smallStringt* self4;
   4596   smallStringt* obj0;
   4597   appendNSmashG(self4, obj0);
   4598   smallJsont* obj1;
   4599   appendNSmashG(self4, obj1);
   4600   char * obj2;
   4601   appendNSmashG(self4, obj2);
   4602   char obj3;
   4603   appendNSmashG(self4, obj3);
   4604   int obj4;
   4605   appendNSmashG(self4, obj4);
   4606   const char * obj5;
   4607   appendNSmashG(self4, obj5);
   4608 }
   4609 {
   4610   char ** self5;
   4611   char * obj0;
   4612   appendNSmashG(self5, obj0);
   4613   char obj1;
   4614   appendNSmashG(self5, obj1);
   4615   int obj2;
   4616   appendNSmashG(self5, obj2);
   4617   char * obj3;
   4618   appendNSmashG(self5, obj3);
   4619 }
   4620 {
   4621   char *** self6;
   4622   char ** obj0;
   4623   appendNSmashG(self6, obj0);
   4624 }
   4625 {
   4626   smallArrayt* self1;
   4627   baset* value0;
   4628   prependG(self1, value0);
   4629   bool value1;
   4630   prependG(self1, value1);
   4631   double value2;
   4632   prependG(self1, value2);
   4633   int64_t value3;
   4634   prependG(self1, value3);
   4635   int32_t value4;
   4636   prependG(self1, value4);
   4637   uint32_t value5;
   4638   prependG(self1, value5);
   4639   uint64_t value6;
   4640   prependG(self1, value6);
   4641   char* value7;
   4642   prependG(self1, value7);
   4643   char value8;
   4644   prependG(self1, value8);
   4645   const char* value9;
   4646   prependG(self1, value9);
   4647   smallDictt* value10;
   4648   prependG(self1, value10);
   4649   smallArrayt* value11;
   4650   prependG(self1, value11);
   4651   char ** value12;
   4652   prependG(self1, value12);
   4653   const char ** value13;
   4654   prependG(self1, value13);
   4655   smallBoolt* value14;
   4656   prependG(self1, value14);
   4657   smallBytest* value15;
   4658   prependG(self1, value15);
   4659   smallDoublet* value16;
   4660   prependG(self1, value16);
   4661   smallIntt* value17;
   4662   prependG(self1, value17);
   4663   smallJsont* value18;
   4664   prependG(self1, value18);
   4665   smallStringt* value19;
   4666   prependG(self1, value19);
   4667   smallContainert* value20;
   4668   prependG(self1, value20);
   4669   undefinedt* value21;
   4670   prependG(self1, value21);
   4671   void * value22;
   4672   prependG(self1, value22);
   4673 }
   4674 {
   4675   smallJsont* self2;
   4676   baset* value0;
   4677   prependG(self2, value0);
   4678   bool value1;
   4679   prependG(self2, value1);
   4680   double value2;
   4681   prependG(self2, value2);
   4682   int64_t value3;
   4683   prependG(self2, value3);
   4684   int32_t value4;
   4685   prependG(self2, value4);
   4686   uint32_t value5;
   4687   prependG(self2, value5);
   4688   uint64_t value6;
   4689   prependG(self2, value6);
   4690   char* value7;
   4691   prependG(self2, value7);
   4692   char value8;
   4693   prependG(self2, value8);
   4694   const char* value9;
   4695   prependG(self2, value9);
   4696   smallDictt* value10;
   4697   prependG(self2, value10);
   4698   smallArrayt* value11;
   4699   prependG(self2, value11);
   4700   char ** value12;
   4701   prependG(self2, value12);
   4702   const char ** value13;
   4703   prependG(self2, value13);
   4704   smallBoolt* value14;
   4705   prependG(self2, value14);
   4706   smallBytest* value15;
   4707   prependG(self2, value15);
   4708   smallDoublet* value16;
   4709   prependG(self2, value16);
   4710   smallIntt* value17;
   4711   prependG(self2, value17);
   4712   smallJsont* value18;
   4713   prependG(self2, value18);
   4714   smallStringt* value19;
   4715   prependG(self2, value19);
   4716   smallContainert* value20;
   4717   prependG(self2, value20);
   4718   undefinedt* value21;
   4719   prependG(self2, value21);
   4720   void * value22;
   4721   prependG(self2, value22);
   4722 }
   4723 {
   4724   smallStringt* self3;
   4725   smallStringt* value0;
   4726   prependG(self3, value0);
   4727   smallJsont* value1;
   4728   prependG(self3, value1);
   4729   char * value2;
   4730   prependG(self3, value2);
   4731   char value3;
   4732   prependG(self3, value3);
   4733   int value4;
   4734   prependG(self3, value4);
   4735   const char * value5;
   4736   prependG(self3, value5);
   4737 }
   4738 {
   4739   char self4;
   4740   const char * value0;
   4741   prependG(self4, value0);
   4742 }
   4743 {
   4744   int self5;
   4745   const char * value0;
   4746   prependG(self5, value0);
   4747 }
   4748 {
   4749   char * self6;
   4750   char * value0;
   4751   prependG(self6, value0);
   4752   const char * value1;
   4753   prependG(self6, value1);
   4754   char value2;
   4755   prependG(self6, value2);
   4756   int value3;
   4757   prependG(self6, value3);
   4758   const char * value4;
   4759   prependG(self6, value4);
   4760 }
   4761 {
   4762   const char * self7;
   4763   char * value0;
   4764   prependG(self7, value0);
   4765   const char * value1;
   4766   prependG(self7, value1);
   4767   char value2;
   4768   prependG(self7, value2);
   4769   int value3;
   4770   prependG(self7, value3);
   4771   const char * value4;
   4772   prependG(self7, value4);
   4773 }
   4774 {
   4775   char ** self8;
   4776   char * value0;
   4777   prependG(self8, value0);
   4778   const char * value1;
   4779   prependG(self8, value1);
   4780   char value2;
   4781   prependG(self8, value2);
   4782   int value3;
   4783   prependG(self8, value3);
   4784   const char * value4;
   4785   prependG(self8, value4);
   4786 }
   4787 {
   4788   char *** self9;
   4789   char * value0;
   4790   prependG(self9, value0);
   4791   const char * value1;
   4792   prependG(self9, value1);
   4793   char value2;
   4794   prependG(self9, value2);
   4795   int value3;
   4796   prependG(self9, value3);
   4797   const char * value4;
   4798   prependG(self9, value4);
   4799 }
   4800 {
   4801   smallArrayt* self1;
   4802   baset* obj0;
   4803   prependNFreeG(self1, obj0);
   4804   bool obj1;
   4805   prependNFreeG(self1, obj1);
   4806   double obj2;
   4807   prependNFreeG(self1, obj2);
   4808   int64_t obj3;
   4809   prependNFreeG(self1, obj3);
   4810   int32_t obj4;
   4811   prependNFreeG(self1, obj4);
   4812   uint32_t obj5;
   4813   prependNFreeG(self1, obj5);
   4814   uint64_t obj6;
   4815   prependNFreeG(self1, obj6);
   4816   char* obj7;
   4817   prependNFreeG(self1, obj7);
   4818   char obj8;
   4819   prependNFreeG(self1, obj8);
   4820   smallDictt* obj9;
   4821   prependNFreeG(self1, obj9);
   4822   smallArrayt* obj10;
   4823   prependNFreeG(self1, obj10);
   4824   char ** obj11;
   4825   prependNFreeG(self1, obj11);
   4826   smallBoolt* obj12;
   4827   prependNFreeG(self1, obj12);
   4828   smallBytest* obj13;
   4829   prependNFreeG(self1, obj13);
   4830   smallDoublet* obj14;
   4831   prependNFreeG(self1, obj14);
   4832   smallIntt* obj15;
   4833   prependNFreeG(self1, obj15);
   4834   smallJsont* obj16;
   4835   prependNFreeG(self1, obj16);
   4836   smallStringt* obj17;
   4837   prependNFreeG(self1, obj17);
   4838   smallContainert* obj18;
   4839   prependNFreeG(self1, obj18);
   4840   undefinedt* obj19;
   4841   prependNFreeG(self1, obj19);
   4842   void * obj20;
   4843   prependNFreeG(self1, obj20);
   4844 }
   4845 {
   4846   smallJsont* self2;
   4847   baset* obj0;
   4848   prependNFreeG(self2, obj0);
   4849   bool obj1;
   4850   prependNFreeG(self2, obj1);
   4851   double obj2;
   4852   prependNFreeG(self2, obj2);
   4853   int64_t obj3;
   4854   prependNFreeG(self2, obj3);
   4855   int32_t obj4;
   4856   prependNFreeG(self2, obj4);
   4857   uint32_t obj5;
   4858   prependNFreeG(self2, obj5);
   4859   uint64_t obj6;
   4860   prependNFreeG(self2, obj6);
   4861   char* obj7;
   4862   prependNFreeG(self2, obj7);
   4863   char obj8;
   4864   prependNFreeG(self2, obj8);
   4865   smallDictt* obj9;
   4866   prependNFreeG(self2, obj9);
   4867   smallArrayt* obj10;
   4868   prependNFreeG(self2, obj10);
   4869   char ** obj11;
   4870   prependNFreeG(self2, obj11);
   4871   smallBoolt* obj12;
   4872   prependNFreeG(self2, obj12);
   4873   smallBytest* obj13;
   4874   prependNFreeG(self2, obj13);
   4875   smallDoublet* obj14;
   4876   prependNFreeG(self2, obj14);
   4877   smallIntt* obj15;
   4878   prependNFreeG(self2, obj15);
   4879   smallJsont* obj16;
   4880   prependNFreeG(self2, obj16);
   4881   smallStringt* obj17;
   4882   prependNFreeG(self2, obj17);
   4883   smallContainert* obj18;
   4884   prependNFreeG(self2, obj18);
   4885   undefinedt* obj19;
   4886   prependNFreeG(self2, obj19);
   4887   void * obj20;
   4888   prependNFreeG(self2, obj20);
   4889 }
   4890 {
   4891   smallStringt* self3;
   4892   smallStringt* obj0;
   4893   prependNFreeG(self3, obj0);
   4894   smallJsont* obj1;
   4895   prependNFreeG(self3, obj1);
   4896   char * obj2;
   4897   prependNFreeG(self3, obj2);
   4898   char obj3;
   4899   prependNFreeG(self3, obj3);
   4900   int obj4;
   4901   prependNFreeG(self3, obj4);
   4902   const char * obj5;
   4903   prependNFreeG(self3, obj5);
   4904 }
   4905 {
   4906   char ** self4;
   4907   char * obj0;
   4908   prependNFreeG(self4, obj0);
   4909   char obj1;
   4910   prependNFreeG(self4, obj1);
   4911   int obj2;
   4912   prependNFreeG(self4, obj2);
   4913   char * obj3;
   4914   prependNFreeG(self4, obj3);
   4915 }
   4916 {
   4917   char *** self5;
   4918   char * obj0;
   4919   prependNFreeG(self5, obj0);
   4920   char obj1;
   4921   prependNFreeG(self5, obj1);
   4922   int obj2;
   4923   prependNFreeG(self5, obj2);
   4924   char * obj3;
   4925   prependNFreeG(self5, obj3);
   4926 }
   4927 {
   4928   smallDictt* self1;
   4929   smallDictt* obj0;
   4930   shiftG(self1, obj0);
   4931   smallJsont* obj1;
   4932   shiftG(self1, obj1);
   4933   smallDictt * obj2;
   4934   shiftG(self1, obj2);
   4935 }
   4936 {
   4937   smallArrayt* self2;
   4938   smallArrayt * obj0;
   4939   shiftG(self2, obj0);
   4940   smallJsont * obj1;
   4941   shiftG(self2, obj1);
   4942   smallArrayt * obj2;
   4943   shiftG(self2, obj2);
   4944 }
   4945 {
   4946   smallJsont* self3;
   4947   smallArrayt * obj0;
   4948   shiftG(self3, obj0);
   4949   smallDictt * obj1;
   4950   shiftG(self3, obj1);
   4951   smallJsont * obj2;
   4952   shiftG(self3, obj2);
   4953   smallJsont * obj3;
   4954   shiftG(self3, obj3);
   4955 }
   4956 {
   4957   smallStringt* self4;
   4958   smallStringt* obj0;
   4959   shiftG(self4, obj0);
   4960   smallJsont* obj1;
   4961   shiftG(self4, obj1);
   4962   char * obj2;
   4963   shiftG(self4, obj2);
   4964   char obj3;
   4965   shiftG(self4, obj3);
   4966   int obj4;
   4967   shiftG(self4, obj4);
   4968   const char * obj5;
   4969   shiftG(self4, obj5);
   4970 }
   4971 {
   4972   char self5;
   4973   const char * obj0;
   4974   shiftG(self5, obj0);
   4975 }
   4976 {
   4977   int self6;
   4978   const char * obj0;
   4979   shiftG(self6, obj0);
   4980 }
   4981 {
   4982   char * self7;
   4983   char * obj0;
   4984   shiftG(self7, obj0);
   4985   const char * obj1;
   4986   shiftG(self7, obj1);
   4987   char obj2;
   4988   shiftG(self7, obj2);
   4989   int obj3;
   4990   shiftG(self7, obj3);
   4991   const char * obj4;
   4992   shiftG(self7, obj4);
   4993 }
   4994 {
   4995   const char * self8;
   4996   char * obj0;
   4997   shiftG(self8, obj0);
   4998   const char * obj1;
   4999   shiftG(self8, obj1);
   5000   char obj2;
   5001   shiftG(self8, obj2);
   5002   int obj3;
   5003   shiftG(self8, obj3);
   5004   const char * obj4;
   5005   shiftG(self8, obj4);
   5006 }
   5007 {
   5008   char ** self9;
   5009   char * obj0;
   5010   shiftG(self9, obj0);
   5011   const char * obj1;
   5012   shiftG(self9, obj1);
   5013   char obj2;
   5014   shiftG(self9, obj2);
   5015   int obj3;
   5016   shiftG(self9, obj3);
   5017   const char * obj4;
   5018   shiftG(self9, obj4);
   5019 }
   5020 {
   5021   char *** self10;
   5022   char ** obj0;
   5023   shiftG(self10, obj0);
   5024 }
   5025 {
   5026   smallDictt* self1;
   5027   smallDictt* obj0;
   5028   shiftNSmashG(self1, obj0);
   5029   smallJsont* obj1;
   5030   shiftNSmashG(self1, obj1);
   5031   smallDictt * obj2;
   5032   shiftNSmashG(self1, obj2);
   5033 }
   5034 {
   5035   smallArrayt* self2;
   5036   smallArrayt * obj0;
   5037   shiftNSmashG(self2, obj0);
   5038   smallJsont * obj1;
   5039   shiftNSmashG(self2, obj1);
   5040   smallArrayt * obj2;
   5041   shiftNSmashG(self2, obj2);
   5042 }
   5043 {
   5044   smallJsont* self3;
   5045   smallArrayt * obj0;
   5046   shiftNSmashG(self3, obj0);
   5047   smallDictt * obj1;
   5048   shiftNSmashG(self3, obj1);
   5049   smallJsont * obj2;
   5050   shiftNSmashG(self3, obj2);
   5051   smallJsont * obj3;
   5052   shiftNSmashG(self3, obj3);
   5053 }
   5054 {
   5055   smallStringt* self4;
   5056   smallStringt* obj0;
   5057   shiftNSmashG(self4, obj0);
   5058   smallJsont* obj1;
   5059   shiftNSmashG(self4, obj1);
   5060   char * obj2;
   5061   shiftNSmashG(self4, obj2);
   5062   char obj3;
   5063   shiftNSmashG(self4, obj3);
   5064   int obj4;
   5065   shiftNSmashG(self4, obj4);
   5066   const char * obj5;
   5067   shiftNSmashG(self4, obj5);
   5068 }
   5069 {
   5070   char ** self5;
   5071   char * obj0;
   5072   shiftNSmashG(self5, obj0);
   5073   char obj1;
   5074   shiftNSmashG(self5, obj1);
   5075   int obj2;
   5076   shiftNSmashG(self5, obj2);
   5077   char * obj3;
   5078   shiftNSmashG(self5, obj3);
   5079 }
   5080 {
   5081   char *** self6;
   5082   char ** obj0;
   5083   shiftNSmashG(self6, obj0);
   5084 }
   5085 {
   5086   smallDictt* self1;
   5087   char * start0;
   5088   int end1;
   5089   delG(self1, start0, end1);
   5090   const char * start1;
   5091   delG(self1, start1, end1);
   5092   char start2;
   5093   delG(self1, start2, end1);
   5094   int start3;
   5095   delG(self1, start3, end1);
   5096   const char * start5;
   5097   int end0;
   5098   delG(self1, start5, end0);
   5099 }
   5100 {
   5101   smallJsont* self2;
   5102   char * start0;
   5103   int end1;
   5104   delG(self2, start0, end1);
   5105   const char * start1;
   5106   delG(self2, start1, end1);
   5107   int64_t start2;
   5108   delG(self2, start2, end1);
   5109   int32_t start3;
   5110   delG(self2, start3, end1);
   5111   int16_t start4;
   5112   delG(self2, start4, end1);
   5113   int8_t start5;
   5114   delG(self2, start5, end1);
   5115   uint64_t start6;
   5116   delG(self2, start6, end1);
   5117   uint32_t start7;
   5118   delG(self2, start7, end1);
   5119   uint16_t start8;
   5120   delG(self2, start8, end1);
   5121   uint8_t start9;
   5122   delG(self2, start9, end1);
   5123   int64_t start16;
   5124   int end0;
   5125   delG(self2, start16, end0);
   5126 }
   5127 {
   5128   smallArrayt* self3;
   5129   int64_t start17;
   5130   int64_t end0;
   5131   delG(self3, start17, end0);
   5132 }
   5133 {
   5134   smallStringt* self4;
   5135   int64_t start18;
   5136   int64_t end0;
   5137   delG(self4, start18, end0);
   5138 }
   5139 {
   5140   char ** self5;
   5141   int64_t start19;
   5142   int64_t end0;
   5143   delG(self5, start19, end0);
   5144 }
   5145 {
   5146   char *** self6;
   5147   int64_t start20;
   5148   int64_t end0;
   5149   delG(self6, start20, end0);
   5150 }
   5151 {
   5152   smallDictt* self1;
   5153   char * index0;
   5154   delElemG(self1, index0);
   5155   const char * index1;
   5156   delElemG(self1, index1);
   5157   char index2;
   5158   delElemG(self1, index2);
   5159   int index3;
   5160   delElemG(self1, index3);
   5161   const char * index4;
   5162   delElemG(self1, index4);
   5163 }
   5164 {
   5165   smallJsont* self2;
   5166   char * index0;
   5167   delElemG(self2, index0);
   5168   const char * index1;
   5169   delElemG(self2, index1);
   5170   int64_t index2;
   5171   delElemG(self2, index2);
   5172   int32_t index3;
   5173   delElemG(self2, index3);
   5174   int16_t index4;
   5175   delElemG(self2, index4);
   5176   int8_t index5;
   5177   delElemG(self2, index5);
   5178   uint64_t index6;
   5179   delElemG(self2, index6);
   5180   uint32_t index7;
   5181   delElemG(self2, index7);
   5182   uint16_t index8;
   5183   delElemG(self2, index8);
   5184   uint8_t index9;
   5185   delElemG(self2, index9);
   5186   const char * index10;
   5187   delElemG(self2, index10);
   5188 }
   5189 {
   5190   smallArrayt* self3;
   5191   int64_t index0;
   5192   delElemG(self3, index0);
   5193 }
   5194 {
   5195   smallStringt* self4;
   5196   int64_t index0;
   5197   delElemG(self4, index0);
   5198 }
   5199 {
   5200   char ** self5;
   5201   int64_t index0;
   5202   delElemG(self5, index0);
   5203 }
   5204 {
   5205   char *** self6;
   5206   int64_t index0;
   5207   delElemG(self6, index0);
   5208 }
   5209 {
   5210   smallArrayt* self1;
   5211   baset* returnType0;
   5212   popG(self1, returnType0);
   5213   undefinedt* returnType1;
   5214   popG(self1, returnType1);
   5215   bool returnType2;
   5216   popG(self1, returnType2);
   5217   double returnType3;
   5218   popG(self1, returnType3);
   5219   int64_t returnType4;
   5220   popG(self1, returnType4);
   5221   int32_t returnType5;
   5222   popG(self1, returnType5);
   5223   uint64_t returnType6;
   5224   popG(self1, returnType6);
   5225   uint32_t returnType7;
   5226   popG(self1, returnType7);
   5227   char* returnType8;
   5228   popG(self1, returnType8);
   5229   smallDictt* returnType9;
   5230   popG(self1, returnType9);
   5231   smallArrayt* returnType10;
   5232   popG(self1, returnType10);
   5233   smallBoolt* returnType11;
   5234   popG(self1, returnType11);
   5235   smallBytest* returnType12;
   5236   popG(self1, returnType12);
   5237   smallDoublet* returnType13;
   5238   popG(self1, returnType13);
   5239   smallIntt* returnType14;
   5240   popG(self1, returnType14);
   5241   smallJsont* returnType15;
   5242   popG(self1, returnType15);
   5243   smallStringt* returnType16;
   5244   popG(self1, returnType16);
   5245   void* returnType17;
   5246   popG(self1, returnType17);
   5247   smallContainert* returnType18;
   5248   popG(self1, returnType18);
   5249   baset* returnType19;
   5250   popG(self1, returnType19);
   5251 }
   5252 {
   5253   smallJsont* self2;
   5254   baset* returnType0;
   5255   popG(self2, returnType0);
   5256   undefinedt* returnType1;
   5257   popG(self2, returnType1);
   5258   bool returnType2;
   5259   popG(self2, returnType2);
   5260   double returnType3;
   5261   popG(self2, returnType3);
   5262   int64_t returnType4;
   5263   popG(self2, returnType4);
   5264   int32_t returnType5;
   5265   popG(self2, returnType5);
   5266   uint64_t returnType6;
   5267   popG(self2, returnType6);
   5268   uint32_t returnType7;
   5269   popG(self2, returnType7);
   5270   char* returnType8;
   5271   popG(self2, returnType8);
   5272   smallDictt* returnType9;
   5273   popG(self2, returnType9);
   5274   smallArrayt* returnType10;
   5275   popG(self2, returnType10);
   5276   smallBoolt* returnType11;
   5277   popG(self2, returnType11);
   5278   smallBytest* returnType12;
   5279   popG(self2, returnType12);
   5280   smallDoublet* returnType13;
   5281   popG(self2, returnType13);
   5282   smallIntt* returnType14;
   5283   popG(self2, returnType14);
   5284   smallJsont* returnType15;
   5285   popG(self2, returnType15);
   5286   smallStringt* returnType16;
   5287   popG(self2, returnType16);
   5288   void* returnType17;
   5289   popG(self2, returnType17);
   5290   smallContainert* returnType18;
   5291   popG(self2, returnType18);
   5292   baset* returnType19;
   5293   popG(self2, returnType19);
   5294 }
   5295 {
   5296   char *** self3;
   5297   int returnType0;
   5298   popG(self3, returnType0);
   5299 }
   5300 {
   5301   smallArrayt* self1;
   5302   baset* returnType0;
   5303   dequeueG(self1, returnType0);
   5304   undefinedt* returnType1;
   5305   dequeueG(self1, returnType1);
   5306   bool returnType2;
   5307   dequeueG(self1, returnType2);
   5308   double returnType3;
   5309   dequeueG(self1, returnType3);
   5310   int64_t returnType4;
   5311   dequeueG(self1, returnType4);
   5312   int32_t returnType5;
   5313   dequeueG(self1, returnType5);
   5314   uint64_t returnType6;
   5315   dequeueG(self1, returnType6);
   5316   uint32_t returnType7;
   5317   dequeueG(self1, returnType7);
   5318   char* returnType8;
   5319   dequeueG(self1, returnType8);
   5320   smallDictt* returnType9;
   5321   dequeueG(self1, returnType9);
   5322   smallArrayt* returnType10;
   5323   dequeueG(self1, returnType10);
   5324   smallBoolt* returnType11;
   5325   dequeueG(self1, returnType11);
   5326   smallBytest* returnType12;
   5327   dequeueG(self1, returnType12);
   5328   smallDoublet* returnType13;
   5329   dequeueG(self1, returnType13);
   5330   smallIntt* returnType14;
   5331   dequeueG(self1, returnType14);
   5332   smallJsont* returnType15;
   5333   dequeueG(self1, returnType15);
   5334   smallStringt* returnType16;
   5335   dequeueG(self1, returnType16);
   5336   void* returnType17;
   5337   dequeueG(self1, returnType17);
   5338   smallContainert* returnType18;
   5339   dequeueG(self1, returnType18);
   5340   baset* returnType19;
   5341   dequeueG(self1, returnType19);
   5342 }
   5343 {
   5344   smallJsont* self2;
   5345   baset* returnType0;
   5346   dequeueG(self2, returnType0);
   5347   undefinedt* returnType1;
   5348   dequeueG(self2, returnType1);
   5349   bool returnType2;
   5350   dequeueG(self2, returnType2);
   5351   double returnType3;
   5352   dequeueG(self2, returnType3);
   5353   int64_t returnType4;
   5354   dequeueG(self2, returnType4);
   5355   int32_t returnType5;
   5356   dequeueG(self2, returnType5);
   5357   uint64_t returnType6;
   5358   dequeueG(self2, returnType6);
   5359   uint32_t returnType7;
   5360   dequeueG(self2, returnType7);
   5361   char* returnType8;
   5362   dequeueG(self2, returnType8);
   5363   smallDictt* returnType9;
   5364   dequeueG(self2, returnType9);
   5365   smallArrayt* returnType10;
   5366   dequeueG(self2, returnType10);
   5367   smallBoolt* returnType11;
   5368   dequeueG(self2, returnType11);
   5369   smallBytest* returnType12;
   5370   dequeueG(self2, returnType12);
   5371   smallDoublet* returnType13;
   5372   dequeueG(self2, returnType13);
   5373   smallIntt* returnType14;
   5374   dequeueG(self2, returnType14);
   5375   smallJsont* returnType15;
   5376   dequeueG(self2, returnType15);
   5377   smallStringt* returnType16;
   5378   dequeueG(self2, returnType16);
   5379   void* returnType17;
   5380   dequeueG(self2, returnType17);
   5381   smallContainert* returnType18;
   5382   dequeueG(self2, returnType18);
   5383   baset* returnType19;
   5384   dequeueG(self2, returnType19);
   5385 }
   5386 {
   5387   char *** self3;
   5388   int returnType0;
   5389   dequeueG(self3, returnType0);
   5390 }
   5391 {
   5392   char * returnType0;
   5393   getProgPathG(returnType0);
   5394   const char * returnType1;
   5395   getProgPathG(returnType1);
   5396   smallJsont * returnType2;
   5397   getProgPathG(returnType2);
   5398   smallStringt * returnType3;
   5399   getProgPathG(returnType3);
   5400 }
   5401 {
   5402   char * returnType0;
   5403   getRealProgPathG(returnType0);
   5404   const char * returnType1;
   5405   getRealProgPathG(returnType1);
   5406   smallJsont * returnType2;
   5407   getRealProgPathG(returnType2);
   5408   smallStringt * returnType3;
   5409   getRealProgPathG(returnType3);
   5410 }
   5411 {
   5412   char * cmd0;
   5413   systemG(cmd0);
   5414   const char * cmd1;
   5415   systemG(cmd1);
   5416   smallJsont * cmd2;
   5417   systemG(cmd2);
   5418   smallStringt * cmd3;
   5419   systemG(cmd3);
   5420 }
   5421 {
   5422   char * cmd0;
   5423   systemNFreeG(cmd0);
   5424   smallJsont * cmd1;
   5425   systemNFreeG(cmd1);
   5426   smallStringt * cmd2;
   5427   systemNFreeG(cmd2);
   5428 }
   5429 {
   5430   char * path0;
   5431   getModificationTimeG(path0);
   5432   const char * path1;
   5433   getModificationTimeG(path1);
   5434   smallJsont * path2;
   5435   getModificationTimeG(path2);
   5436   smallStringt * path3;
   5437   getModificationTimeG(path3);
   5438 }
   5439 {
   5440   char * path1;
   5441   time_t mtime0;
   5442   setModificationTimeG(path1, mtime0);
   5443 }
   5444 {
   5445   const char * path2;
   5446   time_t mtime0;
   5447   setModificationTimeG(path2, mtime0);
   5448 }
   5449 {
   5450   smallJsont * path3;
   5451   time_t mtime0;
   5452   setModificationTimeG(path3, mtime0);
   5453 }
   5454 {
   5455   smallStringt * path4;
   5456   time_t mtime0;
   5457   setModificationTimeG(path4, mtime0);
   5458 }
   5459 {
   5460   char * path11;
   5461   char * path20;
   5462   equalModificationTimesG(path11, path20);
   5463   const char * path21;
   5464   equalModificationTimesG(path11, path21);
   5465   smallJsont * path22;
   5466   equalModificationTimesG(path11, path22);
   5467   smallStringt * path23;
   5468   equalModificationTimesG(path11, path23);
   5469 }
   5470 {
   5471   const char * path12;
   5472   char * path20;
   5473   equalModificationTimesG(path12, path20);
   5474   const char * path21;
   5475   equalModificationTimesG(path12, path21);
   5476   smallJsont * path22;
   5477   equalModificationTimesG(path12, path22);
   5478   smallStringt * path23;
   5479   equalModificationTimesG(path12, path23);
   5480 }
   5481 {
   5482   smallJsont * path13;
   5483   char * path20;
   5484   equalModificationTimesG(path13, path20);
   5485   const char * path21;
   5486   equalModificationTimesG(path13, path21);
   5487   smallJsont * path22;
   5488   equalModificationTimesG(path13, path22);
   5489   smallStringt * path23;
   5490   equalModificationTimesG(path13, path23);
   5491 }
   5492 {
   5493   smallStringt * path14;
   5494   char * path20;
   5495   equalModificationTimesG(path14, path20);
   5496   const char * path21;
   5497   equalModificationTimesG(path14, path21);
   5498   smallJsont * path22;
   5499   equalModificationTimesG(path14, path22);
   5500   smallStringt * path23;
   5501   equalModificationTimesG(path14, path23);
   5502 }
   5503 {
   5504   char * returnType1;
   5505   const time_t t0;
   5506   timeToSG(returnType1, t0);
   5507 }
   5508 {
   5509   smallJsont * returnType2;
   5510   const time_t t0;
   5511   timeToSG(returnType2, t0);
   5512 }
   5513 {
   5514   smallStringt * returnType3;
   5515   const time_t t0;
   5516   timeToSG(returnType3, t0);
   5517 }
   5518 {
   5519   char * path0;
   5520   shDirnameG(path0);
   5521   const char * path1;
   5522   shDirnameG(path1);
   5523   smallJsont * path2;
   5524   shDirnameG(path2);
   5525   smallStringt * path3;
   5526   shDirnameG(path3);
   5527 }
   5528 {
   5529   char * path0;
   5530   expandHomeG(path0);
   5531   const char * path1;
   5532   expandHomeG(path1);
   5533   char ** path2;
   5534   expandHomeG(path2);
   5535   smallJsont * path3;
   5536   expandHomeG(path3);
   5537   smallStringt * path4;
   5538   expandHomeG(path4);
   5539 }
   5540 {
   5541   char * path0;
   5542   normalizePathG(path0);
   5543   const char * path1;
   5544   normalizePathG(path1);
   5545   char ** path2;
   5546   normalizePathG(path2);
   5547   smallJsont * path3;
   5548   normalizePathG(path3);
   5549   smallStringt * path4;
   5550   normalizePathG(path4);
   5551 }
   5552 {
   5553   char * returnType0;
   5554   getCwdG(returnType0);
   5555   const char * returnType1;
   5556   getCwdG(returnType1);
   5557   smallJsont * returnType2;
   5558   getCwdG(returnType2);
   5559   smallStringt * returnType3;
   5560   getCwdG(returnType3);
   5561 }
   5562 {
   5563   char * path0;
   5564   chDirG(path0);
   5565   const char * path1;
   5566   chDirG(path1);
   5567   smallJsont * path2;
   5568   chDirG(path2);
   5569   smallStringt * path3;
   5570   chDirG(path3);
   5571 }
   5572 {
   5573   char * path0;
   5574   isDirG(path0);
   5575   const char * path1;
   5576   isDirG(path1);
   5577   smallJsont * path2;
   5578   isDirG(path2);
   5579   smallStringt * path3;
   5580   isDirG(path3);
   5581 }
   5582 {
   5583   char * path0;
   5584   isLinkG(path0);
   5585   const char * path1;
   5586   isLinkG(path1);
   5587   smallJsont * path2;
   5588   isLinkG(path2);
   5589   smallStringt * path3;
   5590   isLinkG(path3);
   5591 }
   5592 {
   5593   char * path0;
   5594   fileExistsG(path0);
   5595   const char * path1;
   5596   fileExistsG(path1);
   5597   smallJsont * path2;
   5598   fileExistsG(path2);
   5599   smallStringt * path3;
   5600   fileExistsG(path3);
   5601 }
   5602 {
   5603   char * path1;
   5604   mode_t mode0;
   5605   fileChmodG(path1, mode0);
   5606 }
   5607 {
   5608   const char * path2;
   5609   mode_t mode0;
   5610   fileChmodG(path2, mode0);
   5611 }
   5612 {
   5613   smallJsont * path3;
   5614   mode_t mode0;
   5615   fileChmodG(path3, mode0);
   5616 }
   5617 {
   5618   smallStringt * path4;
   5619   mode_t mode0;
   5620   fileChmodG(path4, mode0);
   5621 }
   5622 {
   5623   char * path0;
   5624   fileSizeG(path0);
   5625   const char * path1;
   5626   fileSizeG(path1);
   5627   smallJsont * path2;
   5628   fileSizeG(path2);
   5629   smallStringt * path3;
   5630   fileSizeG(path3);
   5631   FILE * path4;
   5632   fileSizeG(path4);
   5633 }
   5634 {
   5635   smallArrayt * self1;
   5636   char * path0;
   5637   readFileG(self1, path0);
   5638   const char* path1;
   5639   readFileG(self1, path1);
   5640   FILE * path2;
   5641   readFileG(self1, path2);
   5642   smallJsont * path3;
   5643   readFileG(self1, path3);
   5644   smallStringt * path4;
   5645   readFileG(self1, path4);
   5646 }
   5647 {
   5648   smallBoolt * self2;
   5649   char * path0;
   5650   readFileG(self2, path0);
   5651   const char* path1;
   5652   readFileG(self2, path1);
   5653   FILE * path2;
   5654   readFileG(self2, path2);
   5655   smallJsont * path3;
   5656   readFileG(self2, path3);
   5657   smallStringt * path4;
   5658   readFileG(self2, path4);
   5659 }
   5660 {
   5661   smallDoublet * self3;
   5662   char * path0;
   5663   readFileG(self3, path0);
   5664   const char* path1;
   5665   readFileG(self3, path1);
   5666   FILE * path2;
   5667   readFileG(self3, path2);
   5668   smallJsont * path3;
   5669   readFileG(self3, path3);
   5670   smallStringt * path4;
   5671   readFileG(self3, path4);
   5672 }
   5673 {
   5674   smallIntt * self4;
   5675   char * path0;
   5676   readFileG(self4, path0);
   5677   const char* path1;
   5678   readFileG(self4, path1);
   5679   FILE * path2;
   5680   readFileG(self4, path2);
   5681   smallJsont * path3;
   5682   readFileG(self4, path3);
   5683   smallStringt * path4;
   5684   readFileG(self4, path4);
   5685 }
   5686 {
   5687   smallStringt * self5;
   5688   char * path0;
   5689   readFileG(self5, path0);
   5690   const char* path1;
   5691   readFileG(self5, path1);
   5692   FILE * path2;
   5693   readFileG(self5, path2);
   5694   smallJsont * path3;
   5695   readFileG(self5, path3);
   5696   smallStringt * path4;
   5697   readFileG(self5, path4);
   5698 }
   5699 {
   5700   smallBytest * self6;
   5701   char * path0;
   5702   readFileG(self6, path0);
   5703   const char* path1;
   5704   readFileG(self6, path1);
   5705   FILE * path2;
   5706   readFileG(self6, path2);
   5707   smallJsont * path3;
   5708   readFileG(self6, path3);
   5709   smallStringt * path4;
   5710   readFileG(self6, path4);
   5711 }
   5712 {
   5713   smallJsont * self7;
   5714   char * path0;
   5715   readFileG(self7, path0);
   5716   const char* path1;
   5717   readFileG(self7, path1);
   5718   FILE * path2;
   5719   readFileG(self7, path2);
   5720   smallJsont * path3;
   5721   readFileG(self7, path3);
   5722   smallStringt * path4;
   5723   readFileG(self7, path4);
   5724 }
   5725 {
   5726   char ** self8;
   5727   char * path0;
   5728   readFileG(self8, path0);
   5729   const char * path1;
   5730   readFileG(self8, path1);
   5731   FILE * path2;
   5732   readFileG(self8, path2);
   5733   smallJsont * path3;
   5734   readFileG(self8, path3);
   5735   smallStringt * path4;
   5736   readFileG(self8, path4);
   5737 }
   5738 {
   5739   char *** self9;
   5740   char * path0;
   5741   readFileG(self9, path0);
   5742   const char * path1;
   5743   readFileG(self9, path1);
   5744   FILE * path2;
   5745   readFileG(self9, path2);
   5746   smallJsont * path3;
   5747   readFileG(self9, path3);
   5748   smallStringt * path4;
   5749   readFileG(self9, path4);
   5750 }
   5751 {
   5752   char * self10;
   5753   char * path0;
   5754   readFileG(self10, path0);
   5755   const char * path1;
   5756   readFileG(self10, path1);
   5757   FILE * path2;
   5758   readFileG(self10, path2);
   5759   smallJsont * path3;
   5760   readFileG(self10, path3);
   5761   smallStringt * path4;
   5762   readFileG(self10, path4);
   5763 }
   5764 {
   5765   void * self11;
   5766   char * path0;
   5767   readFileG(self11, path0);
   5768   const char * path1;
   5769   readFileG(self11, path1);
   5770   FILE * path2;
   5771   readFileG(self11, path2);
   5772   smallJsont * path3;
   5773   readFileG(self11, path3);
   5774   smallStringt * path4;
   5775   readFileG(self11, path4);
   5776 }
   5777 {
   5778   smallArrayt * self1;
   5779   char * path0;
   5780   readTextG(self1, path0);
   5781   const char* path1;
   5782   readTextG(self1, path1);
   5783   FILE * path2;
   5784   readTextG(self1, path2);
   5785   smallJsont * path3;
   5786   readTextG(self1, path3);
   5787   smallStringt * path4;
   5788   readTextG(self1, path4);
   5789 }
   5790 {
   5791   smallStringt * self2;
   5792   char * path0;
   5793   readTextG(self2, path0);
   5794   const char* path1;
   5795   readTextG(self2, path1);
   5796   FILE * path2;
   5797   readTextG(self2, path2);
   5798   smallJsont * path3;
   5799   readTextG(self2, path3);
   5800   smallStringt * path4;
   5801   readTextG(self2, path4);
   5802 }
   5803 {
   5804   smallJsont * self3;
   5805   char * path0;
   5806   readTextG(self3, path0);
   5807   const char* path1;
   5808   readTextG(self3, path1);
   5809   FILE * path2;
   5810   readTextG(self3, path2);
   5811   smallJsont * path3;
   5812   readTextG(self3, path3);
   5813   smallStringt * path4;
   5814   readTextG(self3, path4);
   5815 }
   5816 {
   5817   char ** self4;
   5818   char * path0;
   5819   readTextG(self4, path0);
   5820   const char * path1;
   5821   readTextG(self4, path1);
   5822   FILE * path2;
   5823   readTextG(self4, path2);
   5824   smallJsont * path3;
   5825   readTextG(self4, path3);
   5826   smallStringt * path4;
   5827   readTextG(self4, path4);
   5828 }
   5829 {
   5830   char *** self5;
   5831   char * path0;
   5832   readTextG(self5, path0);
   5833   const char * path1;
   5834   readTextG(self5, path1);
   5835   FILE * path2;
   5836   readTextG(self5, path2);
   5837   smallJsont * path3;
   5838   readTextG(self5, path3);
   5839   smallStringt * path4;
   5840   readTextG(self5, path4);
   5841 }
   5842 {
   5843   char * self6;
   5844   char * path0;
   5845   readTextG(self6, path0);
   5846   const char * path1;
   5847   readTextG(self6, path1);
   5848   FILE * path2;
   5849   readTextG(self6, path2);
   5850   smallJsont * path3;
   5851   readTextG(self6, path3);
   5852   smallStringt * path4;
   5853   readTextG(self6, path4);
   5854 }
   5855 {
   5856   void * self7;
   5857   char * path0;
   5858   readTextG(self7, path0);
   5859   const char * path1;
   5860   readTextG(self7, path1);
   5861   FILE * path2;
   5862   readTextG(self7, path2);
   5863   smallJsont * path3;
   5864   readTextG(self7, path3);
   5865   smallStringt * path4;
   5866   readTextG(self7, path4);
   5867 }
   5868 {
   5869   smallArrayt * self1;
   5870   char * path0;
   5871   writeFileG(self1, path0);
   5872   const char * path1;
   5873   writeFileG(self1, path1);
   5874   FILE * path2;
   5875   writeFileG(self1, path2);
   5876   smallJsont * path3;
   5877   writeFileG(self1, path3);
   5878   smallStringt * path4;
   5879   writeFileG(self1, path4);
   5880 }
   5881 {
   5882   smallBoolt * self2;
   5883   char * path0;
   5884   writeFileG(self2, path0);
   5885   const char * path1;
   5886   writeFileG(self2, path1);
   5887   FILE * path2;
   5888   writeFileG(self2, path2);
   5889   smallJsont * path3;
   5890   writeFileG(self2, path3);
   5891   smallStringt * path4;
   5892   writeFileG(self2, path4);
   5893 }
   5894 {
   5895   smallDoublet * self3;
   5896   char * path0;
   5897   writeFileG(self3, path0);
   5898   const char * path1;
   5899   writeFileG(self3, path1);
   5900   FILE * path2;
   5901   writeFileG(self3, path2);
   5902   smallJsont * path3;
   5903   writeFileG(self3, path3);
   5904   smallStringt * path4;
   5905   writeFileG(self3, path4);
   5906 }
   5907 {
   5908   smallIntt * self4;
   5909   char * path0;
   5910   writeFileG(self4, path0);
   5911   const char * path1;
   5912   writeFileG(self4, path1);
   5913   FILE * path2;
   5914   writeFileG(self4, path2);
   5915   smallJsont * path3;
   5916   writeFileG(self4, path3);
   5917   smallStringt * path4;
   5918   writeFileG(self4, path4);
   5919 }
   5920 {
   5921   smallStringt * self5;
   5922   char * path0;
   5923   writeFileG(self5, path0);
   5924   const char * path1;
   5925   writeFileG(self5, path1);
   5926   FILE * path2;
   5927   writeFileG(self5, path2);
   5928   smallJsont * path3;
   5929   writeFileG(self5, path3);
   5930   smallStringt * path4;
   5931   writeFileG(self5, path4);
   5932 }
   5933 {
   5934   smallBytest * self6;
   5935   char * path0;
   5936   writeFileG(self6, path0);
   5937   const char * path1;
   5938   writeFileG(self6, path1);
   5939   FILE * path2;
   5940   writeFileG(self6, path2);
   5941   smallJsont * path3;
   5942   writeFileG(self6, path3);
   5943   smallStringt * path4;
   5944   writeFileG(self6, path4);
   5945 }
   5946 {
   5947   smallDictt * self7;
   5948   char * path0;
   5949   writeFileG(self7, path0);
   5950   const char * path1;
   5951   writeFileG(self7, path1);
   5952   FILE * path2;
   5953   writeFileG(self7, path2);
   5954   smallJsont * path3;
   5955   writeFileG(self7, path3);
   5956   smallStringt * path4;
   5957   writeFileG(self7, path4);
   5958 }
   5959 {
   5960   smallJsont * self8;
   5961   char * path0;
   5962   writeFileG(self8, path0);
   5963   const char * path1;
   5964   writeFileG(self8, path1);
   5965   FILE * path2;
   5966   writeFileG(self8, path2);
   5967   smallJsont * path3;
   5968   writeFileG(self8, path3);
   5969   smallStringt * path4;
   5970   writeFileG(self8, path4);
   5971 }
   5972 {
   5973   char ** self9;
   5974   char * path0;
   5975   writeFileG(self9, path0);
   5976   const char * path1;
   5977   writeFileG(self9, path1);
   5978   FILE * path2;
   5979   writeFileG(self9, path2);
   5980   smallJsont * path3;
   5981   writeFileG(self9, path3);
   5982   smallStringt * path4;
   5983   writeFileG(self9, path4);
   5984 }
   5985 {
   5986   const char ** self10;
   5987   char * path0;
   5988   writeFileG(self10, path0);
   5989   const char * path1;
   5990   writeFileG(self10, path1);
   5991   FILE * path2;
   5992   writeFileG(self10, path2);
   5993   smallJsont * path3;
   5994   writeFileG(self10, path3);
   5995   smallStringt * path4;
   5996   writeFileG(self10, path4);
   5997 }
   5998 {
   5999   const char * self11;
   6000   char * path0;
   6001   writeFileG(self11, path0);
   6002   const char * path1;
   6003   writeFileG(self11, path1);
   6004   FILE * path2;
   6005   writeFileG(self11, path2);
   6006   const char * path3;
   6007   writeFileG(self11, path3);
   6008 }
   6009 {
   6010   char * self12;
   6011   char * path0;
   6012   writeFileG(self12, path0);
   6013   const char * path1;
   6014   writeFileG(self12, path1);
   6015   FILE * path2;
   6016   writeFileG(self12, path2);
   6017   const char * path3;
   6018   writeFileG(self12, path3);
   6019 }
   6020 {
   6021   smallArrayt * self1;
   6022   char * path0;
   6023   writeTextG(self1, path0);
   6024   const char * path1;
   6025   writeTextG(self1, path1);
   6026   FILE * path2;
   6027   writeTextG(self1, path2);
   6028   smallJsont * path3;
   6029   writeTextG(self1, path3);
   6030   smallStringt * path4;
   6031   writeTextG(self1, path4);
   6032 }
   6033 {
   6034   smallStringt * self2;
   6035   char * path0;
   6036   writeTextG(self2, path0);
   6037   const char * path1;
   6038   writeTextG(self2, path1);
   6039   FILE * path2;
   6040   writeTextG(self2, path2);
   6041   smallJsont * path3;
   6042   writeTextG(self2, path3);
   6043   smallStringt * path4;
   6044   writeTextG(self2, path4);
   6045 }
   6046 {
   6047   smallJsont * self3;
   6048   char * path0;
   6049   writeTextG(self3, path0);
   6050   const char * path1;
   6051   writeTextG(self3, path1);
   6052   FILE * path2;
   6053   writeTextG(self3, path2);
   6054   smallJsont * path3;
   6055   writeTextG(self3, path3);
   6056   smallStringt * path4;
   6057   writeTextG(self3, path4);
   6058 }
   6059 {
   6060   char ** self4;
   6061   char * path0;
   6062   writeTextG(self4, path0);
   6063   const char * path1;
   6064   writeTextG(self4, path1);
   6065   FILE * path2;
   6066   writeTextG(self4, path2);
   6067   smallJsont * path3;
   6068   writeTextG(self4, path3);
   6069   smallStringt * path4;
   6070   writeTextG(self4, path4);
   6071 }
   6072 {
   6073   const char ** self5;
   6074   char * path0;
   6075   writeTextG(self5, path0);
   6076   const char * path1;
   6077   writeTextG(self5, path1);
   6078   FILE * path2;
   6079   writeTextG(self5, path2);
   6080   smallJsont * path3;
   6081   writeTextG(self5, path3);
   6082   smallStringt * path4;
   6083   writeTextG(self5, path4);
   6084 }
   6085 {
   6086   const char * self6;
   6087   char * path0;
   6088   writeTextG(self6, path0);
   6089   const char * path1;
   6090   writeTextG(self6, path1);
   6091   FILE * path2;
   6092   writeTextG(self6, path2);
   6093   const char * path3;
   6094   writeTextG(self6, path3);
   6095 }
   6096 {
   6097   char * self7;
   6098   char * path0;
   6099   writeTextG(self7, path0);
   6100   const char * path1;
   6101   writeTextG(self7, path1);
   6102   FILE * path2;
   6103   writeTextG(self7, path2);
   6104   const char * path3;
   6105   writeTextG(self7, path3);
   6106 }
   6107 {
   6108   smallArrayt * self1;
   6109   char * path0;
   6110   appendFileG(self1, path0);
   6111   const char * path1;
   6112   appendFileG(self1, path1);
   6113   smallStringt * path2;
   6114   appendFileG(self1, path2);
   6115   const char * path3;
   6116   appendFileG(self1, path3);
   6117 }
   6118 {
   6119   smallBytest * self2;
   6120   char * path0;
   6121   appendFileG(self2, path0);
   6122   const char * path1;
   6123   appendFileG(self2, path1);
   6124   smallStringt * path2;
   6125   appendFileG(self2, path2);
   6126   const char * path3;
   6127   appendFileG(self2, path3);
   6128 }
   6129 {
   6130   smallDictt * self3;
   6131   char * path0;
   6132   appendFileG(self3, path0);
   6133   const char * path1;
   6134   appendFileG(self3, path1);
   6135   smallStringt * path2;
   6136   appendFileG(self3, path2);
   6137   const char * path3;
   6138   appendFileG(self3, path3);
   6139 }
   6140 {
   6141   smallJsont * self4;
   6142   char * path0;
   6143   appendFileG(self4, path0);
   6144   const char * path1;
   6145   appendFileG(self4, path1);
   6146   smallStringt * path2;
   6147   appendFileG(self4, path2);
   6148   smallJsont * path3;
   6149   appendFileG(self4, path3);
   6150 }
   6151 {
   6152   char * self5;
   6153   const char * path0;
   6154   appendFileG(self5, path0);
   6155 }
   6156 {
   6157   const char * self6;
   6158   const char * path0;
   6159   appendFileG(self6, path0);
   6160 }
   6161 {
   6162   char ** self7;
   6163   const char * path0;
   6164   appendFileG(self7, path0);
   6165 }
   6166 {
   6167   const char ** self8;
   6168   const char * path0;
   6169   appendFileG(self8, path0);
   6170 }
   6171 {
   6172   smallJsont * self1;
   6173   smallArrayt * keys1;
   6174   smallArrayt * values0;
   6175   zipG(self1, keys1, values0);
   6176   smallJsont * values1;
   6177   zipG(self1, keys1, values1);
   6178   char ** values2;
   6179   zipG(self1, keys1, values2);
   6180   const char ** values3;
   6181   zipG(self1, keys1, values3);
   6182 }
   6183 {
   6184   smallJsont * self1;
   6185   smallJsont * keys2;
   6186   smallArrayt * values0;
   6187   zipG(self1, keys2, values0);
   6188   smallJsont * values1;
   6189   zipG(self1, keys2, values1);
   6190   char ** values2;
   6191   zipG(self1, keys2, values2);
   6192   const char ** values3;
   6193   zipG(self1, keys2, values3);
   6194 }
   6195 {
   6196   smallJsont * self1;
   6197   char ** keys3;
   6198   smallArrayt * values0;
   6199   zipG(self1, keys3, values0);
   6200   smallJsont * values1;
   6201   zipG(self1, keys3, values1);
   6202   char ** values2;
   6203   zipG(self1, keys3, values2);
   6204   const char ** values3;
   6205   zipG(self1, keys3, values3);
   6206 }
   6207 {
   6208   smallJsont * self1;
   6209   const char ** keys4;
   6210   smallArrayt * values0;
   6211   zipG(self1, keys4, values0);
   6212   smallJsont * values1;
   6213   zipG(self1, keys4, values1);
   6214   char ** values2;
   6215   zipG(self1, keys4, values2);
   6216   const char ** values3;
   6217   zipG(self1, keys4, values3);
   6218 }
   6219 {
   6220   smallDictt * self2;
   6221   smallArrayt * keys5;
   6222   smallArrayt * values0;
   6223   zipG(self2, keys5, values0);
   6224   smallJsont * values1;
   6225   zipG(self2, keys5, values1);
   6226   char ** values2;
   6227   zipG(self2, keys5, values2);
   6228   const char ** values3;
   6229   zipG(self2, keys5, values3);
   6230 }
   6231 {
   6232   smallDictt * self2;
   6233   smallJsont * keys6;
   6234   smallArrayt * values0;
   6235   zipG(self2, keys6, values0);
   6236   smallJsont * values1;
   6237   zipG(self2, keys6, values1);
   6238   char ** values2;
   6239   zipG(self2, keys6, values2);
   6240   const char ** values3;
   6241   zipG(self2, keys6, values3);
   6242 }
   6243 {
   6244   smallDictt * self2;
   6245   char ** keys7;
   6246   smallArrayt * values0;
   6247   zipG(self2, keys7, values0);
   6248   smallJsont * values1;
   6249   zipG(self2, keys7, values1);
   6250   char ** values2;
   6251   zipG(self2, keys7, values2);
   6252   const char ** values3;
   6253   zipG(self2, keys7, values3);
   6254 }
   6255 {
   6256   smallDictt * self2;
   6257   const char ** keys8;
   6258   smallArrayt * values0;
   6259   zipG(self2, keys8, values0);
   6260   smallJsont * values1;
   6261   zipG(self2, keys8, values1);
   6262   char ** values2;
   6263   zipG(self2, keys8, values2);
   6264   const char ** values3;
   6265   zipG(self2, keys8, values3);
   6266 }
   6267 {
   6268   smallArrayt * self3;
   6269   smallArrayt * keys9;
   6270   smallArrayt * values0;
   6271   zipG(self3, keys9, values0);
   6272   smallJsont * values1;
   6273   zipG(self3, keys9, values1);
   6274   char ** values2;
   6275   zipG(self3, keys9, values2);
   6276   const char ** values3;
   6277   zipG(self3, keys9, values3);
   6278 }
   6279 {
   6280   smallArrayt * self3;
   6281   smallJsont * keys10;
   6282   smallArrayt * values0;
   6283   zipG(self3, keys10, values0);
   6284   smallJsont * values1;
   6285   zipG(self3, keys10, values1);
   6286   char ** values2;
   6287   zipG(self3, keys10, values2);
   6288   const char ** values3;
   6289   zipG(self3, keys10, values3);
   6290 }
   6291 {
   6292   smallArrayt * self3;
   6293   char ** keys11;
   6294   smallArrayt * values0;
   6295   zipG(self3, keys11, values0);
   6296   smallJsont * values1;
   6297   zipG(self3, keys11, values1);
   6298   char ** values2;
   6299   zipG(self3, keys11, values2);
   6300   const char ** values3;
   6301   zipG(self3, keys11, values3);
   6302 }
   6303 {
   6304   smallArrayt * self3;
   6305   const char ** keys12;
   6306   smallArrayt * values0;
   6307   zipG(self3, keys12, values0);
   6308   smallJsont * values1;
   6309   zipG(self3, keys12, values1);
   6310   char ** values2;
   6311   zipG(self3, keys12, values2);
   6312   const char ** values3;
   6313   zipG(self3, keys12, values3);
   6314 }
   6315 {
   6316   char ** returnType1;
   6317   const char* path0;
   6318   walkDirG(returnType1, path0);
   6319 }
   6320 {
   6321   smallArrayt * returnType2;
   6322   char * path0;
   6323   walkDirG(returnType2, path0);
   6324   const char * path1;
   6325   walkDirG(returnType2, path1);
   6326   smallJsont * path2;
   6327   walkDirG(returnType2, path2);
   6328   smallStringt * path3;
   6329   walkDirG(returnType2, path3);
   6330 }
   6331 {
   6332   char ** returnType1;
   6333   const char* path0;
   6334   walkDirDirG(returnType1, path0);
   6335 }
   6336 {
   6337   smallArrayt * returnType2;
   6338   char * path0;
   6339   walkDirDirG(returnType2, path0);
   6340   const char * path1;
   6341   walkDirDirG(returnType2, path1);
   6342   smallJsont * path2;
   6343   walkDirDirG(returnType2, path2);
   6344   smallStringt * path3;
   6345   walkDirDirG(returnType2, path3);
   6346 }
   6347 {
   6348   char ** returnType1;
   6349   const char * path0;
   6350   readDirG(returnType1, path0);
   6351 }
   6352 {
   6353   smallArrayt * returnType2;
   6354   char * path0;
   6355   readDirG(returnType2, path0);
   6356   const char * path1;
   6357   readDirG(returnType2, path1);
   6358   smallJsont * path2;
   6359   readDirG(returnType2, path2);
   6360   smallStringt * path3;
   6361   readDirG(returnType2, path3);
   6362 }
   6363 {
   6364   char ** returnType1;
   6365   const char * path0;
   6366   readDirDirG(returnType1, path0);
   6367 }
   6368 {
   6369   smallArrayt * returnType2;
   6370   char * path0;
   6371   readDirDirG(returnType2, path0);
   6372   const char * path1;
   6373   readDirDirG(returnType2, path1);
   6374   smallJsont * path2;
   6375   readDirDirG(returnType2, path2);
   6376   smallStringt * path3;
   6377   readDirDirG(returnType2, path3);
   6378 }
   6379 {
   6380   char ** returnType1;
   6381   const char* path0;
   6382   walkDirAllG(returnType1, path0);
   6383 }
   6384 {
   6385   smallArrayt * returnType2;
   6386   char * path0;
   6387   walkDirAllG(returnType2, path0);
   6388   const char * path1;
   6389   walkDirAllG(returnType2, path1);
   6390   smallJsont * path2;
   6391   walkDirAllG(returnType2, path2);
   6392   smallStringt * path3;
   6393   walkDirAllG(returnType2, path3);
   6394 }
   6395 {
   6396   char ** returnType1;
   6397   const char * path0;
   6398   readDirAllG(returnType1, path0);
   6399 }
   6400 {
   6401   smallArrayt * returnType2;
   6402   char * path0;
   6403   readDirAllG(returnType2, path0);
   6404   const char * path1;
   6405   readDirAllG(returnType2, path1);
   6406   smallJsont * path2;
   6407   readDirAllG(returnType2, path2);
   6408   smallStringt * path3;
   6409   readDirAllG(returnType2, path3);
   6410 }
   6411 {
   6412   char * path0;
   6413   mkdirParentsG(path0);
   6414   const char * path1;
   6415   mkdirParentsG(path1);
   6416   smallJsont * path2;
   6417   mkdirParentsG(path2);
   6418   smallStringt * path3;
   6419   mkdirParentsG(path3);
   6420 }
   6421 {
   6422   char * path0;
   6423   rmAllG(path0);
   6424   const char * path1;
   6425   rmAllG(path1);
   6426   smallJsont * path2;
   6427   rmAllG(path2);
   6428   smallStringt * path3;
   6429   rmAllG(path3);
   6430 }
   6431 {
   6432   char * path11;
   6433   char * path20;
   6434   copyG(path11, path20);
   6435   const char * path21;
   6436   copyG(path11, path21);
   6437   smallJsont * path22;
   6438   copyG(path11, path22);
   6439   smallStringt * path23;
   6440   copyG(path11, path23);
   6441 }
   6442 {
   6443   const char * path12;
   6444   char * path20;
   6445   copyG(path12, path20);
   6446   const char * path21;
   6447   copyG(path12, path21);
   6448   smallJsont * path22;
   6449   copyG(path12, path22);
   6450   smallStringt * path23;
   6451   copyG(path12, path23);
   6452 }
   6453 {
   6454   smallJsont * path13;
   6455   char * path20;
   6456   copyG(path13, path20);
   6457   const char* path21;
   6458   copyG(path13, path21);
   6459   smallJsont * path22;
   6460   copyG(path13, path22);
   6461   smallStringt * path23;
   6462   copyG(path13, path23);
   6463 }
   6464 {
   6465   smallStringt * path14;
   6466   char * path20;
   6467   copyG(path14, path20);
   6468   const char* path21;
   6469   copyG(path14, path21);
   6470   smallJsont * path22;
   6471   copyG(path14, path22);
   6472   smallStringt * path23;
   6473   copyG(path14, path23);
   6474 }
   6475 {
   6476   char * returnType1;
   6477   uint64_t length0;
   6478   randomSG(returnType1, length0);
   6479 }
   6480 {
   6481   smallJsont * returnType2;
   6482   uint64_t length0;
   6483   randomSG(returnType2, length0);
   6484 }
   6485 {
   6486   smallStringt * returnType3;
   6487   uint64_t length0;
   6488   randomSG(returnType3, length0);
   6489 }
   6490 {
   6491   char * returnType1;
   6492   uint64_t length0;
   6493   randomAlphaNumSG(returnType1, length0);
   6494 }
   6495 {
   6496   smallJsont * returnType2;
   6497   uint64_t length0;
   6498   randomAlphaNumSG(returnType2, length0);
   6499 }
   6500 {
   6501   smallStringt * returnType3;
   6502   uint64_t length0;
   6503   randomAlphaNumSG(returnType3, length0);
   6504 }
   6505 {
   6506   char * returnType0;
   6507   readG(returnType0);
   6508   smallJsont * returnType1;
   6509   readG(returnType1);
   6510   smallStringt * returnType2;
   6511   readG(returnType2);
   6512 }
   6513 {
   6514   char * returnType1;
   6515   FILE * fp0;
   6516   readLineG(returnType1, fp0);
   6517 }
   6518 {
   6519   smallJsont * returnType2;
   6520   FILE * fp0;
   6521   readLineG(returnType2, fp0);
   6522 }
   6523 {
   6524   smallStringt * returnType3;
   6525   FILE * fp0;
   6526   readLineG(returnType3, fp0);
   6527 }
   6528 {
   6529   smallArrayt* self0;
   6530   dupG(self0);
   6531   smallBoolt* self1;
   6532   dupG(self1);
   6533   smallBytest* self2;
   6534   dupG(self2);
   6535   smallContainert* self3;
   6536   dupG(self3);
   6537   smallDictt* self4;
   6538   dupG(self4);
   6539   smallDoublet* self5;
   6540   dupG(self5);
   6541   smallIntt* self6;
   6542   dupG(self6);
   6543   smallJsont* self7;
   6544   dupG(self7);
   6545   smallStringt* self8;
   6546   dupG(self8);
   6547   undefinedt* self9;
   6548   dupG(self9);
   6549   baset* self10;
   6550   dupG(self10);
   6551   char * self11;
   6552   dupG(self11);
   6553   const char * self12;
   6554   dupG(self12);
   6555   char ** self13;
   6556   dupG(self13);
   6557   const char ** self14;
   6558   dupG(self14);
   6559 }
   6560 {
   6561   char * self1;
   6562   char * olds1;
   6563   char * news0;
   6564   size_t max1;
   6565   replaceG(self1, olds1, news0, max1);
   6566   const char * news1;
   6567   replaceG(self1, olds1, news1, max1);
   6568   char news2;
   6569   replaceG(self1, olds1, news2, max1);
   6570   int news3;
   6571   replaceG(self1, olds1, news3, max1);
   6572   const char * news5;
   6573   size_t max0;
   6574   replaceG(self1, olds1, news5, max0);
   6575 }
   6576 {
   6577   char * self1;
   6578   const char * olds2;
   6579   char * news0;
   6580   size_t max1;
   6581   replaceG(self1, olds2, news0, max1);
   6582   const char * news1;
   6583   replaceG(self1, olds2, news1, max1);
   6584   char news2;
   6585   replaceG(self1, olds2, news2, max1);
   6586   int news3;
   6587   replaceG(self1, olds2, news3, max1);
   6588   const char * news10;
   6589   size_t max0;
   6590   replaceG(self1, olds2, news10, max0);
   6591 }
   6592 {
   6593   char * self1;
   6594   char olds3;
   6595   char * news0;
   6596   size_t max1;
   6597   replaceG(self1, olds3, news0, max1);
   6598   const char * news1;
   6599   replaceG(self1, olds3, news1, max1);
   6600   char news2;
   6601   replaceG(self1, olds3, news2, max1);
   6602   int news3;
   6603   replaceG(self1, olds3, news3, max1);
   6604   const char * news15;
   6605   size_t max0;
   6606   replaceG(self1, olds3, news15, max0);
   6607 }
   6608 {
   6609   char * self1;
   6610   int olds4;
   6611   char * news0;
   6612   size_t max1;
   6613   replaceG(self1, olds4, news0, max1);
   6614   const char * news1;
   6615   replaceG(self1, olds4, news1, max1);
   6616   char news2;
   6617   replaceG(self1, olds4, news2, max1);
   6618   int news3;
   6619   replaceG(self1, olds4, news3, max1);
   6620   const char * news20;
   6621   size_t max0;
   6622   replaceG(self1, olds4, news20, max0);
   6623 }
   6624 {
   6625   char * self1;
   6626   const char * olds0;
   6627   const char * news0;
   6628   size_t max0;
   6629   replaceG(self1, olds0, news0, max0);
   6630 }
   6631 {
   6632   char ** self2;
   6633   char * olds6;
   6634   char * news0;
   6635   size_t max1;
   6636   replaceG(self2, olds6, news0, max1);
   6637   const char * news1;
   6638   replaceG(self2, olds6, news1, max1);
   6639   char news2;
   6640   replaceG(self2, olds6, news2, max1);
   6641   int news3;
   6642   replaceG(self2, olds6, news3, max1);
   6643   const char * news25;
   6644   size_t max0;
   6645   replaceG(self2, olds6, news25, max0);
   6646 }
   6647 {
   6648   char ** self2;
   6649   const char * olds7;
   6650   char * news0;
   6651   size_t max1;
   6652   replaceG(self2, olds7, news0, max1);
   6653   const char * news1;
   6654   replaceG(self2, olds7, news1, max1);
   6655   char news2;
   6656   replaceG(self2, olds7, news2, max1);
   6657   int news3;
   6658   replaceG(self2, olds7, news3, max1);
   6659   const char * news30;
   6660   size_t max0;
   6661   replaceG(self2, olds7, news30, max0);
   6662 }
   6663 {
   6664   char ** self2;
   6665   char olds8;
   6666   char * news0;
   6667   size_t max1;
   6668   replaceG(self2, olds8, news0, max1);
   6669   const char * news1;
   6670   replaceG(self2, olds8, news1, max1);
   6671   char news2;
   6672   replaceG(self2, olds8, news2, max1);
   6673   int news3;
   6674   replaceG(self2, olds8, news3, max1);
   6675   const char * news35;
   6676   size_t max0;
   6677   replaceG(self2, olds8, news35, max0);
   6678 }
   6679 {
   6680   char ** self2;
   6681   int olds9;
   6682   char * news0;
   6683   size_t max1;
   6684   replaceG(self2, olds9, news0, max1);
   6685   const char * news1;
   6686   replaceG(self2, olds9, news1, max1);
   6687   char news2;
   6688   replaceG(self2, olds9, news2, max1);
   6689   int news3;
   6690   replaceG(self2, olds9, news3, max1);
   6691   const char * news40;
   6692   size_t max0;
   6693   replaceG(self2, olds9, news40, max0);
   6694 }
   6695 {
   6696   char ** self2;
   6697   const char * olds0;
   6698   const char * news0;
   6699   size_t max0;
   6700   replaceG(self2, olds0, news0, max0);
   6701 }
   6702 {
   6703   smallJsont * self3;
   6704   char * olds11;
   6705   char * news0;
   6706   size_t max1;
   6707   replaceG(self3, olds11, news0, max1);
   6708   const char * news1;
   6709   replaceG(self3, olds11, news1, max1);
   6710   char news2;
   6711   replaceG(self3, olds11, news2, max1);
   6712   int news3;
   6713   replaceG(self3, olds11, news3, max1);
   6714   smallJsont * news4;
   6715   replaceG(self3, olds11, news4, max1);
   6716   smallStringt * news5;
   6717   replaceG(self3, olds11, news5, max1);
   6718 }
   6719 {
   6720   smallJsont * self3;
   6721   const char * olds12;
   6722   char * news0;
   6723   size_t max1;
   6724   replaceG(self3, olds12, news0, max1);
   6725   const char * news1;
   6726   replaceG(self3, olds12, news1, max1);
   6727   char news2;
   6728   replaceG(self3, olds12, news2, max1);
   6729   int news3;
   6730   replaceG(self3, olds12, news3, max1);
   6731   smallJsont * news4;
   6732   replaceG(self3, olds12, news4, max1);
   6733   smallStringt * news5;
   6734   replaceG(self3, olds12, news5, max1);
   6735 }
   6736 {
   6737   smallJsont * self3;
   6738   char olds13;
   6739   char * news0;
   6740   size_t max1;
   6741   replaceG(self3, olds13, news0, max1);
   6742   const char * news1;
   6743   replaceG(self3, olds13, news1, max1);
   6744   char news2;
   6745   replaceG(self3, olds13, news2, max1);
   6746   int news3;
   6747   replaceG(self3, olds13, news3, max1);
   6748   smallJsont * news4;
   6749   replaceG(self3, olds13, news4, max1);
   6750   smallStringt * news5;
   6751   replaceG(self3, olds13, news5, max1);
   6752 }
   6753 {
   6754   smallJsont * self3;
   6755   int olds14;
   6756   char * news0;
   6757   size_t max1;
   6758   replaceG(self3, olds14, news0, max1);
   6759   const char * news1;
   6760   replaceG(self3, olds14, news1, max1);
   6761   char news2;
   6762   replaceG(self3, olds14, news2, max1);
   6763   int news3;
   6764   replaceG(self3, olds14, news3, max1);
   6765   smallJsont * news4;
   6766   replaceG(self3, olds14, news4, max1);
   6767   smallStringt * news5;
   6768   replaceG(self3, olds14, news5, max1);
   6769 }
   6770 {
   6771   smallJsont * self3;
   6772   smallJsont * olds15;
   6773   char * news0;
   6774   size_t max1;
   6775   replaceG(self3, olds15, news0, max1);
   6776   const char * news1;
   6777   replaceG(self3, olds15, news1, max1);
   6778   char news2;
   6779   replaceG(self3, olds15, news2, max1);
   6780   int news3;
   6781   replaceG(self3, olds15, news3, max1);
   6782   smallJsont * news4;
   6783   replaceG(self3, olds15, news4, max1);
   6784   smallStringt * news5;
   6785   replaceG(self3, olds15, news5, max1);
   6786 }
   6787 {
   6788   smallJsont * self3;
   6789   smallStringt * olds16;
   6790   char * news0;
   6791   size_t max1;
   6792   replaceG(self3, olds16, news0, max1);
   6793   const char * news1;
   6794   replaceG(self3, olds16, news1, max1);
   6795   char news2;
   6796   replaceG(self3, olds16, news2, max1);
   6797   int news3;
   6798   replaceG(self3, olds16, news3, max1);
   6799   smallJsont * news4;
   6800   replaceG(self3, olds16, news4, max1);
   6801   smallStringt * news5;
   6802   replaceG(self3, olds16, news5, max1);
   6803 }
   6804 {
   6805   smallStringt * self4;
   6806   char * olds17;
   6807   char * news0;
   6808   size_t max1;
   6809   replaceG(self4, olds17, news0, max1);
   6810   const char * news1;
   6811   replaceG(self4, olds17, news1, max1);
   6812   char news2;
   6813   replaceG(self4, olds17, news2, max1);
   6814   int news3;
   6815   replaceG(self4, olds17, news3, max1);
   6816   smallJsont * news4;
   6817   replaceG(self4, olds17, news4, max1);
   6818   smallStringt * news5;
   6819   replaceG(self4, olds17, news5, max1);
   6820 }
   6821 {
   6822   smallStringt * self4;
   6823   const char * olds18;
   6824   char * news0;
   6825   size_t max1;
   6826   replaceG(self4, olds18, news0, max1);
   6827   const char * news1;
   6828   replaceG(self4, olds18, news1, max1);
   6829   char news2;
   6830   replaceG(self4, olds18, news2, max1);
   6831   int news3;
   6832   replaceG(self4, olds18, news3, max1);
   6833   smallJsont * news4;
   6834   replaceG(self4, olds18, news4, max1);
   6835   smallStringt * news5;
   6836   replaceG(self4, olds18, news5, max1);
   6837 }
   6838 {
   6839   smallStringt * self4;
   6840   char olds19;
   6841   char * news0;
   6842   size_t max1;
   6843   replaceG(self4, olds19, news0, max1);
   6844   const char * news1;
   6845   replaceG(self4, olds19, news1, max1);
   6846   char news2;
   6847   replaceG(self4, olds19, news2, max1);
   6848   int news3;
   6849   replaceG(self4, olds19, news3, max1);
   6850   smallJsont * news4;
   6851   replaceG(self4, olds19, news4, max1);
   6852   smallStringt * news5;
   6853   replaceG(self4, olds19, news5, max1);
   6854 }
   6855 {
   6856   smallStringt * self4;
   6857   int olds20;
   6858   char * news0;
   6859   size_t max1;
   6860   replaceG(self4, olds20, news0, max1);
   6861   const char * news1;
   6862   replaceG(self4, olds20, news1, max1);
   6863   char news2;
   6864   replaceG(self4, olds20, news2, max1);
   6865   int news3;
   6866   replaceG(self4, olds20, news3, max1);
   6867   smallJsont * news4;
   6868   replaceG(self4, olds20, news4, max1);
   6869   smallStringt * news5;
   6870   replaceG(self4, olds20, news5, max1);
   6871 }
   6872 {
   6873   smallStringt * self4;
   6874   smallJsont * olds21;
   6875   char * news0;
   6876   size_t max1;
   6877   replaceG(self4, olds21, news0, max1);
   6878   const char * news1;
   6879   replaceG(self4, olds21, news1, max1);
   6880   char news2;
   6881   replaceG(self4, olds21, news2, max1);
   6882   int news3;
   6883   replaceG(self4, olds21, news3, max1);
   6884   smallJsont * news4;
   6885   replaceG(self4, olds21, news4, max1);
   6886   smallStringt * news5;
   6887   replaceG(self4, olds21, news5, max1);
   6888 }
   6889 {
   6890   smallStringt * self4;
   6891   smallStringt * olds22;
   6892   char * news0;
   6893   size_t max1;
   6894   replaceG(self4, olds22, news0, max1);
   6895   const char * news1;
   6896   replaceG(self4, olds22, news1, max1);
   6897   char news2;
   6898   replaceG(self4, olds22, news2, max1);
   6899   int news3;
   6900   replaceG(self4, olds22, news3, max1);
   6901   smallJsont * news4;
   6902   replaceG(self4, olds22, news4, max1);
   6903   smallStringt * news5;
   6904   replaceG(self4, olds22, news5, max1);
   6905 }
   6906 {
   6907   char * self1;
   6908   char * olds1;
   6909   char * news0;
   6910   size_t max1;
   6911   icReplaceG(self1, olds1, news0, max1);
   6912   const char * news1;
   6913   icReplaceG(self1, olds1, news1, max1);
   6914   char news2;
   6915   icReplaceG(self1, olds1, news2, max1);
   6916   int news3;
   6917   icReplaceG(self1, olds1, news3, max1);
   6918   const char * news5;
   6919   size_t max0;
   6920   icReplaceG(self1, olds1, news5, max0);
   6921 }
   6922 {
   6923   char * self1;
   6924   const char * olds2;
   6925   char * news0;
   6926   size_t max1;
   6927   icReplaceG(self1, olds2, news0, max1);
   6928   const char * news1;
   6929   icReplaceG(self1, olds2, news1, max1);
   6930   char news2;
   6931   icReplaceG(self1, olds2, news2, max1);
   6932   int news3;
   6933   icReplaceG(self1, olds2, news3, max1);
   6934   const char * news10;
   6935   size_t max0;
   6936   icReplaceG(self1, olds2, news10, max0);
   6937 }
   6938 {
   6939   char * self1;
   6940   char olds3;
   6941   char * news0;
   6942   size_t max1;
   6943   icReplaceG(self1, olds3, news0, max1);
   6944   const char * news1;
   6945   icReplaceG(self1, olds3, news1, max1);
   6946   char news2;
   6947   icReplaceG(self1, olds3, news2, max1);
   6948   int news3;
   6949   icReplaceG(self1, olds3, news3, max1);
   6950   const char * news15;
   6951   size_t max0;
   6952   icReplaceG(self1, olds3, news15, max0);
   6953 }
   6954 {
   6955   char * self1;
   6956   int olds4;
   6957   char * news0;
   6958   size_t max1;
   6959   icReplaceG(self1, olds4, news0, max1);
   6960   const char * news1;
   6961   icReplaceG(self1, olds4, news1, max1);
   6962   char news2;
   6963   icReplaceG(self1, olds4, news2, max1);
   6964   int news3;
   6965   icReplaceG(self1, olds4, news3, max1);
   6966   const char * news20;
   6967   size_t max0;
   6968   icReplaceG(self1, olds4, news20, max0);
   6969 }
   6970 {
   6971   char * self1;
   6972   const char * olds0;
   6973   const char * news0;
   6974   size_t max0;
   6975   icReplaceG(self1, olds0, news0, max0);
   6976 }
   6977 {
   6978   char ** self2;
   6979   char * olds6;
   6980   char * news0;
   6981   size_t max1;
   6982   icReplaceG(self2, olds6, news0, max1);
   6983   const char * news1;
   6984   icReplaceG(self2, olds6, news1, max1);
   6985   char news2;
   6986   icReplaceG(self2, olds6, news2, max1);
   6987   int news3;
   6988   icReplaceG(self2, olds6, news3, max1);
   6989   const char * news25;
   6990   size_t max0;
   6991   icReplaceG(self2, olds6, news25, max0);
   6992 }
   6993 {
   6994   char ** self2;
   6995   const char * olds7;
   6996   char * news0;
   6997   size_t max1;
   6998   icReplaceG(self2, olds7, news0, max1);
   6999   const char * news1;
   7000   icReplaceG(self2, olds7, news1, max1);
   7001   char news2;
   7002   icReplaceG(self2, olds7, news2, max1);
   7003   int news3;
   7004   icReplaceG(self2, olds7, news3, max1);
   7005   const char * news30;
   7006   size_t max0;
   7007   icReplaceG(self2, olds7, news30, max0);
   7008 }
   7009 {
   7010   char ** self2;
   7011   char olds8;
   7012   char * news0;
   7013   size_t max1;
   7014   icReplaceG(self2, olds8, news0, max1);
   7015   const char * news1;
   7016   icReplaceG(self2, olds8, news1, max1);
   7017   char news2;
   7018   icReplaceG(self2, olds8, news2, max1);
   7019   int news3;
   7020   icReplaceG(self2, olds8, news3, max1);
   7021   const char * news35;
   7022   size_t max0;
   7023   icReplaceG(self2, olds8, news35, max0);
   7024 }
   7025 {
   7026   char ** self2;
   7027   int olds9;
   7028   char * news0;
   7029   size_t max1;
   7030   icReplaceG(self2, olds9, news0, max1);
   7031   const char * news1;
   7032   icReplaceG(self2, olds9, news1, max1);
   7033   char news2;
   7034   icReplaceG(self2, olds9, news2, max1);
   7035   int news3;
   7036   icReplaceG(self2, olds9, news3, max1);
   7037   const char * news40;
   7038   size_t max0;
   7039   icReplaceG(self2, olds9, news40, max0);
   7040 }
   7041 {
   7042   char ** self2;
   7043   const char * olds0;
   7044   const char * news0;
   7045   size_t max0;
   7046   icReplaceG(self2, olds0, news0, max0);
   7047 }
   7048 {
   7049   smallJsont * self3;
   7050   char * olds11;
   7051   char * news0;
   7052   size_t max1;
   7053   icReplaceG(self3, olds11, news0, max1);
   7054   const char * news1;
   7055   icReplaceG(self3, olds11, news1, max1);
   7056   char news2;
   7057   icReplaceG(self3, olds11, news2, max1);
   7058   int news3;
   7059   icReplaceG(self3, olds11, news3, max1);
   7060   smallJsont * news4;
   7061   icReplaceG(self3, olds11, news4, max1);
   7062   smallStringt * news5;
   7063   icReplaceG(self3, olds11, news5, max1);
   7064   const char * news47;
   7065   size_t max0;
   7066   icReplaceG(self3, olds11, news47, max0);
   7067 }
   7068 {
   7069   smallJsont * self3;
   7070   const char * olds12;
   7071   char * news0;
   7072   size_t max1;
   7073   icReplaceG(self3, olds12, news0, max1);
   7074   const char * news1;
   7075   icReplaceG(self3, olds12, news1, max1);
   7076   char news2;
   7077   icReplaceG(self3, olds12, news2, max1);
   7078   int news3;
   7079   icReplaceG(self3, olds12, news3, max1);
   7080   smallJsont * news4;
   7081   icReplaceG(self3, olds12, news4, max1);
   7082   smallStringt * news5;
   7083   icReplaceG(self3, olds12, news5, max1);
   7084   const char * news54;
   7085   size_t max0;
   7086   icReplaceG(self3, olds12, news54, max0);
   7087 }
   7088 {
   7089   smallJsont * self3;
   7090   char olds13;
   7091   char * news0;
   7092   size_t max1;
   7093   icReplaceG(self3, olds13, news0, max1);
   7094   const char * news1;
   7095   icReplaceG(self3, olds13, news1, max1);
   7096   char news2;
   7097   icReplaceG(self3, olds13, news2, max1);
   7098   int news3;
   7099   icReplaceG(self3, olds13, news3, max1);
   7100   smallJsont * news4;
   7101   icReplaceG(self3, olds13, news4, max1);
   7102   smallStringt * news5;
   7103   icReplaceG(self3, olds13, news5, max1);
   7104   const char * news61;
   7105   size_t max0;
   7106   icReplaceG(self3, olds13, news61, max0);
   7107 }
   7108 {
   7109   smallJsont * self3;
   7110   int olds14;
   7111   char * news0;
   7112   size_t max1;
   7113   icReplaceG(self3, olds14, news0, max1);
   7114   const char * news1;
   7115   icReplaceG(self3, olds14, news1, max1);
   7116   char news2;
   7117   icReplaceG(self3, olds14, news2, max1);
   7118   int news3;
   7119   icReplaceG(self3, olds14, news3, max1);
   7120   smallJsont * news4;
   7121   icReplaceG(self3, olds14, news4, max1);
   7122   smallStringt * news5;
   7123   icReplaceG(self3, olds14, news5, max1);
   7124   const char * news68;
   7125   size_t max0;
   7126   icReplaceG(self3, olds14, news68, max0);
   7127 }
   7128 {
   7129   smallJsont * self3;
   7130   smallJsont * olds15;
   7131   char * news0;
   7132   size_t max1;
   7133   icReplaceG(self3, olds15, news0, max1);
   7134   const char * news1;
   7135   icReplaceG(self3, olds15, news1, max1);
   7136   char news2;
   7137   icReplaceG(self3, olds15, news2, max1);
   7138   smallJsont * news3;
   7139   icReplaceG(self3, olds15, news3, max1);
   7140   smallStringt * news4;
   7141   icReplaceG(self3, olds15, news4, max1);
   7142   const char * news74;
   7143   size_t max0;
   7144   icReplaceG(self3, olds15, news74, max0);
   7145 }
   7146 {
   7147   smallJsont * self3;
   7148   smallStringt * olds16;
   7149   char * news0;
   7150   size_t max1;
   7151   icReplaceG(self3, olds16, news0, max1);
   7152   const char * news1;
   7153   icReplaceG(self3, olds16, news1, max1);
   7154   char news2;
   7155   icReplaceG(self3, olds16, news2, max1);
   7156   smallJsont * news3;
   7157   icReplaceG(self3, olds16, news3, max1);
   7158   smallStringt * news4;
   7159   icReplaceG(self3, olds16, news4, max1);
   7160   const char * news80;
   7161   size_t max0;
   7162   icReplaceG(self3, olds16, news80, max0);
   7163 }
   7164 {
   7165   smallStringt * self4;
   7166   char * olds17;
   7167   char * news0;
   7168   size_t max1;
   7169   icReplaceG(self4, olds17, news0, max1);
   7170   const char * news1;
   7171   icReplaceG(self4, olds17, news1, max1);
   7172   char news2;
   7173   icReplaceG(self4, olds17, news2, max1);
   7174   int news3;
   7175   icReplaceG(self4, olds17, news3, max1);
   7176   smallJsont * news4;
   7177   icReplaceG(self4, olds17, news4, max1);
   7178   smallStringt * news5;
   7179   icReplaceG(self4, olds17, news5, max1);
   7180   const char * news87;
   7181   size_t max0;
   7182   icReplaceG(self4, olds17, news87, max0);
   7183 }
   7184 {
   7185   smallStringt * self4;
   7186   const char * olds18;
   7187   char * news0;
   7188   size_t max1;
   7189   icReplaceG(self4, olds18, news0, max1);
   7190   const char * news1;
   7191   icReplaceG(self4, olds18, news1, max1);
   7192   char news2;
   7193   icReplaceG(self4, olds18, news2, max1);
   7194   int news3;
   7195   icReplaceG(self4, olds18, news3, max1);
   7196   smallJsont * news4;
   7197   icReplaceG(self4, olds18, news4, max1);
   7198   smallStringt * news5;
   7199   icReplaceG(self4, olds18, news5, max1);
   7200   const char * news94;
   7201   size_t max0;
   7202   icReplaceG(self4, olds18, news94, max0);
   7203 }
   7204 {
   7205   smallStringt * self4;
   7206   char olds19;
   7207   char * news0;
   7208   size_t max1;
   7209   icReplaceG(self4, olds19, news0, max1);
   7210   const char * news1;
   7211   icReplaceG(self4, olds19, news1, max1);
   7212   char news2;
   7213   icReplaceG(self4, olds19, news2, max1);
   7214   int news3;
   7215   icReplaceG(self4, olds19, news3, max1);
   7216   smallJsont * news4;
   7217   icReplaceG(self4, olds19, news4, max1);
   7218   smallStringt * news5;
   7219   icReplaceG(self4, olds19, news5, max1);
   7220   const char * news101;
   7221   size_t max0;
   7222   icReplaceG(self4, olds19, news101, max0);
   7223 }
   7224 {
   7225   smallStringt * self4;
   7226   int olds20;
   7227   char * news0;
   7228   size_t max1;
   7229   icReplaceG(self4, olds20, news0, max1);
   7230   const char * news1;
   7231   icReplaceG(self4, olds20, news1, max1);
   7232   char news2;
   7233   icReplaceG(self4, olds20, news2, max1);
   7234   int news3;
   7235   icReplaceG(self4, olds20, news3, max1);
   7236   smallJsont * news4;
   7237   icReplaceG(self4, olds20, news4, max1);
   7238   smallStringt * news5;
   7239   icReplaceG(self4, olds20, news5, max1);
   7240   const char * news108;
   7241   size_t max0;
   7242   icReplaceG(self4, olds20, news108, max0);
   7243 }
   7244 {
   7245   smallStringt * self4;
   7246   smallJsont * olds21;
   7247   char * news0;
   7248   size_t max1;
   7249   icReplaceG(self4, olds21, news0, max1);
   7250   const char * news1;
   7251   icReplaceG(self4, olds21, news1, max1);
   7252   char news2;
   7253   icReplaceG(self4, olds21, news2, max1);
   7254   smallJsont * news3;
   7255   icReplaceG(self4, olds21, news3, max1);
   7256   smallStringt * news4;
   7257   icReplaceG(self4, olds21, news4, max1);
   7258   const char * news114;
   7259   size_t max0;
   7260   icReplaceG(self4, olds21, news114, max0);
   7261 }
   7262 {
   7263   smallStringt * self4;
   7264   smallStringt * olds22;
   7265   char * news0;
   7266   size_t max1;
   7267   icReplaceG(self4, olds22, news0, max1);
   7268   const char * news1;
   7269   icReplaceG(self4, olds22, news1, max1);
   7270   char news2;
   7271   icReplaceG(self4, olds22, news2, max1);
   7272   smallJsont * news3;
   7273   icReplaceG(self4, olds22, news3, max1);
   7274   smallStringt * news4;
   7275   icReplaceG(self4, olds22, news4, max1);
   7276   const char * news120;
   7277   size_t max0;
   7278   icReplaceG(self4, olds22, news120, max0);
   7279 }
   7280 {
   7281   baset * self0;
   7282   isLSheepyObject(self0);
   7283   smallArrayt* self1;
   7284   isLSheepyObject(self1);
   7285   smallBoolt* self2;
   7286   isLSheepyObject(self2);
   7287   smallBytest* self3;
   7288   isLSheepyObject(self3);
   7289   smallDictt * self4;
   7290   isLSheepyObject(self4);
   7291   smallDoublet * self5;
   7292   isLSheepyObject(self5);
   7293   smallIntt * self6;
   7294   isLSheepyObject(self6);
   7295   smallJsont * self7;
   7296   isLSheepyObject(self7);
   7297   smallStringt * self8;
   7298   isLSheepyObject(self8);
   7299   smallContainert * self9;
   7300   isLSheepyObject(self9);
   7301   undefinedt * self10;
   7302   isLSheepyObject(self10);
   7303 }
   7304 {
   7305   char self1;
   7306   char * obj0;
   7307   eqDirectG(self1, obj0);
   7308   const char * obj1;
   7309   eqDirectG(self1, obj1);
   7310   char obj2;
   7311   eqDirectG(self1, obj2);
   7312   baset* obj3;
   7313   eqDirectG(self1, obj3);
   7314   bool obj4;
   7315   eqDirectG(self1, obj4);
   7316   double obj5;
   7317   eqDirectG(self1, obj5);
   7318   int64_t obj6;
   7319   eqDirectG(self1, obj6);
   7320   int32_t obj7;
   7321   eqDirectG(self1, obj7);
   7322   uint32_t obj8;
   7323   eqDirectG(self1, obj8);
   7324   uint64_t obj9;
   7325   eqDirectG(self1, obj9);
   7326   smallBytest* obj10;
   7327   eqDirectG(self1, obj10);
   7328   smallDoublet* obj11;
   7329   eqDirectG(self1, obj11);
   7330   smallIntt* obj12;
   7331   eqDirectG(self1, obj12);
   7332   smallJsont* obj13;
   7333   eqDirectG(self1, obj13);
   7334   smallStringt* obj14;
   7335   eqDirectG(self1, obj14);
   7336   void * obj15;
   7337   eqDirectG(self1, obj15);
   7338 }
   7339 {
   7340   char * self2;
   7341   char * obj0;
   7342   eqDirectG(self2, obj0);
   7343   const char * obj1;
   7344   eqDirectG(self2, obj1);
   7345   char obj2;
   7346   eqDirectG(self2, obj2);
   7347   baset* obj3;
   7348   eqDirectG(self2, obj3);
   7349   bool obj4;
   7350   eqDirectG(self2, obj4);
   7351   double obj5;
   7352   eqDirectG(self2, obj5);
   7353   int64_t obj6;
   7354   eqDirectG(self2, obj6);
   7355   int32_t obj7;
   7356   eqDirectG(self2, obj7);
   7357   uint32_t obj8;
   7358   eqDirectG(self2, obj8);
   7359   uint64_t obj9;
   7360   eqDirectG(self2, obj9);
   7361   smallBoolt* obj10;
   7362   eqDirectG(self2, obj10);
   7363   smallBytest* obj11;
   7364   eqDirectG(self2, obj11);
   7365   smallDoublet* obj12;
   7366   eqDirectG(self2, obj12);
   7367   smallIntt* obj13;
   7368   eqDirectG(self2, obj13);
   7369   smallJsont* obj14;
   7370   eqDirectG(self2, obj14);
   7371   smallStringt* obj15;
   7372   eqDirectG(self2, obj15);
   7373   void * obj16;
   7374   eqDirectG(self2, obj16);
   7375 }
   7376 {
   7377   const char * self3;
   7378   char * obj0;
   7379   eqDirectG(self3, obj0);
   7380   const char * obj1;
   7381   eqDirectG(self3, obj1);
   7382   char obj2;
   7383   eqDirectG(self3, obj2);
   7384   baset* obj3;
   7385   eqDirectG(self3, obj3);
   7386   bool obj4;
   7387   eqDirectG(self3, obj4);
   7388   double obj5;
   7389   eqDirectG(self3, obj5);
   7390   int64_t obj6;
   7391   eqDirectG(self3, obj6);
   7392   int32_t obj7;
   7393   eqDirectG(self3, obj7);
   7394   uint32_t obj8;
   7395   eqDirectG(self3, obj8);
   7396   uint64_t obj9;
   7397   eqDirectG(self3, obj9);
   7398   smallBoolt* obj10;
   7399   eqDirectG(self3, obj10);
   7400   smallBytest* obj11;
   7401   eqDirectG(self3, obj11);
   7402   smallDoublet* obj12;
   7403   eqDirectG(self3, obj12);
   7404   smallIntt* obj13;
   7405   eqDirectG(self3, obj13);
   7406   smallJsont* obj14;
   7407   eqDirectG(self3, obj14);
   7408   smallStringt* obj15;
   7409   eqDirectG(self3, obj15);
   7410   void * obj16;
   7411   eqDirectG(self3, obj16);
   7412 }
   7413 {
   7414   char ** self4;
   7415   char obj0;
   7416   eqDirectG(self4, obj0);
   7417   char ** obj1;
   7418   eqDirectG(self4, obj1);
   7419   const char ** obj2;
   7420   eqDirectG(self4, obj2);
   7421   baset* obj3;
   7422   eqDirectG(self4, obj3);
   7423   bool obj4;
   7424   eqDirectG(self4, obj4);
   7425   double obj5;
   7426   eqDirectG(self4, obj5);
   7427   int64_t obj6;
   7428   eqDirectG(self4, obj6);
   7429   int32_t obj7;
   7430   eqDirectG(self4, obj7);
   7431   uint32_t obj8;
   7432   eqDirectG(self4, obj8);
   7433   uint64_t obj9;
   7434   eqDirectG(self4, obj9);
   7435   smallJsont* obj10;
   7436   eqDirectG(self4, obj10);
   7437   smallArrayt* obj11;
   7438   eqDirectG(self4, obj11);
   7439   void * obj12;
   7440   eqDirectG(self4, obj12);
   7441 }
   7442 {
   7443   const char ** self5;
   7444   char obj0;
   7445   eqDirectG(self5, obj0);
   7446   char ** obj1;
   7447   eqDirectG(self5, obj1);
   7448   const char ** obj2;
   7449   eqDirectG(self5, obj2);
   7450   baset* obj3;
   7451   eqDirectG(self5, obj3);
   7452   bool obj4;
   7453   eqDirectG(self5, obj4);
   7454   double obj5;
   7455   eqDirectG(self5, obj5);
   7456   int64_t obj6;
   7457   eqDirectG(self5, obj6);
   7458   int32_t obj7;
   7459   eqDirectG(self5, obj7);
   7460   uint32_t obj8;
   7461   eqDirectG(self5, obj8);
   7462   uint64_t obj9;
   7463   eqDirectG(self5, obj9);
   7464   smallJsont* obj10;
   7465   eqDirectG(self5, obj10);
   7466   smallArrayt* obj11;
   7467   eqDirectG(self5, obj11);
   7468   void * obj12;
   7469   eqDirectG(self5, obj12);
   7470 }
   7471 {
   7472   baset* self6;
   7473   char obj0;
   7474   eqDirectG(self6, obj0);
   7475   char * obj1;
   7476   eqDirectG(self6, obj1);
   7477   const char * obj2;
   7478   eqDirectG(self6, obj2);
   7479   char ** obj3;
   7480   eqDirectG(self6, obj3);
   7481   const char ** obj4;
   7482   eqDirectG(self6, obj4);
   7483   baset* obj5;
   7484   eqDirectG(self6, obj5);
   7485   bool obj6;
   7486   eqDirectG(self6, obj6);
   7487   double obj7;
   7488   eqDirectG(self6, obj7);
   7489   int64_t obj8;
   7490   eqDirectG(self6, obj8);
   7491   int32_t obj9;
   7492   eqDirectG(self6, obj9);
   7493   uint32_t obj10;
   7494   eqDirectG(self6, obj10);
   7495   uint64_t obj11;
   7496   eqDirectG(self6, obj11);
   7497   smallArrayt* obj12;
   7498   eqDirectG(self6, obj12);
   7499   smallBoolt* obj13;
   7500   eqDirectG(self6, obj13);
   7501   smallBytest* obj14;
   7502   eqDirectG(self6, obj14);
   7503   smallDoublet* obj15;
   7504   eqDirectG(self6, obj15);
   7505   smallDictt* obj16;
   7506   eqDirectG(self6, obj16);
   7507   smallIntt* obj17;
   7508   eqDirectG(self6, obj17);
   7509   smallJsont* obj18;
   7510   eqDirectG(self6, obj18);
   7511   smallStringt* obj19;
   7512   eqDirectG(self6, obj19);
   7513   void * obj20;
   7514   eqDirectG(self6, obj20);
   7515 }
   7516 {
   7517   bool self7;
   7518   char obj0;
   7519   eqDirectG(self7, obj0);
   7520   char * obj1;
   7521   eqDirectG(self7, obj1);
   7522   const char * obj2;
   7523   eqDirectG(self7, obj2);
   7524   baset* obj3;
   7525   eqDirectG(self7, obj3);
   7526   bool obj4;
   7527   eqDirectG(self7, obj4);
   7528   double obj5;
   7529   eqDirectG(self7, obj5);
   7530   int64_t obj6;
   7531   eqDirectG(self7, obj6);
   7532   int32_t obj7;
   7533   eqDirectG(self7, obj7);
   7534   uint32_t obj8;
   7535   eqDirectG(self7, obj8);
   7536   uint64_t obj9;
   7537   eqDirectG(self7, obj9);
   7538   smallBoolt* obj10;
   7539   eqDirectG(self7, obj10);
   7540   smallBytest* obj11;
   7541   eqDirectG(self7, obj11);
   7542   smallDoublet* obj12;
   7543   eqDirectG(self7, obj12);
   7544   smallIntt* obj13;
   7545   eqDirectG(self7, obj13);
   7546   smallJsont* obj14;
   7547   eqDirectG(self7, obj14);
   7548   smallStringt* obj15;
   7549   eqDirectG(self7, obj15);
   7550   void * obj16;
   7551   eqDirectG(self7, obj16);
   7552 }
   7553 {
   7554   double self8;
   7555   char obj0;
   7556   eqDirectG(self8, obj0);
   7557   char * obj1;
   7558   eqDirectG(self8, obj1);
   7559   const char * obj2;
   7560   eqDirectG(self8, obj2);
   7561   baset* obj3;
   7562   eqDirectG(self8, obj3);
   7563   bool obj4;
   7564   eqDirectG(self8, obj4);
   7565   double obj5;
   7566   eqDirectG(self8, obj5);
   7567   int64_t obj6;
   7568   eqDirectG(self8, obj6);
   7569   int32_t obj7;
   7570   eqDirectG(self8, obj7);
   7571   uint32_t obj8;
   7572   eqDirectG(self8, obj8);
   7573   uint64_t obj9;
   7574   eqDirectG(self8, obj9);
   7575   smallBoolt* obj10;
   7576   eqDirectG(self8, obj10);
   7577   smallBytest* obj11;
   7578   eqDirectG(self8, obj11);
   7579   smallDoublet* obj12;
   7580   eqDirectG(self8, obj12);
   7581   smallIntt* obj13;
   7582   eqDirectG(self8, obj13);
   7583   smallJsont* obj14;
   7584   eqDirectG(self8, obj14);
   7585   smallStringt* obj15;
   7586   eqDirectG(self8, obj15);
   7587   void * obj16;
   7588   eqDirectG(self8, obj16);
   7589 }
   7590 {
   7591   int64_t self9;
   7592   char obj0;
   7593   eqDirectG(self9, obj0);
   7594   char * obj1;
   7595   eqDirectG(self9, obj1);
   7596   const char * obj2;
   7597   eqDirectG(self9, obj2);
   7598   baset* obj3;
   7599   eqDirectG(self9, obj3);
   7600   bool obj4;
   7601   eqDirectG(self9, obj4);
   7602   double obj5;
   7603   eqDirectG(self9, obj5);
   7604   int64_t obj6;
   7605   eqDirectG(self9, obj6);
   7606   int32_t obj7;
   7607   eqDirectG(self9, obj7);
   7608   uint32_t obj8;
   7609   eqDirectG(self9, obj8);
   7610   uint64_t obj9;
   7611   eqDirectG(self9, obj9);
   7612   smallBoolt* obj10;
   7613   eqDirectG(self9, obj10);
   7614   smallBytest* obj11;
   7615   eqDirectG(self9, obj11);
   7616   smallDoublet* obj12;
   7617   eqDirectG(self9, obj12);
   7618   smallIntt* obj13;
   7619   eqDirectG(self9, obj13);
   7620   smallJsont* obj14;
   7621   eqDirectG(self9, obj14);
   7622   smallStringt* obj15;
   7623   eqDirectG(self9, obj15);
   7624   void * obj16;
   7625   eqDirectG(self9, obj16);
   7626 }
   7627 {
   7628   int32_t self10;
   7629   char obj0;
   7630   eqDirectG(self10, obj0);
   7631   char * obj1;
   7632   eqDirectG(self10, obj1);
   7633   const char * obj2;
   7634   eqDirectG(self10, obj2);
   7635   baset* obj3;
   7636   eqDirectG(self10, obj3);
   7637   bool obj4;
   7638   eqDirectG(self10, obj4);
   7639   double obj5;
   7640   eqDirectG(self10, obj5);
   7641   int64_t obj6;
   7642   eqDirectG(self10, obj6);
   7643   int32_t obj7;
   7644   eqDirectG(self10, obj7);
   7645   uint32_t obj8;
   7646   eqDirectG(self10, obj8);
   7647   uint64_t obj9;
   7648   eqDirectG(self10, obj9);
   7649   smallBoolt* obj10;
   7650   eqDirectG(self10, obj10);
   7651   smallBytest* obj11;
   7652   eqDirectG(self10, obj11);
   7653   smallDoublet* obj12;
   7654   eqDirectG(self10, obj12);
   7655   smallIntt* obj13;
   7656   eqDirectG(self10, obj13);
   7657   smallJsont* obj14;
   7658   eqDirectG(self10, obj14);
   7659   smallStringt* obj15;
   7660   eqDirectG(self10, obj15);
   7661   void * obj16;
   7662   eqDirectG(self10, obj16);
   7663 }
   7664 {
   7665   uint32_t self11;
   7666   char obj0;
   7667   eqDirectG(self11, obj0);
   7668   char * obj1;
   7669   eqDirectG(self11, obj1);
   7670   const char * obj2;
   7671   eqDirectG(self11, obj2);
   7672   baset* obj3;
   7673   eqDirectG(self11, obj3);
   7674   bool obj4;
   7675   eqDirectG(self11, obj4);
   7676   double obj5;
   7677   eqDirectG(self11, obj5);
   7678   int64_t obj6;
   7679   eqDirectG(self11, obj6);
   7680   int32_t obj7;
   7681   eqDirectG(self11, obj7);
   7682   uint32_t obj8;
   7683   eqDirectG(self11, obj8);
   7684   uint64_t obj9;
   7685   eqDirectG(self11, obj9);
   7686   smallBoolt* obj10;
   7687   eqDirectG(self11, obj10);
   7688   smallBytest* obj11;
   7689   eqDirectG(self11, obj11);
   7690   smallDoublet* obj12;
   7691   eqDirectG(self11, obj12);
   7692   smallIntt* obj13;
   7693   eqDirectG(self11, obj13);
   7694   smallJsont* obj14;
   7695   eqDirectG(self11, obj14);
   7696   smallStringt* obj15;
   7697   eqDirectG(self11, obj15);
   7698   void * obj16;
   7699   eqDirectG(self11, obj16);
   7700 }
   7701 {
   7702   uint64_t self12;
   7703   char obj0;
   7704   eqDirectG(self12, obj0);
   7705   char * obj1;
   7706   eqDirectG(self12, obj1);
   7707   const char * obj2;
   7708   eqDirectG(self12, obj2);
   7709   baset* obj3;
   7710   eqDirectG(self12, obj3);
   7711   bool obj4;
   7712   eqDirectG(self12, obj4);
   7713   double obj5;
   7714   eqDirectG(self12, obj5);
   7715   int64_t obj6;
   7716   eqDirectG(self12, obj6);
   7717   int32_t obj7;
   7718   eqDirectG(self12, obj7);
   7719   uint32_t obj8;
   7720   eqDirectG(self12, obj8);
   7721   uint64_t obj9;
   7722   eqDirectG(self12, obj9);
   7723   smallBoolt* obj10;
   7724   eqDirectG(self12, obj10);
   7725   smallBytest* obj11;
   7726   eqDirectG(self12, obj11);
   7727   smallDoublet* obj12;
   7728   eqDirectG(self12, obj12);
   7729   smallIntt* obj13;
   7730   eqDirectG(self12, obj13);
   7731   smallJsont* obj14;
   7732   eqDirectG(self12, obj14);
   7733   smallStringt* obj15;
   7734   eqDirectG(self12, obj15);
   7735   void * obj16;
   7736   eqDirectG(self12, obj16);
   7737 }
   7738 {
   7739   smallArrayt* self13;
   7740   char obj0;
   7741   eqDirectG(self13, obj0);
   7742   char ** obj1;
   7743   eqDirectG(self13, obj1);
   7744   const char ** obj2;
   7745   eqDirectG(self13, obj2);
   7746   baset* obj3;
   7747   eqDirectG(self13, obj3);
   7748   bool obj4;
   7749   eqDirectG(self13, obj4);
   7750   double obj5;
   7751   eqDirectG(self13, obj5);
   7752   int64_t obj6;
   7753   eqDirectG(self13, obj6);
   7754   int32_t obj7;
   7755   eqDirectG(self13, obj7);
   7756   uint32_t obj8;
   7757   eqDirectG(self13, obj8);
   7758   uint64_t obj9;
   7759   eqDirectG(self13, obj9);
   7760   smallJsont* obj10;
   7761   eqDirectG(self13, obj10);
   7762   smallArrayt* obj11;
   7763   eqDirectG(self13, obj11);
   7764   void * obj12;
   7765   eqDirectG(self13, obj12);
   7766 }
   7767 {
   7768   smallBoolt* self14;
   7769   char obj0;
   7770   eqDirectG(self14, obj0);
   7771   char * obj1;
   7772   eqDirectG(self14, obj1);
   7773   const char * obj2;
   7774   eqDirectG(self14, obj2);
   7775   baset* obj3;
   7776   eqDirectG(self14, obj3);
   7777   bool obj4;
   7778   eqDirectG(self14, obj4);
   7779   double obj5;
   7780   eqDirectG(self14, obj5);
   7781   int64_t obj6;
   7782   eqDirectG(self14, obj6);
   7783   int32_t obj7;
   7784   eqDirectG(self14, obj7);
   7785   uint32_t obj8;
   7786   eqDirectG(self14, obj8);
   7787   uint64_t obj9;
   7788   eqDirectG(self14, obj9);
   7789   smallBoolt* obj10;
   7790   eqDirectG(self14, obj10);
   7791   smallBytest* obj11;
   7792   eqDirectG(self14, obj11);
   7793   smallDoublet* obj12;
   7794   eqDirectG(self14, obj12);
   7795   smallIntt* obj13;
   7796   eqDirectG(self14, obj13);
   7797   smallJsont* obj14;
   7798   eqDirectG(self14, obj14);
   7799   smallStringt* obj15;
   7800   eqDirectG(self14, obj15);
   7801   void * obj16;
   7802   eqDirectG(self14, obj16);
   7803 }
   7804 {
   7805   smallBytest* self15;
   7806   char obj0;
   7807   eqDirectG(self15, obj0);
   7808   char * obj1;
   7809   eqDirectG(self15, obj1);
   7810   const char * obj2;
   7811   eqDirectG(self15, obj2);
   7812   baset* obj3;
   7813   eqDirectG(self15, obj3);
   7814   bool obj4;
   7815   eqDirectG(self15, obj4);
   7816   double obj5;
   7817   eqDirectG(self15, obj5);
   7818   int64_t obj6;
   7819   eqDirectG(self15, obj6);
   7820   int32_t obj7;
   7821   eqDirectG(self15, obj7);
   7822   uint32_t obj8;
   7823   eqDirectG(self15, obj8);
   7824   uint64_t obj9;
   7825   eqDirectG(self15, obj9);
   7826   smallBoolt* obj10;
   7827   eqDirectG(self15, obj10);
   7828   smallBytest* obj11;
   7829   eqDirectG(self15, obj11);
   7830   smallDoublet* obj12;
   7831   eqDirectG(self15, obj12);
   7832   smallIntt* obj13;
   7833   eqDirectG(self15, obj13);
   7834   smallStringt* obj14;
   7835   eqDirectG(self15, obj14);
   7836   void * obj15;
   7837   eqDirectG(self15, obj15);
   7838 }
   7839 {
   7840   smallDoublet* self16;
   7841   char obj0;
   7842   eqDirectG(self16, obj0);
   7843   char * obj1;
   7844   eqDirectG(self16, obj1);
   7845   const char * obj2;
   7846   eqDirectG(self16, obj2);
   7847   baset* obj3;
   7848   eqDirectG(self16, obj3);
   7849   bool obj4;
   7850   eqDirectG(self16, obj4);
   7851   double obj5;
   7852   eqDirectG(self16, obj5);
   7853   int64_t obj6;
   7854   eqDirectG(self16, obj6);
   7855   int32_t obj7;
   7856   eqDirectG(self16, obj7);
   7857   uint32_t obj8;
   7858   eqDirectG(self16, obj8);
   7859   uint64_t obj9;
   7860   eqDirectG(self16, obj9);
   7861   smallBoolt* obj10;
   7862   eqDirectG(self16, obj10);
   7863   smallBytest* obj11;
   7864   eqDirectG(self16, obj11);
   7865   smallDoublet* obj12;
   7866   eqDirectG(self16, obj12);
   7867   smallIntt* obj13;
   7868   eqDirectG(self16, obj13);
   7869   smallJsont* obj14;
   7870   eqDirectG(self16, obj14);
   7871   smallStringt* obj15;
   7872   eqDirectG(self16, obj15);
   7873   void * obj16;
   7874   eqDirectG(self16, obj16);
   7875 }
   7876 {
   7877   smallDictt* self17;
   7878   char obj0;
   7879   eqDirectG(self17, obj0);
   7880   baset* obj1;
   7881   eqDirectG(self17, obj1);
   7882   bool obj2;
   7883   eqDirectG(self17, obj2);
   7884   double obj3;
   7885   eqDirectG(self17, obj3);
   7886   int64_t obj4;
   7887   eqDirectG(self17, obj4);
   7888   int32_t obj5;
   7889   eqDirectG(self17, obj5);
   7890   uint32_t obj6;
   7891   eqDirectG(self17, obj6);
   7892   uint64_t obj7;
   7893   eqDirectG(self17, obj7);
   7894   smallJsont* obj8;
   7895   eqDirectG(self17, obj8);
   7896   smallDictt* obj9;
   7897   eqDirectG(self17, obj9);
   7898   void * obj10;
   7899   eqDirectG(self17, obj10);
   7900 }
   7901 {
   7902   smallIntt* self18;
   7903   char obj0;
   7904   eqDirectG(self18, obj0);
   7905   char * obj1;
   7906   eqDirectG(self18, obj1);
   7907   const char * obj2;
   7908   eqDirectG(self18, obj2);
   7909   baset* obj3;
   7910   eqDirectG(self18, obj3);
   7911   bool obj4;
   7912   eqDirectG(self18, obj4);
   7913   double obj5;
   7914   eqDirectG(self18, obj5);
   7915   int64_t obj6;
   7916   eqDirectG(self18, obj6);
   7917   int32_t obj7;
   7918   eqDirectG(self18, obj7);
   7919   uint32_t obj8;
   7920   eqDirectG(self18, obj8);
   7921   uint64_t obj9;
   7922   eqDirectG(self18, obj9);
   7923   smallBoolt* obj10;
   7924   eqDirectG(self18, obj10);
   7925   smallBytest* obj11;
   7926   eqDirectG(self18, obj11);
   7927   smallDoublet* obj12;
   7928   eqDirectG(self18, obj12);
   7929   smallIntt* obj13;
   7930   eqDirectG(self18, obj13);
   7931   smallJsont* obj14;
   7932   eqDirectG(self18, obj14);
   7933   smallStringt* obj15;
   7934   eqDirectG(self18, obj15);
   7935   void * obj16;
   7936   eqDirectG(self18, obj16);
   7937 }
   7938 {
   7939   smallJsont* self19;
   7940   char obj0;
   7941   eqDirectG(self19, obj0);
   7942   char * obj1;
   7943   eqDirectG(self19, obj1);
   7944   const char * obj2;
   7945   eqDirectG(self19, obj2);
   7946   char ** obj3;
   7947   eqDirectG(self19, obj3);
   7948   const char ** obj4;
   7949   eqDirectG(self19, obj4);
   7950   baset* obj5;
   7951   eqDirectG(self19, obj5);
   7952   bool obj6;
   7953   eqDirectG(self19, obj6);
   7954   double obj7;
   7955   eqDirectG(self19, obj7);
   7956   int64_t obj8;
   7957   eqDirectG(self19, obj8);
   7958   int32_t obj9;
   7959   eqDirectG(self19, obj9);
   7960   uint32_t obj10;
   7961   eqDirectG(self19, obj10);
   7962   uint64_t obj11;
   7963   eqDirectG(self19, obj11);
   7964   smallArrayt* obj12;
   7965   eqDirectG(self19, obj12);
   7966   smallBoolt* obj13;
   7967   eqDirectG(self19, obj13);
   7968   smallBytest* obj14;
   7969   eqDirectG(self19, obj14);
   7970   smallDictt* obj15;
   7971   eqDirectG(self19, obj15);
   7972   smallDoublet* obj16;
   7973   eqDirectG(self19, obj16);
   7974   smallIntt* obj17;
   7975   eqDirectG(self19, obj17);
   7976   smallJsont* obj18;
   7977   eqDirectG(self19, obj18);
   7978   smallStringt* obj19;
   7979   eqDirectG(self19, obj19);
   7980   void * obj20;
   7981   eqDirectG(self19, obj20);
   7982 }
   7983 {
   7984   smallStringt* self20;
   7985   char * obj0;
   7986   eqDirectG(self20, obj0);
   7987   const char * obj1;
   7988   eqDirectG(self20, obj1);
   7989   char obj2;
   7990   eqDirectG(self20, obj2);
   7991   baset* obj3;
   7992   eqDirectG(self20, obj3);
   7993   bool obj4;
   7994   eqDirectG(self20, obj4);
   7995   double obj5;
   7996   eqDirectG(self20, obj5);
   7997   int64_t obj6;
   7998   eqDirectG(self20, obj6);
   7999   int32_t obj7;
   8000   eqDirectG(self20, obj7);
   8001   uint32_t obj8;
   8002   eqDirectG(self20, obj8);
   8003   uint64_t obj9;
   8004   eqDirectG(self20, obj9);
   8005   smallBoolt* obj10;
   8006   eqDirectG(self20, obj10);
   8007   smallBytest* obj11;
   8008   eqDirectG(self20, obj11);
   8009   smallDoublet* obj12;
   8010   eqDirectG(self20, obj12);
   8011   smallIntt* obj13;
   8012   eqDirectG(self20, obj13);
   8013   smallJsont* obj14;
   8014   eqDirectG(self20, obj14);
   8015   smallStringt* obj15;
   8016   eqDirectG(self20, obj15);
   8017   void * obj16;
   8018   eqDirectG(self20, obj16);
   8019 }
   8020 {
   8021   char self1;
   8022   char * obj0;
   8023   icEqDirectG(self1, obj0);
   8024   const char * obj1;
   8025   icEqDirectG(self1, obj1);
   8026   char obj2;
   8027   icEqDirectG(self1, obj2);
   8028   baset* obj3;
   8029   icEqDirectG(self1, obj3);
   8030   bool obj4;
   8031   icEqDirectG(self1, obj4);
   8032   double obj5;
   8033   icEqDirectG(self1, obj5);
   8034   int64_t obj6;
   8035   icEqDirectG(self1, obj6);
   8036   int32_t obj7;
   8037   icEqDirectG(self1, obj7);
   8038   uint32_t obj8;
   8039   icEqDirectG(self1, obj8);
   8040   uint64_t obj9;
   8041   icEqDirectG(self1, obj9);
   8042   smallDoublet* obj10;
   8043   icEqDirectG(self1, obj10);
   8044   smallIntt* obj11;
   8045   icEqDirectG(self1, obj11);
   8046   smallJsont* obj12;
   8047   icEqDirectG(self1, obj12);
   8048   smallStringt* obj13;
   8049   icEqDirectG(self1, obj13);
   8050   void * obj14;
   8051   icEqDirectG(self1, obj14);
   8052 }
   8053 {
   8054   char * self2;
   8055   char * obj0;
   8056   icEqDirectG(self2, obj0);
   8057   const char * obj1;
   8058   icEqDirectG(self2, obj1);
   8059   char obj2;
   8060   icEqDirectG(self2, obj2);
   8061   baset* obj3;
   8062   icEqDirectG(self2, obj3);
   8063   bool obj4;
   8064   icEqDirectG(self2, obj4);
   8065   double obj5;
   8066   icEqDirectG(self2, obj5);
   8067   int64_t obj6;
   8068   icEqDirectG(self2, obj6);
   8069   int32_t obj7;
   8070   icEqDirectG(self2, obj7);
   8071   uint32_t obj8;
   8072   icEqDirectG(self2, obj8);
   8073   uint64_t obj9;
   8074   icEqDirectG(self2, obj9);
   8075   smallBoolt* obj10;
   8076   icEqDirectG(self2, obj10);
   8077   smallBytest* obj11;
   8078   icEqDirectG(self2, obj11);
   8079   smallDoublet* obj12;
   8080   icEqDirectG(self2, obj12);
   8081   smallIntt* obj13;
   8082   icEqDirectG(self2, obj13);
   8083   smallJsont* obj14;
   8084   icEqDirectG(self2, obj14);
   8085   smallStringt* obj15;
   8086   icEqDirectG(self2, obj15);
   8087   void * obj16;
   8088   icEqDirectG(self2, obj16);
   8089 }
   8090 {
   8091   const char * self3;
   8092   char * obj0;
   8093   icEqDirectG(self3, obj0);
   8094   const char * obj1;
   8095   icEqDirectG(self3, obj1);
   8096   char obj2;
   8097   icEqDirectG(self3, obj2);
   8098   baset* obj3;
   8099   icEqDirectG(self3, obj3);
   8100   bool obj4;
   8101   icEqDirectG(self3, obj4);
   8102   double obj5;
   8103   icEqDirectG(self3, obj5);
   8104   int64_t obj6;
   8105   icEqDirectG(self3, obj6);
   8106   int32_t obj7;
   8107   icEqDirectG(self3, obj7);
   8108   uint32_t obj8;
   8109   icEqDirectG(self3, obj8);
   8110   uint64_t obj9;
   8111   icEqDirectG(self3, obj9);
   8112   smallBoolt* obj10;
   8113   icEqDirectG(self3, obj10);
   8114   smallBytest* obj11;
   8115   icEqDirectG(self3, obj11);
   8116   smallDoublet* obj12;
   8117   icEqDirectG(self3, obj12);
   8118   smallIntt* obj13;
   8119   icEqDirectG(self3, obj13);
   8120   smallJsont* obj14;
   8121   icEqDirectG(self3, obj14);
   8122   smallStringt* obj15;
   8123   icEqDirectG(self3, obj15);
   8124   void * obj16;
   8125   icEqDirectG(self3, obj16);
   8126 }
   8127 {
   8128   char ** self4;
   8129   char obj0;
   8130   icEqDirectG(self4, obj0);
   8131   char ** obj1;
   8132   icEqDirectG(self4, obj1);
   8133   const char ** obj2;
   8134   icEqDirectG(self4, obj2);
   8135   baset* obj3;
   8136   icEqDirectG(self4, obj3);
   8137   bool obj4;
   8138   icEqDirectG(self4, obj4);
   8139   double obj5;
   8140   icEqDirectG(self4, obj5);
   8141   int64_t obj6;
   8142   icEqDirectG(self4, obj6);
   8143   int32_t obj7;
   8144   icEqDirectG(self4, obj7);
   8145   uint32_t obj8;
   8146   icEqDirectG(self4, obj8);
   8147   uint64_t obj9;
   8148   icEqDirectG(self4, obj9);
   8149   smallJsont* obj10;
   8150   icEqDirectG(self4, obj10);
   8151   smallArrayt* obj11;
   8152   icEqDirectG(self4, obj11);
   8153   void * obj12;
   8154   icEqDirectG(self4, obj12);
   8155 }
   8156 {
   8157   const char ** self5;
   8158   char obj0;
   8159   icEqDirectG(self5, obj0);
   8160   char ** obj1;
   8161   icEqDirectG(self5, obj1);
   8162   const char ** obj2;
   8163   icEqDirectG(self5, obj2);
   8164   baset* obj3;
   8165   icEqDirectG(self5, obj3);
   8166   bool obj4;
   8167   icEqDirectG(self5, obj4);
   8168   double obj5;
   8169   icEqDirectG(self5, obj5);
   8170   int64_t obj6;
   8171   icEqDirectG(self5, obj6);
   8172   int32_t obj7;
   8173   icEqDirectG(self5, obj7);
   8174   uint32_t obj8;
   8175   icEqDirectG(self5, obj8);
   8176   uint64_t obj9;
   8177   icEqDirectG(self5, obj9);
   8178   smallJsont* obj10;
   8179   icEqDirectG(self5, obj10);
   8180   smallArrayt* obj11;
   8181   icEqDirectG(self5, obj11);
   8182   void * obj12;
   8183   icEqDirectG(self5, obj12);
   8184 }
   8185 {
   8186   baset* self6;
   8187   char obj0;
   8188   icEqDirectG(self6, obj0);
   8189   char * obj1;
   8190   icEqDirectG(self6, obj1);
   8191   const char * obj2;
   8192   icEqDirectG(self6, obj2);
   8193   char ** obj3;
   8194   icEqDirectG(self6, obj3);
   8195   const char ** obj4;
   8196   icEqDirectG(self6, obj4);
   8197   baset* obj5;
   8198   icEqDirectG(self6, obj5);
   8199   bool obj6;
   8200   icEqDirectG(self6, obj6);
   8201   double obj7;
   8202   icEqDirectG(self6, obj7);
   8203   int64_t obj8;
   8204   icEqDirectG(self6, obj8);
   8205   int32_t obj9;
   8206   icEqDirectG(self6, obj9);
   8207   uint32_t obj10;
   8208   icEqDirectG(self6, obj10);
   8209   uint64_t obj11;
   8210   icEqDirectG(self6, obj11);
   8211   smallArrayt* obj12;
   8212   icEqDirectG(self6, obj12);
   8213   smallBoolt* obj13;
   8214   icEqDirectG(self6, obj13);
   8215   smallBytest* obj14;
   8216   icEqDirectG(self6, obj14);
   8217   smallDoublet* obj15;
   8218   icEqDirectG(self6, obj15);
   8219   smallDictt* obj16;
   8220   icEqDirectG(self6, obj16);
   8221   smallIntt* obj17;
   8222   icEqDirectG(self6, obj17);
   8223   smallJsont* obj18;
   8224   icEqDirectG(self6, obj18);
   8225   smallStringt* obj19;
   8226   icEqDirectG(self6, obj19);
   8227   void * obj20;
   8228   icEqDirectG(self6, obj20);
   8229 }
   8230 {
   8231   bool self7;
   8232   char obj0;
   8233   icEqDirectG(self7, obj0);
   8234   char * obj1;
   8235   icEqDirectG(self7, obj1);
   8236   const char * obj2;
   8237   icEqDirectG(self7, obj2);
   8238   baset* obj3;
   8239   icEqDirectG(self7, obj3);
   8240   bool obj4;
   8241   icEqDirectG(self7, obj4);
   8242   double obj5;
   8243   icEqDirectG(self7, obj5);
   8244   int64_t obj6;
   8245   icEqDirectG(self7, obj6);
   8246   int32_t obj7;
   8247   icEqDirectG(self7, obj7);
   8248   uint32_t obj8;
   8249   icEqDirectG(self7, obj8);
   8250   uint64_t obj9;
   8251   icEqDirectG(self7, obj9);
   8252   smallBoolt* obj10;
   8253   icEqDirectG(self7, obj10);
   8254   smallBytest* obj11;
   8255   icEqDirectG(self7, obj11);
   8256   smallDoublet* obj12;
   8257   icEqDirectG(self7, obj12);
   8258   smallIntt* obj13;
   8259   icEqDirectG(self7, obj13);
   8260   smallJsont* obj14;
   8261   icEqDirectG(self7, obj14);
   8262   smallStringt* obj15;
   8263   icEqDirectG(self7, obj15);
   8264   void * obj16;
   8265   icEqDirectG(self7, obj16);
   8266 }
   8267 {
   8268   double self8;
   8269   char obj0;
   8270   icEqDirectG(self8, obj0);
   8271   char * obj1;
   8272   icEqDirectG(self8, obj1);
   8273   const char * obj2;
   8274   icEqDirectG(self8, obj2);
   8275   baset* obj3;
   8276   icEqDirectG(self8, obj3);
   8277   bool obj4;
   8278   icEqDirectG(self8, obj4);
   8279   double obj5;
   8280   icEqDirectG(self8, obj5);
   8281   int64_t obj6;
   8282   icEqDirectG(self8, obj6);
   8283   int32_t obj7;
   8284   icEqDirectG(self8, obj7);
   8285   uint32_t obj8;
   8286   icEqDirectG(self8, obj8);
   8287   uint64_t obj9;
   8288   icEqDirectG(self8, obj9);
   8289   smallBoolt* obj10;
   8290   icEqDirectG(self8, obj10);
   8291   smallBytest* obj11;
   8292   icEqDirectG(self8, obj11);
   8293   smallDoublet* obj12;
   8294   icEqDirectG(self8, obj12);
   8295   smallIntt* obj13;
   8296   icEqDirectG(self8, obj13);
   8297   smallJsont* obj14;
   8298   icEqDirectG(self8, obj14);
   8299   smallStringt* obj15;
   8300   icEqDirectG(self8, obj15);
   8301   void * obj16;
   8302   icEqDirectG(self8, obj16);
   8303 }
   8304 {
   8305   int64_t self9;
   8306   char obj0;
   8307   icEqDirectG(self9, obj0);
   8308   char * obj1;
   8309   icEqDirectG(self9, obj1);
   8310   const char * obj2;
   8311   icEqDirectG(self9, obj2);
   8312   baset* obj3;
   8313   icEqDirectG(self9, obj3);
   8314   bool obj4;
   8315   icEqDirectG(self9, obj4);
   8316   double obj5;
   8317   icEqDirectG(self9, obj5);
   8318   int64_t obj6;
   8319   icEqDirectG(self9, obj6);
   8320   int32_t obj7;
   8321   icEqDirectG(self9, obj7);
   8322   uint32_t obj8;
   8323   icEqDirectG(self9, obj8);
   8324   uint64_t obj9;
   8325   icEqDirectG(self9, obj9);
   8326   smallBoolt* obj10;
   8327   icEqDirectG(self9, obj10);
   8328   smallBytest* obj11;
   8329   icEqDirectG(self9, obj11);
   8330   smallDoublet* obj12;
   8331   icEqDirectG(self9, obj12);
   8332   smallIntt* obj13;
   8333   icEqDirectG(self9, obj13);
   8334   smallJsont* obj14;
   8335   icEqDirectG(self9, obj14);
   8336   smallStringt* obj15;
   8337   icEqDirectG(self9, obj15);
   8338   void * obj16;
   8339   icEqDirectG(self9, obj16);
   8340 }
   8341 {
   8342   int32_t self10;
   8343   char obj0;
   8344   icEqDirectG(self10, obj0);
   8345   char * obj1;
   8346   icEqDirectG(self10, obj1);
   8347   const char * obj2;
   8348   icEqDirectG(self10, obj2);
   8349   baset* obj3;
   8350   icEqDirectG(self10, obj3);
   8351   bool obj4;
   8352   icEqDirectG(self10, obj4);
   8353   double obj5;
   8354   icEqDirectG(self10, obj5);
   8355   int64_t obj6;
   8356   icEqDirectG(self10, obj6);
   8357   int32_t obj7;
   8358   icEqDirectG(self10, obj7);
   8359   uint32_t obj8;
   8360   icEqDirectG(self10, obj8);
   8361   uint64_t obj9;
   8362   icEqDirectG(self10, obj9);
   8363   smallBoolt* obj10;
   8364   icEqDirectG(self10, obj10);
   8365   smallBytest* obj11;
   8366   icEqDirectG(self10, obj11);
   8367   smallDoublet* obj12;
   8368   icEqDirectG(self10, obj12);
   8369   smallIntt* obj13;
   8370   icEqDirectG(self10, obj13);
   8371   smallJsont* obj14;
   8372   icEqDirectG(self10, obj14);
   8373   smallStringt* obj15;
   8374   icEqDirectG(self10, obj15);
   8375   void * obj16;
   8376   icEqDirectG(self10, obj16);
   8377 }
   8378 {
   8379   uint32_t self11;
   8380   char obj0;
   8381   icEqDirectG(self11, obj0);
   8382   char * obj1;
   8383   icEqDirectG(self11, obj1);
   8384   const char * obj2;
   8385   icEqDirectG(self11, obj2);
   8386   baset* obj3;
   8387   icEqDirectG(self11, obj3);
   8388   bool obj4;
   8389   icEqDirectG(self11, obj4);
   8390   double obj5;
   8391   icEqDirectG(self11, obj5);
   8392   int64_t obj6;
   8393   icEqDirectG(self11, obj6);
   8394   int32_t obj7;
   8395   icEqDirectG(self11, obj7);
   8396   uint32_t obj8;
   8397   icEqDirectG(self11, obj8);
   8398   uint64_t obj9;
   8399   icEqDirectG(self11, obj9);
   8400   smallBoolt* obj10;
   8401   icEqDirectG(self11, obj10);
   8402   smallBytest* obj11;
   8403   icEqDirectG(self11, obj11);
   8404   smallDoublet* obj12;
   8405   icEqDirectG(self11, obj12);
   8406   smallIntt* obj13;
   8407   icEqDirectG(self11, obj13);
   8408   smallJsont* obj14;
   8409   icEqDirectG(self11, obj14);
   8410   smallStringt* obj15;
   8411   icEqDirectG(self11, obj15);
   8412   void * obj16;
   8413   icEqDirectG(self11, obj16);
   8414 }
   8415 {
   8416   uint64_t self12;
   8417   char obj0;
   8418   icEqDirectG(self12, obj0);
   8419   char * obj1;
   8420   icEqDirectG(self12, obj1);
   8421   const char * obj2;
   8422   icEqDirectG(self12, obj2);
   8423   baset* obj3;
   8424   icEqDirectG(self12, obj3);
   8425   bool obj4;
   8426   icEqDirectG(self12, obj4);
   8427   double obj5;
   8428   icEqDirectG(self12, obj5);
   8429   int64_t obj6;
   8430   icEqDirectG(self12, obj6);
   8431   int32_t obj7;
   8432   icEqDirectG(self12, obj7);
   8433   uint32_t obj8;
   8434   icEqDirectG(self12, obj8);
   8435   uint64_t obj9;
   8436   icEqDirectG(self12, obj9);
   8437   smallBoolt* obj10;
   8438   icEqDirectG(self12, obj10);
   8439   smallBytest* obj11;
   8440   icEqDirectG(self12, obj11);
   8441   smallDoublet* obj12;
   8442   icEqDirectG(self12, obj12);
   8443   smallIntt* obj13;
   8444   icEqDirectG(self12, obj13);
   8445   smallJsont* obj14;
   8446   icEqDirectG(self12, obj14);
   8447   smallStringt* obj15;
   8448   icEqDirectG(self12, obj15);
   8449   void * obj16;
   8450   icEqDirectG(self12, obj16);
   8451 }
   8452 {
   8453   smallArrayt* self13;
   8454   char obj0;
   8455   icEqDirectG(self13, obj0);
   8456   char ** obj1;
   8457   icEqDirectG(self13, obj1);
   8458   const char ** obj2;
   8459   icEqDirectG(self13, obj2);
   8460   baset* obj3;
   8461   icEqDirectG(self13, obj3);
   8462   bool obj4;
   8463   icEqDirectG(self13, obj4);
   8464   double obj5;
   8465   icEqDirectG(self13, obj5);
   8466   int64_t obj6;
   8467   icEqDirectG(self13, obj6);
   8468   int32_t obj7;
   8469   icEqDirectG(self13, obj7);
   8470   uint32_t obj8;
   8471   icEqDirectG(self13, obj8);
   8472   uint64_t obj9;
   8473   icEqDirectG(self13, obj9);
   8474   smallJsont* obj10;
   8475   icEqDirectG(self13, obj10);
   8476   smallArrayt* obj11;
   8477   icEqDirectG(self13, obj11);
   8478   void * obj12;
   8479   icEqDirectG(self13, obj12);
   8480 }
   8481 {
   8482   smallBoolt* self14;
   8483   char obj0;
   8484   icEqDirectG(self14, obj0);
   8485   char * obj1;
   8486   icEqDirectG(self14, obj1);
   8487   const char * obj2;
   8488   icEqDirectG(self14, obj2);
   8489   baset* obj3;
   8490   icEqDirectG(self14, obj3);
   8491   bool obj4;
   8492   icEqDirectG(self14, obj4);
   8493   double obj5;
   8494   icEqDirectG(self14, obj5);
   8495   int64_t obj6;
   8496   icEqDirectG(self14, obj6);
   8497   int32_t obj7;
   8498   icEqDirectG(self14, obj7);
   8499   uint32_t obj8;
   8500   icEqDirectG(self14, obj8);
   8501   uint64_t obj9;
   8502   icEqDirectG(self14, obj9);
   8503   smallBoolt* obj10;
   8504   icEqDirectG(self14, obj10);
   8505   smallBytest* obj11;
   8506   icEqDirectG(self14, obj11);
   8507   smallDoublet* obj12;
   8508   icEqDirectG(self14, obj12);
   8509   smallIntt* obj13;
   8510   icEqDirectG(self14, obj13);
   8511   smallJsont* obj14;
   8512   icEqDirectG(self14, obj14);
   8513   smallStringt* obj15;
   8514   icEqDirectG(self14, obj15);
   8515   void * obj16;
   8516   icEqDirectG(self14, obj16);
   8517 }
   8518 {
   8519   smallBytest* self15;
   8520   char obj0;
   8521   icEqDirectG(self15, obj0);
   8522   char * obj1;
   8523   icEqDirectG(self15, obj1);
   8524   const char * obj2;
   8525   icEqDirectG(self15, obj2);
   8526   baset* obj3;
   8527   icEqDirectG(self15, obj3);
   8528   bool obj4;
   8529   icEqDirectG(self15, obj4);
   8530   double obj5;
   8531   icEqDirectG(self15, obj5);
   8532   int64_t obj6;
   8533   icEqDirectG(self15, obj6);
   8534   int32_t obj7;
   8535   icEqDirectG(self15, obj7);
   8536   uint32_t obj8;
   8537   icEqDirectG(self15, obj8);
   8538   uint64_t obj9;
   8539   icEqDirectG(self15, obj9);
   8540   smallBoolt* obj10;
   8541   icEqDirectG(self15, obj10);
   8542   smallBytest* obj11;
   8543   icEqDirectG(self15, obj11);
   8544   smallDoublet* obj12;
   8545   icEqDirectG(self15, obj12);
   8546   smallIntt* obj13;
   8547   icEqDirectG(self15, obj13);
   8548   smallStringt* obj14;
   8549   icEqDirectG(self15, obj14);
   8550   void * obj15;
   8551   icEqDirectG(self15, obj15);
   8552 }
   8553 {
   8554   smallDoublet* self16;
   8555   char obj0;
   8556   icEqDirectG(self16, obj0);
   8557   char * obj1;
   8558   icEqDirectG(self16, obj1);
   8559   const char * obj2;
   8560   icEqDirectG(self16, obj2);
   8561   baset* obj3;
   8562   icEqDirectG(self16, obj3);
   8563   bool obj4;
   8564   icEqDirectG(self16, obj4);
   8565   double obj5;
   8566   icEqDirectG(self16, obj5);
   8567   int64_t obj6;
   8568   icEqDirectG(self16, obj6);
   8569   int32_t obj7;
   8570   icEqDirectG(self16, obj7);
   8571   uint32_t obj8;
   8572   icEqDirectG(self16, obj8);
   8573   uint64_t obj9;
   8574   icEqDirectG(self16, obj9);
   8575   smallBoolt* obj10;
   8576   icEqDirectG(self16, obj10);
   8577   smallBytest* obj11;
   8578   icEqDirectG(self16, obj11);
   8579   smallDoublet* obj12;
   8580   icEqDirectG(self16, obj12);
   8581   smallIntt* obj13;
   8582   icEqDirectG(self16, obj13);
   8583   smallJsont* obj14;
   8584   icEqDirectG(self16, obj14);
   8585   smallStringt* obj15;
   8586   icEqDirectG(self16, obj15);
   8587   void * obj16;
   8588   icEqDirectG(self16, obj16);
   8589 }
   8590 {
   8591   smallDictt* self17;
   8592   char obj0;
   8593   icEqDirectG(self17, obj0);
   8594   baset* obj1;
   8595   icEqDirectG(self17, obj1);
   8596   bool obj2;
   8597   icEqDirectG(self17, obj2);
   8598   double obj3;
   8599   icEqDirectG(self17, obj3);
   8600   int64_t obj4;
   8601   icEqDirectG(self17, obj4);
   8602   int32_t obj5;
   8603   icEqDirectG(self17, obj5);
   8604   uint32_t obj6;
   8605   icEqDirectG(self17, obj6);
   8606   uint64_t obj7;
   8607   icEqDirectG(self17, obj7);
   8608   smallJsont* obj8;
   8609   icEqDirectG(self17, obj8);
   8610   smallDictt* obj9;
   8611   icEqDirectG(self17, obj9);
   8612   void * obj10;
   8613   icEqDirectG(self17, obj10);
   8614 }
   8615 {
   8616   smallIntt* self18;
   8617   char obj0;
   8618   icEqDirectG(self18, obj0);
   8619   char * obj1;
   8620   icEqDirectG(self18, obj1);
   8621   const char * obj2;
   8622   icEqDirectG(self18, obj2);
   8623   baset* obj3;
   8624   icEqDirectG(self18, obj3);
   8625   bool obj4;
   8626   icEqDirectG(self18, obj4);
   8627   double obj5;
   8628   icEqDirectG(self18, obj5);
   8629   int64_t obj6;
   8630   icEqDirectG(self18, obj6);
   8631   int32_t obj7;
   8632   icEqDirectG(self18, obj7);
   8633   uint32_t obj8;
   8634   icEqDirectG(self18, obj8);
   8635   uint64_t obj9;
   8636   icEqDirectG(self18, obj9);
   8637   smallBoolt* obj10;
   8638   icEqDirectG(self18, obj10);
   8639   smallBytest* obj11;
   8640   icEqDirectG(self18, obj11);
   8641   smallDoublet* obj12;
   8642   icEqDirectG(self18, obj12);
   8643   smallIntt* obj13;
   8644   icEqDirectG(self18, obj13);
   8645   smallJsont* obj14;
   8646   icEqDirectG(self18, obj14);
   8647   smallStringt* obj15;
   8648   icEqDirectG(self18, obj15);
   8649   void * obj16;
   8650   icEqDirectG(self18, obj16);
   8651 }
   8652 {
   8653   smallJsont* self19;
   8654   char * obj0;
   8655   icEqDirectG(self19, obj0);
   8656   const char * obj1;
   8657   icEqDirectG(self19, obj1);
   8658   char obj2;
   8659   icEqDirectG(self19, obj2);
   8660   char ** obj3;
   8661   icEqDirectG(self19, obj3);
   8662   const char ** obj4;
   8663   icEqDirectG(self19, obj4);
   8664   baset* obj5;
   8665   icEqDirectG(self19, obj5);
   8666   bool obj6;
   8667   icEqDirectG(self19, obj6);
   8668   double obj7;
   8669   icEqDirectG(self19, obj7);
   8670   int64_t obj8;
   8671   icEqDirectG(self19, obj8);
   8672   int32_t obj9;
   8673   icEqDirectG(self19, obj9);
   8674   uint32_t obj10;
   8675   icEqDirectG(self19, obj10);
   8676   uint64_t obj11;
   8677   icEqDirectG(self19, obj11);
   8678   smallArrayt* obj12;
   8679   icEqDirectG(self19, obj12);
   8680   smallBoolt* obj13;
   8681   icEqDirectG(self19, obj13);
   8682   smallBytest* obj14;
   8683   icEqDirectG(self19, obj14);
   8684   smallDictt* obj15;
   8685   icEqDirectG(self19, obj15);
   8686   smallDoublet* obj16;
   8687   icEqDirectG(self19, obj16);
   8688   smallIntt* obj17;
   8689   icEqDirectG(self19, obj17);
   8690   smallJsont* obj18;
   8691   icEqDirectG(self19, obj18);
   8692   smallStringt* obj19;
   8693   icEqDirectG(self19, obj19);
   8694   void * obj20;
   8695   icEqDirectG(self19, obj20);
   8696 }
   8697 {
   8698   smallStringt* self20;
   8699   char * obj0;
   8700   icEqDirectG(self20, obj0);
   8701   const char * obj1;
   8702   icEqDirectG(self20, obj1);
   8703   char obj2;
   8704   icEqDirectG(self20, obj2);
   8705   baset* obj3;
   8706   icEqDirectG(self20, obj3);
   8707   bool obj4;
   8708   icEqDirectG(self20, obj4);
   8709   double obj5;
   8710   icEqDirectG(self20, obj5);
   8711   int64_t obj6;
   8712   icEqDirectG(self20, obj6);
   8713   int32_t obj7;
   8714   icEqDirectG(self20, obj7);
   8715   uint32_t obj8;
   8716   icEqDirectG(self20, obj8);
   8717   uint64_t obj9;
   8718   icEqDirectG(self20, obj9);
   8719   smallBoolt* obj10;
   8720   icEqDirectG(self20, obj10);
   8721   smallBytest* obj11;
   8722   icEqDirectG(self20, obj11);
   8723   smallDoublet* obj12;
   8724   icEqDirectG(self20, obj12);
   8725   smallIntt* obj13;
   8726   icEqDirectG(self20, obj13);
   8727   smallJsont* obj14;
   8728   icEqDirectG(self20, obj14);
   8729   smallStringt* obj15;
   8730   icEqDirectG(self20, obj15);
   8731   void * obj16;
   8732   icEqDirectG(self20, obj16);
   8733 }
   8734 {
   8735   char * self1;
   8736   char * obj0;
   8737   int64_t index1;
   8738   eqIG(self1, obj0, index1);
   8739   const char * obj1;
   8740   eqIG(self1, obj1, index1);
   8741   char obj2;
   8742   eqIG(self1, obj2, index1);
   8743   int obj3;
   8744   eqIG(self1, obj3, index1);
   8745   const char * obj5;
   8746   int64_t index0;
   8747   eqIG(self1, obj5, index0);
   8748 }
   8749 {
   8750   const char * self2;
   8751   char * obj0;
   8752   int64_t index1;
   8753   eqIG(self2, obj0, index1);
   8754   const char * obj1;
   8755   eqIG(self2, obj1, index1);
   8756   char obj2;
   8757   eqIG(self2, obj2, index1);
   8758   int obj3;
   8759   eqIG(self2, obj3, index1);
   8760   const char * obj10;
   8761   int64_t index0;
   8762   eqIG(self2, obj10, index0);
   8763 }
   8764 {
   8765   smallJsont * self3;
   8766   char * obj0;
   8767   int64_t index1;
   8768   eqIG(self3, obj0, index1);
   8769   const char * obj1;
   8770   eqIG(self3, obj1, index1);
   8771   char obj2;
   8772   eqIG(self3, obj2, index1);
   8773   int obj3;
   8774   eqIG(self3, obj3, index1);
   8775   smallJsont * obj4;
   8776   eqIG(self3, obj4, index1);
   8777   smallStringt * obj5;
   8778   eqIG(self3, obj5, index1);
   8779   const char * obj17;
   8780   int64_t index0;
   8781   eqIG(self3, obj17, index0);
   8782 }
   8783 {
   8784   smallStringt * self4;
   8785   char * obj0;
   8786   int64_t index1;
   8787   eqIG(self4, obj0, index1);
   8788   const char * obj1;
   8789   eqIG(self4, obj1, index1);
   8790   char obj2;
   8791   eqIG(self4, obj2, index1);
   8792   int obj3;
   8793   eqIG(self4, obj3, index1);
   8794   smallJsont * obj4;
   8795   eqIG(self4, obj4, index1);
   8796   smallStringt * obj5;
   8797   eqIG(self4, obj5, index1);
   8798   const char * obj24;
   8799   int64_t index0;
   8800   eqIG(self4, obj24, index0);
   8801 }
   8802 {
   8803   char * self1;
   8804   char * obj0;
   8805   startsWithG(self1, obj0);
   8806   const char * obj1;
   8807   startsWithG(self1, obj1);
   8808   char obj2;
   8809   startsWithG(self1, obj2);
   8810   int obj3;
   8811   startsWithG(self1, obj3);
   8812   const char * obj4;
   8813   startsWithG(self1, obj4);
   8814 }
   8815 {
   8816   const char * self2;
   8817   char * obj0;
   8818   startsWithG(self2, obj0);
   8819   const char * obj1;
   8820   startsWithG(self2, obj1);
   8821   char obj2;
   8822   startsWithG(self2, obj2);
   8823   int obj3;
   8824   startsWithG(self2, obj3);
   8825   const char * obj4;
   8826   startsWithG(self2, obj4);
   8827 }
   8828 {
   8829   smallJsont * self3;
   8830   char * obj0;
   8831   startsWithG(self3, obj0);
   8832   const char * obj1;
   8833   startsWithG(self3, obj1);
   8834   char obj2;
   8835   startsWithG(self3, obj2);
   8836   int obj3;
   8837   startsWithG(self3, obj3);
   8838   smallJsont * obj4;
   8839   startsWithG(self3, obj4);
   8840   smallStringt * obj5;
   8841   startsWithG(self3, obj5);
   8842 }
   8843 {
   8844   smallStringt * self4;
   8845   char * obj0;
   8846   startsWithG(self4, obj0);
   8847   const char * obj1;
   8848   startsWithG(self4, obj1);
   8849   char obj2;
   8850   startsWithG(self4, obj2);
   8851   int obj3;
   8852   startsWithG(self4, obj3);
   8853   smallJsont * obj4;
   8854   startsWithG(self4, obj4);
   8855   smallStringt * obj5;
   8856   startsWithG(self4, obj5);
   8857 }
   8858 {
   8859   char * self1;
   8860   char * obj0;
   8861   endsWithG(self1, obj0);
   8862   const char * obj1;
   8863   endsWithG(self1, obj1);
   8864   char obj2;
   8865   endsWithG(self1, obj2);
   8866   int obj3;
   8867   endsWithG(self1, obj3);
   8868   const char * obj4;
   8869   endsWithG(self1, obj4);
   8870 }
   8871 {
   8872   const char * self2;
   8873   char * obj0;
   8874   endsWithG(self2, obj0);
   8875   const char * obj1;
   8876   endsWithG(self2, obj1);
   8877   char obj2;
   8878   endsWithG(self2, obj2);
   8879   int obj3;
   8880   endsWithG(self2, obj3);
   8881   const char * obj4;
   8882   endsWithG(self2, obj4);
   8883 }
   8884 {
   8885   smallJsont * self3;
   8886   char * obj0;
   8887   endsWithG(self3, obj0);
   8888   const char * obj1;
   8889   endsWithG(self3, obj1);
   8890   char obj2;
   8891   endsWithG(self3, obj2);
   8892   int obj3;
   8893   endsWithG(self3, obj3);
   8894   smallJsont * obj4;
   8895   endsWithG(self3, obj4);
   8896   smallStringt * obj5;
   8897   endsWithG(self3, obj5);
   8898 }
   8899 {
   8900   smallStringt * self4;
   8901   char * obj0;
   8902   endsWithG(self4, obj0);
   8903   const char * obj1;
   8904   endsWithG(self4, obj1);
   8905   char obj2;
   8906   endsWithG(self4, obj2);
   8907   int obj3;
   8908   endsWithG(self4, obj3);
   8909   smallJsont * obj4;
   8910   endsWithG(self4, obj4);
   8911   smallStringt * obj5;
   8912   endsWithG(self4, obj5);
   8913 }
   8914 {
   8915   char * self1;
   8916   char * obj0;
   8917   countG(self1, obj0);
   8918   const char * obj1;
   8919   countG(self1, obj1);
   8920   char obj2;
   8921   countG(self1, obj2);
   8922   int obj3;
   8923   countG(self1, obj3);
   8924   const char * obj4;
   8925   countG(self1, obj4);
   8926 }
   8927 {
   8928   const char * self2;
   8929   char * obj0;
   8930   countG(self2, obj0);
   8931   const char * obj1;
   8932   countG(self2, obj1);
   8933   char obj2;
   8934   countG(self2, obj2);
   8935   int obj3;
   8936   countG(self2, obj3);
   8937   const char * obj4;
   8938   countG(self2, obj4);
   8939 }
   8940 {
   8941   smallJsont * self3;
   8942   char * obj0;
   8943   countG(self3, obj0);
   8944   const char * obj1;
   8945   countG(self3, obj1);
   8946   char obj2;
   8947   countG(self3, obj2);
   8948   int obj3;
   8949   countG(self3, obj3);
   8950   smallJsont * obj4;
   8951   countG(self3, obj4);
   8952   smallStringt * obj5;
   8953   countG(self3, obj5);
   8954 }
   8955 {
   8956   smallStringt * self4;
   8957   char * obj0;
   8958   countG(self4, obj0);
   8959   const char * obj1;
   8960   countG(self4, obj1);
   8961   char obj2;
   8962   countG(self4, obj2);
   8963   int obj3;
   8964   countG(self4, obj3);
   8965   smallJsont * obj4;
   8966   countG(self4, obj4);
   8967   smallStringt * obj5;
   8968   countG(self4, obj5);
   8969 }
   8970 {
   8971   char * self1;
   8972   char * obj0;
   8973   icStartsWithG(self1, obj0);
   8974   const char * obj1;
   8975   icStartsWithG(self1, obj1);
   8976   char obj2;
   8977   icStartsWithG(self1, obj2);
   8978   int obj3;
   8979   icStartsWithG(self1, obj3);
   8980   const char * obj4;
   8981   icStartsWithG(self1, obj4);
   8982 }
   8983 {
   8984   const char * self2;
   8985   char * obj0;
   8986   icStartsWithG(self2, obj0);
   8987   const char * obj1;
   8988   icStartsWithG(self2, obj1);
   8989   char obj2;
   8990   icStartsWithG(self2, obj2);
   8991   int obj3;
   8992   icStartsWithG(self2, obj3);
   8993   const char * obj4;
   8994   icStartsWithG(self2, obj4);
   8995 }
   8996 {
   8997   smallJsont * self3;
   8998   char * obj0;
   8999   icStartsWithG(self3, obj0);
   9000   const char * obj1;
   9001   icStartsWithG(self3, obj1);
   9002   char obj2;
   9003   icStartsWithG(self3, obj2);
   9004   int obj3;
   9005   icStartsWithG(self3, obj3);
   9006   smallJsont * obj4;
   9007   icStartsWithG(self3, obj4);
   9008   smallStringt * obj5;
   9009   icStartsWithG(self3, obj5);
   9010 }
   9011 {
   9012   smallStringt * self4;
   9013   char * obj0;
   9014   icStartsWithG(self4, obj0);
   9015   const char * obj1;
   9016   icStartsWithG(self4, obj1);
   9017   char obj2;
   9018   icStartsWithG(self4, obj2);
   9019   int obj3;
   9020   icStartsWithG(self4, obj3);
   9021   smallJsont * obj4;
   9022   icStartsWithG(self4, obj4);
   9023   smallStringt * obj5;
   9024   icStartsWithG(self4, obj5);
   9025 }
   9026 {
   9027   char * self1;
   9028   char * obj0;
   9029   icEndsWithG(self1, obj0);
   9030   const char * obj1;
   9031   icEndsWithG(self1, obj1);
   9032   char obj2;
   9033   icEndsWithG(self1, obj2);
   9034   int obj3;
   9035   icEndsWithG(self1, obj3);
   9036   const char * obj4;
   9037   icEndsWithG(self1, obj4);
   9038 }
   9039 {
   9040   const char * self2;
   9041   char * obj0;
   9042   icEndsWithG(self2, obj0);
   9043   const char * obj1;
   9044   icEndsWithG(self2, obj1);
   9045   char obj2;
   9046   icEndsWithG(self2, obj2);
   9047   int obj3;
   9048   icEndsWithG(self2, obj3);
   9049   const char * obj4;
   9050   icEndsWithG(self2, obj4);
   9051 }
   9052 {
   9053   smallJsont * self3;
   9054   char * obj0;
   9055   icEndsWithG(self3, obj0);
   9056   const char * obj1;
   9057   icEndsWithG(self3, obj1);
   9058   char obj2;
   9059   icEndsWithG(self3, obj2);
   9060   int obj3;
   9061   icEndsWithG(self3, obj3);
   9062   smallJsont * obj4;
   9063   icEndsWithG(self3, obj4);
   9064   smallStringt * obj5;
   9065   icEndsWithG(self3, obj5);
   9066 }
   9067 {
   9068   smallStringt * self4;
   9069   char * obj0;
   9070   icEndsWithG(self4, obj0);
   9071   const char * obj1;
   9072   icEndsWithG(self4, obj1);
   9073   char obj2;
   9074   icEndsWithG(self4, obj2);
   9075   int obj3;
   9076   icEndsWithG(self4, obj3);
   9077   smallJsont * obj4;
   9078   icEndsWithG(self4, obj4);
   9079   smallStringt * obj5;
   9080   icEndsWithG(self4, obj5);
   9081 }
   9082 {
   9083   char * self1;
   9084   char * obj0;
   9085   icCountG(self1, obj0);
   9086   const char * obj1;
   9087   icCountG(self1, obj1);
   9088   char obj2;
   9089   icCountG(self1, obj2);
   9090   int obj3;
   9091   icCountG(self1, obj3);
   9092   const char * obj4;
   9093   icCountG(self1, obj4);
   9094 }
   9095 {
   9096   const char * self2;
   9097   char * obj0;
   9098   icCountG(self2, obj0);
   9099   const char * obj1;
   9100   icCountG(self2, obj1);
   9101   char obj2;
   9102   icCountG(self2, obj2);
   9103   int obj3;
   9104   icCountG(self2, obj3);
   9105   const char * obj4;
   9106   icCountG(self2, obj4);
   9107 }
   9108 {
   9109   smallJsont * self3;
   9110   char * obj0;
   9111   icCountG(self3, obj0);
   9112   const char * obj1;
   9113   icCountG(self3, obj1);
   9114   char obj2;
   9115   icCountG(self3, obj2);
   9116   int obj3;
   9117   icCountG(self3, obj3);
   9118   smallJsont * obj4;
   9119   icCountG(self3, obj4);
   9120   smallStringt * obj5;
   9121   icCountG(self3, obj5);
   9122 }
   9123 {
   9124   smallStringt * self4;
   9125   char * obj0;
   9126   icCountG(self4, obj0);
   9127   const char * obj1;
   9128   icCountG(self4, obj1);
   9129   char obj2;
   9130   icCountG(self4, obj2);
   9131   int obj3;
   9132   icCountG(self4, obj3);
   9133   smallJsont * obj4;
   9134   icCountG(self4, obj4);
   9135   smallStringt * obj5;
   9136   icCountG(self4, obj5);
   9137 }
   9138 {
   9139   char * self0;
   9140   isNumberG(self0);
   9141   const char * self1;
   9142   isNumberG(self1);
   9143   smallJsont * self2;
   9144   isNumberG(self2);
   9145   smallStringt * self3;
   9146   isNumberG(self3);
   9147 }
   9148 {
   9149   char * self0;
   9150   isIntG(self0);
   9151   const char * self1;
   9152   isIntG(self1);
   9153   smallJsont * self2;
   9154   isIntG(self2);
   9155   smallStringt * self3;
   9156   isIntG(self3);
   9157 }
   9158 {
   9159   char self0;
   9160   parseIntG(self0);
   9161   int self1;
   9162   parseIntG(self1);
   9163   char * self2;
   9164   parseIntG(self2);
   9165   const char * self3;
   9166   parseIntG(self3);
   9167   smallJsont * self4;
   9168   parseIntG(self4);
   9169   smallStringt * self5;
   9170   parseIntG(self5);
   9171 }
   9172 {
   9173   char * self1;
   9174   int64_t n0;
   9175   intToG(self1, n0);
   9176 }
   9177 {
   9178   smallJsont * self2;
   9179   int64_t n0;
   9180   intToG(self2, n0);
   9181 }
   9182 {
   9183   smallStringt * self3;
   9184   int64_t n0;
   9185   intToG(self3, n0);
   9186 }
   9187 {
   9188   char self0;
   9189   parseDoubleG(self0);
   9190   int self1;
   9191   parseDoubleG(self1);
   9192   char * self2;
   9193   parseDoubleG(self2);
   9194   const char * self3;
   9195   parseDoubleG(self3);
   9196   smallJsont * self4;
   9197   parseDoubleG(self4);
   9198   smallStringt * self5;
   9199   parseDoubleG(self5);
   9200 }
   9201 {
   9202   char * self1;
   9203   double n0;
   9204   doubleToG(self1, n0);
   9205 }
   9206 {
   9207   smallJsont * self2;
   9208   double n0;
   9209   doubleToG(self2, n0);
   9210 }
   9211 {
   9212   smallStringt * self3;
   9213   double n0;
   9214   doubleToG(self3, n0);
   9215 }
   9216 {
   9217   char * self0;
   9218   lenG(self0);
   9219   const char * self1;
   9220   lenG(self1);
   9221   char ** self2;
   9222   lenG(self2);
   9223   const char ** self3;
   9224   lenG(self3);
   9225   smallArrayt * self4;
   9226   lenG(self4);
   9227   smallBytest * self5;
   9228   lenG(self5);
   9229   smallDictt * self6;
   9230   lenG(self6);
   9231   smallJsont * self7;
   9232   lenG(self7);
   9233   smallStringt * self8;
   9234   lenG(self8);
   9235 }
   9236 {
   9237   char * self0;
   9238   upperG(self0);
   9239   const char * self1;
   9240   upperG(self1);
   9241   char ** self2;
   9242   upperG(self2);
   9243   smallJsont * self3;
   9244   upperG(self3);
   9245   smallStringt * self4;
   9246   upperG(self4);
   9247 }
   9248 {
   9249   char * self0;
   9250   lowerG(self0);
   9251   const char * self1;
   9252   lowerG(self1);
   9253   char ** self2;
   9254   lowerG(self2);
   9255   smallJsont * self3;
   9256   lowerG(self3);
   9257   smallStringt * self4;
   9258   lowerG(self4);
   9259 }
   9260 {
   9261   char * self0;
   9262   trimG(self0);
   9263   const char * self1;
   9264   trimG(self1);
   9265   char ** self2;
   9266   trimG(self2);
   9267   smallArrayt * self3;
   9268   trimG(self3);
   9269   smallDictt * self4;
   9270   trimG(self4);
   9271   smallJsont * self5;
   9272   trimG(self5);
   9273   smallStringt * self6;
   9274   trimG(self6);
   9275 }
   9276 {
   9277   char * self0;
   9278   lTrimG(self0);
   9279   const char * self1;
   9280   lTrimG(self1);
   9281   char ** self2;
   9282   lTrimG(self2);
   9283   smallJsont * self3;
   9284   lTrimG(self3);
   9285   smallStringt * self4;
   9286   lTrimG(self4);
   9287 }
   9288 {
   9289   char * self0;
   9290   rTrimG(self0);
   9291   const char * self1;
   9292   rTrimG(self1);
   9293   char ** self2;
   9294   rTrimG(self2);
   9295   smallJsont * self3;
   9296   rTrimG(self3);
   9297   smallStringt * self4;
   9298   rTrimG(self4);
   9299 }
   9300 {
   9301   char * self1;
   9302   char c0;
   9303   uniqG(self1, c0);
   9304 }
   9305 {
   9306   const char * self2;
   9307   char c0;
   9308   uniqG(self2, c0);
   9309 }
   9310 {
   9311   char ** self3;
   9312   char c0;
   9313   uniqG(self3, c0);
   9314 }
   9315 {
   9316   char *** self4;
   9317   int c0;
   9318   uniqG(self4, c0);
   9319 }
   9320 {
   9321   smallArrayt * self5;
   9322   int c0;
   9323   uniqG(self5, c0);
   9324 }
   9325 {
   9326   smallJsont * self6;
   9327   char c0;
   9328   uniqG(self6, c0);
   9329 }
   9330 {
   9331   smallStringt * self7;
   9332   char c0;
   9333   uniqG(self7, c0);
   9334 }
   9335 {
   9336   char * self1;
   9337   char c0;
   9338   icUniqG(self1, c0);
   9339 }
   9340 {
   9341   const char * self2;
   9342   char c0;
   9343   icUniqG(self2, c0);
   9344 }
   9345 {
   9346   char ** self3;
   9347   char c0;
   9348   icUniqG(self3, c0);
   9349 }
   9350 {
   9351   char *** self4;
   9352   int c0;
   9353   icUniqG(self4, c0);
   9354 }
   9355 {
   9356   smallArrayt * self5;
   9357   int c0;
   9358   icUniqG(self5, c0);
   9359 }
   9360 {
   9361   smallJsont * self6;
   9362   char c0;
   9363   icUniqG(self6, c0);
   9364 }
   9365 {
   9366   smallStringt * self7;
   9367   char c0;
   9368   icUniqG(self7, c0);
   9369 }
   9370 {
   9371   char * self1;
   9372   int64_t start1;
   9373   int64_t end0;
   9374   sliceG(self1, start1, end0);
   9375 }
   9376 {
   9377   const char * self2;
   9378   int64_t start2;
   9379   int64_t end0;
   9380   sliceG(self2, start2, end0);
   9381 }
   9382 {
   9383   char ** self3;
   9384   int64_t start3;
   9385   int64_t end0;
   9386   sliceG(self3, start3, end0);
   9387 }
   9388 {
   9389   char *** self4;
   9390   int64_t start4;
   9391   int64_t end0;
   9392   sliceG(self4, start4, end0);
   9393 }
   9394 {
   9395   smallArrayt * self5;
   9396   int64_t start5;
   9397   int64_t end0;
   9398   sliceG(self5, start5, end0);
   9399 }
   9400 {
   9401   smallJsont * self6;
   9402   int64_t start6;
   9403   int64_t end0;
   9404   sliceG(self6, start6, end0);
   9405 }
   9406 {
   9407   smallStringt * self7;
   9408   int64_t start7;
   9409   int64_t end0;
   9410   sliceG(self7, start7, end0);
   9411 }
   9412 {
   9413   char * self1;
   9414   int64_t start1;
   9415   int64_t end0;
   9416   cropG(self1, start1, end0);
   9417 }
   9418 {
   9419   char ** self2;
   9420   int64_t start2;
   9421   int64_t end0;
   9422   cropG(self2, start2, end0);
   9423 }
   9424 {
   9425   char *** self3;
   9426   int64_t start3;
   9427   int64_t end0;
   9428   cropG(self3, start3, end0);
   9429 }
   9430 {
   9431   smallArrayt * self4;
   9432   int64_t start4;
   9433   int64_t end0;
   9434   cropG(self4, start4, end0);
   9435 }
   9436 {
   9437   smallJsont * self5;
   9438   int64_t start5;
   9439   int64_t end0;
   9440   cropG(self5, start5, end0);
   9441 }
   9442 {
   9443   smallStringt * self6;
   9444   int64_t start6;
   9445   int64_t end0;
   9446   cropG(self6, start6, end0);
   9447 }
   9448 {
   9449   smallDictt* self1;
   9450   char * index1;
   9451   baset* returnType0;
   9452   cropElemG(self1, returnType0, index1);
   9453   undefinedt* returnType1;
   9454   cropElemG(self1, returnType1, index1);
   9455   bool returnType2;
   9456   cropElemG(self1, returnType2, index1);
   9457   double returnType3;
   9458   cropElemG(self1, returnType3, index1);
   9459   int64_t returnType4;
   9460   cropElemG(self1, returnType4, index1);
   9461   int32_t returnType5;
   9462   cropElemG(self1, returnType5, index1);
   9463   uint64_t returnType6;
   9464   cropElemG(self1, returnType6, index1);
   9465   uint32_t returnType7;
   9466   cropElemG(self1, returnType7, index1);
   9467   char* returnType8;
   9468   cropElemG(self1, returnType8, index1);
   9469   smallDictt* returnType9;
   9470   cropElemG(self1, returnType9, index1);
   9471   smallArrayt* returnType10;
   9472   cropElemG(self1, returnType10, index1);
   9473   smallBoolt* returnType11;
   9474   cropElemG(self1, returnType11, index1);
   9475   smallBytest* returnType12;
   9476   cropElemG(self1, returnType12, index1);
   9477   smallDoublet* returnType13;
   9478   cropElemG(self1, returnType13, index1);
   9479   smallIntt* returnType14;
   9480   cropElemG(self1, returnType14, index1);
   9481   smallJsont* returnType15;
   9482   cropElemG(self1, returnType15, index1);
   9483   smallStringt* returnType16;
   9484   cropElemG(self1, returnType16, index1);
   9485   void* returnType17;
   9486   cropElemG(self1, returnType17, index1);
   9487   smallContainert* returnType18;
   9488   cropElemG(self1, returnType18, index1);
   9489   smallDictt * returnType19;
   9490   cropElemG(self1, returnType19, index1);
   9491 }
   9492 {
   9493   smallDictt* self1;
   9494   const char * index2;
   9495   baset* returnType0;
   9496   cropElemG(self1, returnType0, index2);
   9497   undefinedt* returnType1;
   9498   cropElemG(self1, returnType1, index2);
   9499   bool returnType2;
   9500   cropElemG(self1, returnType2, index2);
   9501   double returnType3;
   9502   cropElemG(self1, returnType3, index2);
   9503   int64_t returnType4;
   9504   cropElemG(self1, returnType4, index2);
   9505   int32_t returnType5;
   9506   cropElemG(self1, returnType5, index2);
   9507   uint64_t returnType6;
   9508   cropElemG(self1, returnType6, index2);
   9509   uint32_t returnType7;
   9510   cropElemG(self1, returnType7, index2);
   9511   char* returnType8;
   9512   cropElemG(self1, returnType8, index2);
   9513   smallDictt* returnType9;
   9514   cropElemG(self1, returnType9, index2);
   9515   smallArrayt* returnType10;
   9516   cropElemG(self1, returnType10, index2);
   9517   smallBoolt* returnType11;
   9518   cropElemG(self1, returnType11, index2);
   9519   smallBytest* returnType12;
   9520   cropElemG(self1, returnType12, index2);
   9521   smallDoublet* returnType13;
   9522   cropElemG(self1, returnType13, index2);
   9523   smallIntt* returnType14;
   9524   cropElemG(self1, returnType14, index2);
   9525   smallJsont* returnType15;
   9526   cropElemG(self1, returnType15, index2);
   9527   smallStringt* returnType16;
   9528   cropElemG(self1, returnType16, index2);
   9529   void* returnType17;
   9530   cropElemG(self1, returnType17, index2);
   9531   smallContainert* returnType18;
   9532   cropElemG(self1, returnType18, index2);
   9533   smallDictt * returnType19;
   9534   cropElemG(self1, returnType19, index2);
   9535 }
   9536 {
   9537   smallDictt* self1;
   9538   const char* index0;
   9539   smallDictt * returnType0;
   9540   cropElemG(self1, returnType0, index0);
   9541 }
   9542 {
   9543   smallJsont* self2;
   9544   char * index4;
   9545   baset* returnType0;
   9546   cropElemG(self2, returnType0, index4);
   9547   undefinedt* returnType1;
   9548   cropElemG(self2, returnType1, index4);
   9549   bool returnType2;
   9550   cropElemG(self2, returnType2, index4);
   9551   double returnType3;
   9552   cropElemG(self2, returnType3, index4);
   9553   int64_t returnType4;
   9554   cropElemG(self2, returnType4, index4);
   9555   int32_t returnType5;
   9556   cropElemG(self2, returnType5, index4);
   9557   uint64_t returnType6;
   9558   cropElemG(self2, returnType6, index4);
   9559   uint32_t returnType7;
   9560   cropElemG(self2, returnType7, index4);
   9561   char* returnType8;
   9562   cropElemG(self2, returnType8, index4);
   9563   smallDictt* returnType9;
   9564   cropElemG(self2, returnType9, index4);
   9565   smallArrayt* returnType10;
   9566   cropElemG(self2, returnType10, index4);
   9567   smallBoolt* returnType11;
   9568   cropElemG(self2, returnType11, index4);
   9569   smallBytest* returnType12;
   9570   cropElemG(self2, returnType12, index4);
   9571   smallDoublet* returnType13;
   9572   cropElemG(self2, returnType13, index4);
   9573   smallIntt* returnType14;
   9574   cropElemG(self2, returnType14, index4);
   9575   smallJsont* returnType15;
   9576   cropElemG(self2, returnType15, index4);
   9577   smallStringt* returnType16;
   9578   cropElemG(self2, returnType16, index4);
   9579   void* returnType17;
   9580   cropElemG(self2, returnType17, index4);
   9581   smallContainert* returnType18;
   9582   cropElemG(self2, returnType18, index4);
   9583   smallJsont * returnType19;
   9584   cropElemG(self2, returnType19, index4);
   9585 }
   9586 {
   9587   smallJsont* self2;
   9588   const char * index5;
   9589   baset* returnType0;
   9590   cropElemG(self2, returnType0, index5);
   9591   undefinedt* returnType1;
   9592   cropElemG(self2, returnType1, index5);
   9593   bool returnType2;
   9594   cropElemG(self2, returnType2, index5);
   9595   double returnType3;
   9596   cropElemG(self2, returnType3, index5);
   9597   int64_t returnType4;
   9598   cropElemG(self2, returnType4, index5);
   9599   int32_t returnType5;
   9600   cropElemG(self2, returnType5, index5);
   9601   uint64_t returnType6;
   9602   cropElemG(self2, returnType6, index5);
   9603   uint32_t returnType7;
   9604   cropElemG(self2, returnType7, index5);
   9605   char* returnType8;
   9606   cropElemG(self2, returnType8, index5);
   9607   smallDictt* returnType9;
   9608   cropElemG(self2, returnType9, index5);
   9609   smallArrayt* returnType10;
   9610   cropElemG(self2, returnType10, index5);
   9611   smallBoolt* returnType11;
   9612   cropElemG(self2, returnType11, index5);
   9613   smallBytest* returnType12;
   9614   cropElemG(self2, returnType12, index5);
   9615   smallDoublet* returnType13;
   9616   cropElemG(self2, returnType13, index5);
   9617   smallIntt* returnType14;
   9618   cropElemG(self2, returnType14, index5);
   9619   smallJsont* returnType15;
   9620   cropElemG(self2, returnType15, index5);
   9621   smallStringt* returnType16;
   9622   cropElemG(self2, returnType16, index5);
   9623   void* returnType17;
   9624   cropElemG(self2, returnType17, index5);
   9625   smallContainert* returnType18;
   9626   cropElemG(self2, returnType18, index5);
   9627   smallJsont * returnType19;
   9628   cropElemG(self2, returnType19, index5);
   9629 }
   9630 {
   9631   smallJsont* self2;
   9632   int64_t index6;
   9633   baset* returnType0;
   9634   cropElemG(self2, returnType0, index6);
   9635   undefinedt* returnType1;
   9636   cropElemG(self2, returnType1, index6);
   9637   bool returnType2;
   9638   cropElemG(self2, returnType2, index6);
   9639   double returnType3;
   9640   cropElemG(self2, returnType3, index6);
   9641   int64_t returnType4;
   9642   cropElemG(self2, returnType4, index6);
   9643   int32_t returnType5;
   9644   cropElemG(self2, returnType5, index6);
   9645   uint64_t returnType6;
   9646   cropElemG(self2, returnType6, index6);
   9647   uint32_t returnType7;
   9648   cropElemG(self2, returnType7, index6);
   9649   char* returnType8;
   9650   cropElemG(self2, returnType8, index6);
   9651   smallDictt* returnType9;
   9652   cropElemG(self2, returnType9, index6);
   9653   smallArrayt* returnType10;
   9654   cropElemG(self2, returnType10, index6);
   9655   smallBoolt* returnType11;
   9656   cropElemG(self2, returnType11, index6);
   9657   smallBytest* returnType12;
   9658   cropElemG(self2, returnType12, index6);
   9659   smallDoublet* returnType13;
   9660   cropElemG(self2, returnType13, index6);
   9661   smallIntt* returnType14;
   9662   cropElemG(self2, returnType14, index6);
   9663   smallJsont* returnType15;
   9664   cropElemG(self2, returnType15, index6);
   9665   smallStringt* returnType16;
   9666   cropElemG(self2, returnType16, index6);
   9667   void* returnType17;
   9668   cropElemG(self2, returnType17, index6);
   9669   smallContainert* returnType18;
   9670   cropElemG(self2, returnType18, index6);
   9671   smallJsont * returnType19;
   9672   cropElemG(self2, returnType19, index6);
   9673 }
   9674 {
   9675   smallJsont* self2;
   9676   int32_t index7;
   9677   baset* returnType0;
   9678   cropElemG(self2, returnType0, index7);
   9679   undefinedt* returnType1;
   9680   cropElemG(self2, returnType1, index7);
   9681   bool returnType2;
   9682   cropElemG(self2, returnType2, index7);
   9683   double returnType3;
   9684   cropElemG(self2, returnType3, index7);
   9685   int64_t returnType4;
   9686   cropElemG(self2, returnType4, index7);
   9687   int32_t returnType5;
   9688   cropElemG(self2, returnType5, index7);
   9689   uint64_t returnType6;
   9690   cropElemG(self2, returnType6, index7);
   9691   uint32_t returnType7;
   9692   cropElemG(self2, returnType7, index7);
   9693   char* returnType8;
   9694   cropElemG(self2, returnType8, index7);
   9695   smallDictt* returnType9;
   9696   cropElemG(self2, returnType9, index7);
   9697   smallArrayt* returnType10;
   9698   cropElemG(self2, returnType10, index7);
   9699   smallBoolt* returnType11;
   9700   cropElemG(self2, returnType11, index7);
   9701   smallBytest* returnType12;
   9702   cropElemG(self2, returnType12, index7);
   9703   smallDoublet* returnType13;
   9704   cropElemG(self2, returnType13, index7);
   9705   smallIntt* returnType14;
   9706   cropElemG(self2, returnType14, index7);
   9707   smallJsont* returnType15;
   9708   cropElemG(self2, returnType15, index7);
   9709   smallStringt* returnType16;
   9710   cropElemG(self2, returnType16, index7);
   9711   void* returnType17;
   9712   cropElemG(self2, returnType17, index7);
   9713   smallContainert* returnType18;
   9714   cropElemG(self2, returnType18, index7);
   9715   smallJsont * returnType19;
   9716   cropElemG(self2, returnType19, index7);
   9717 }
   9718 {
   9719   smallJsont* self2;
   9720   int16_t index8;
   9721   baset* returnType0;
   9722   cropElemG(self2, returnType0, index8);
   9723   undefinedt* returnType1;
   9724   cropElemG(self2, returnType1, index8);
   9725   bool returnType2;
   9726   cropElemG(self2, returnType2, index8);
   9727   double returnType3;
   9728   cropElemG(self2, returnType3, index8);
   9729   int64_t returnType4;
   9730   cropElemG(self2, returnType4, index8);
   9731   int32_t returnType5;
   9732   cropElemG(self2, returnType5, index8);
   9733   uint64_t returnType6;
   9734   cropElemG(self2, returnType6, index8);
   9735   uint32_t returnType7;
   9736   cropElemG(self2, returnType7, index8);
   9737   char* returnType8;
   9738   cropElemG(self2, returnType8, index8);
   9739   smallDictt* returnType9;
   9740   cropElemG(self2, returnType9, index8);
   9741   smallArrayt* returnType10;
   9742   cropElemG(self2, returnType10, index8);
   9743   smallBoolt* returnType11;
   9744   cropElemG(self2, returnType11, index8);
   9745   smallBytest* returnType12;
   9746   cropElemG(self2, returnType12, index8);
   9747   smallDoublet* returnType13;
   9748   cropElemG(self2, returnType13, index8);
   9749   smallIntt* returnType14;
   9750   cropElemG(self2, returnType14, index8);
   9751   smallJsont* returnType15;
   9752   cropElemG(self2, returnType15, index8);
   9753   smallStringt* returnType16;
   9754   cropElemG(self2, returnType16, index8);
   9755   void* returnType17;
   9756   cropElemG(self2, returnType17, index8);
   9757   smallContainert* returnType18;
   9758   cropElemG(self2, returnType18, index8);
   9759   smallJsont * returnType19;
   9760   cropElemG(self2, returnType19, index8);
   9761 }
   9762 {
   9763   smallJsont* self2;
   9764   int8_t index9;
   9765   baset* returnType0;
   9766   cropElemG(self2, returnType0, index9);
   9767   undefinedt* returnType1;
   9768   cropElemG(self2, returnType1, index9);
   9769   bool returnType2;
   9770   cropElemG(self2, returnType2, index9);
   9771   double returnType3;
   9772   cropElemG(self2, returnType3, index9);
   9773   int64_t returnType4;
   9774   cropElemG(self2, returnType4, index9);
   9775   int32_t returnType5;
   9776   cropElemG(self2, returnType5, index9);
   9777   uint64_t returnType6;
   9778   cropElemG(self2, returnType6, index9);
   9779   uint32_t returnType7;
   9780   cropElemG(self2, returnType7, index9);
   9781   char* returnType8;
   9782   cropElemG(self2, returnType8, index9);
   9783   smallDictt* returnType9;
   9784   cropElemG(self2, returnType9, index9);
   9785   smallArrayt* returnType10;
   9786   cropElemG(self2, returnType10, index9);
   9787   smallBoolt* returnType11;
   9788   cropElemG(self2, returnType11, index9);
   9789   smallBytest* returnType12;
   9790   cropElemG(self2, returnType12, index9);
   9791   smallDoublet* returnType13;
   9792   cropElemG(self2, returnType13, index9);
   9793   smallIntt* returnType14;
   9794   cropElemG(self2, returnType14, index9);
   9795   smallJsont* returnType15;
   9796   cropElemG(self2, returnType15, index9);
   9797   smallStringt* returnType16;
   9798   cropElemG(self2, returnType16, index9);
   9799   void* returnType17;
   9800   cropElemG(self2, returnType17, index9);
   9801   smallContainert* returnType18;
   9802   cropElemG(self2, returnType18, index9);
   9803   smallJsont * returnType19;
   9804   cropElemG(self2, returnType19, index9);
   9805 }
   9806 {
   9807   smallJsont* self2;
   9808   uint64_t index10;
   9809   baset* returnType0;
   9810   cropElemG(self2, returnType0, index10);
   9811   undefinedt* returnType1;
   9812   cropElemG(self2, returnType1, index10);
   9813   bool returnType2;
   9814   cropElemG(self2, returnType2, index10);
   9815   double returnType3;
   9816   cropElemG(self2, returnType3, index10);
   9817   int64_t returnType4;
   9818   cropElemG(self2, returnType4, index10);
   9819   int32_t returnType5;
   9820   cropElemG(self2, returnType5, index10);
   9821   uint64_t returnType6;
   9822   cropElemG(self2, returnType6, index10);
   9823   uint32_t returnType7;
   9824   cropElemG(self2, returnType7, index10);
   9825   char* returnType8;
   9826   cropElemG(self2, returnType8, index10);
   9827   smallDictt* returnType9;
   9828   cropElemG(self2, returnType9, index10);
   9829   smallArrayt* returnType10;
   9830   cropElemG(self2, returnType10, index10);
   9831   smallBoolt* returnType11;
   9832   cropElemG(self2, returnType11, index10);
   9833   smallBytest* returnType12;
   9834   cropElemG(self2, returnType12, index10);
   9835   smallDoublet* returnType13;
   9836   cropElemG(self2, returnType13, index10);
   9837   smallIntt* returnType14;
   9838   cropElemG(self2, returnType14, index10);
   9839   smallJsont* returnType15;
   9840   cropElemG(self2, returnType15, index10);
   9841   smallStringt* returnType16;
   9842   cropElemG(self2, returnType16, index10);
   9843   void* returnType17;
   9844   cropElemG(self2, returnType17, index10);
   9845   smallContainert* returnType18;
   9846   cropElemG(self2, returnType18, index10);
   9847   smallJsont * returnType19;
   9848   cropElemG(self2, returnType19, index10);
   9849 }
   9850 {
   9851   smallJsont* self2;
   9852   uint32_t index11;
   9853   baset* returnType0;
   9854   cropElemG(self2, returnType0, index11);
   9855   undefinedt* returnType1;
   9856   cropElemG(self2, returnType1, index11);
   9857   bool returnType2;
   9858   cropElemG(self2, returnType2, index11);
   9859   double returnType3;
   9860   cropElemG(self2, returnType3, index11);
   9861   int64_t returnType4;
   9862   cropElemG(self2, returnType4, index11);
   9863   int32_t returnType5;
   9864   cropElemG(self2, returnType5, index11);
   9865   uint64_t returnType6;
   9866   cropElemG(self2, returnType6, index11);
   9867   uint32_t returnType7;
   9868   cropElemG(self2, returnType7, index11);
   9869   char* returnType8;
   9870   cropElemG(self2, returnType8, index11);
   9871   smallDictt* returnType9;
   9872   cropElemG(self2, returnType9, index11);
   9873   smallArrayt* returnType10;
   9874   cropElemG(self2, returnType10, index11);
   9875   smallBoolt* returnType11;
   9876   cropElemG(self2, returnType11, index11);
   9877   smallBytest* returnType12;
   9878   cropElemG(self2, returnType12, index11);
   9879   smallDoublet* returnType13;
   9880   cropElemG(self2, returnType13, index11);
   9881   smallIntt* returnType14;
   9882   cropElemG(self2, returnType14, index11);
   9883   smallJsont* returnType15;
   9884   cropElemG(self2, returnType15, index11);
   9885   smallStringt* returnType16;
   9886   cropElemG(self2, returnType16, index11);
   9887   void* returnType17;
   9888   cropElemG(self2, returnType17, index11);
   9889   smallContainert* returnType18;
   9890   cropElemG(self2, returnType18, index11);
   9891   smallJsont * returnType19;
   9892   cropElemG(self2, returnType19, index11);
   9893 }
   9894 {
   9895   smallJsont* self2;
   9896   uint16_t index12;
   9897   baset* returnType0;
   9898   cropElemG(self2, returnType0, index12);
   9899   undefinedt* returnType1;
   9900   cropElemG(self2, returnType1, index12);
   9901   bool returnType2;
   9902   cropElemG(self2, returnType2, index12);
   9903   double returnType3;
   9904   cropElemG(self2, returnType3, index12);
   9905   int64_t returnType4;
   9906   cropElemG(self2, returnType4, index12);
   9907   int32_t returnType5;
   9908   cropElemG(self2, returnType5, index12);
   9909   uint64_t returnType6;
   9910   cropElemG(self2, returnType6, index12);
   9911   uint32_t returnType7;
   9912   cropElemG(self2, returnType7, index12);
   9913   char* returnType8;
   9914   cropElemG(self2, returnType8, index12);
   9915   smallDictt* returnType9;
   9916   cropElemG(self2, returnType9, index12);
   9917   smallArrayt* returnType10;
   9918   cropElemG(self2, returnType10, index12);
   9919   smallBoolt* returnType11;
   9920   cropElemG(self2, returnType11, index12);
   9921   smallBytest* returnType12;
   9922   cropElemG(self2, returnType12, index12);
   9923   smallDoublet* returnType13;
   9924   cropElemG(self2, returnType13, index12);
   9925   smallIntt* returnType14;
   9926   cropElemG(self2, returnType14, index12);
   9927   smallJsont* returnType15;
   9928   cropElemG(self2, returnType15, index12);
   9929   smallStringt* returnType16;
   9930   cropElemG(self2, returnType16, index12);
   9931   void* returnType17;
   9932   cropElemG(self2, returnType17, index12);
   9933   smallContainert* returnType18;
   9934   cropElemG(self2, returnType18, index12);
   9935   smallJsont * returnType19;
   9936   cropElemG(self2, returnType19, index12);
   9937 }
   9938 {
   9939   smallJsont* self2;
   9940   uint8_t index13;
   9941   baset* returnType0;
   9942   cropElemG(self2, returnType0, index13);
   9943   undefinedt* returnType1;
   9944   cropElemG(self2, returnType1, index13);
   9945   bool returnType2;
   9946   cropElemG(self2, returnType2, index13);
   9947   double returnType3;
   9948   cropElemG(self2, returnType3, index13);
   9949   int64_t returnType4;
   9950   cropElemG(self2, returnType4, index13);
   9951   int32_t returnType5;
   9952   cropElemG(self2, returnType5, index13);
   9953   uint64_t returnType6;
   9954   cropElemG(self2, returnType6, index13);
   9955   uint32_t returnType7;
   9956   cropElemG(self2, returnType7, index13);
   9957   char* returnType8;
   9958   cropElemG(self2, returnType8, index13);
   9959   smallDictt* returnType9;
   9960   cropElemG(self2, returnType9, index13);
   9961   smallArrayt* returnType10;
   9962   cropElemG(self2, returnType10, index13);
   9963   smallBoolt* returnType11;
   9964   cropElemG(self2, returnType11, index13);
   9965   smallBytest* returnType12;
   9966   cropElemG(self2, returnType12, index13);
   9967   smallDoublet* returnType13;
   9968   cropElemG(self2, returnType13, index13);
   9969   smallIntt* returnType14;
   9970   cropElemG(self2, returnType14, index13);
   9971   smallJsont* returnType15;
   9972   cropElemG(self2, returnType15, index13);
   9973   smallStringt* returnType16;
   9974   cropElemG(self2, returnType16, index13);
   9975   void* returnType17;
   9976   cropElemG(self2, returnType17, index13);
   9977   smallContainert* returnType18;
   9978   cropElemG(self2, returnType18, index13);
   9979   smallJsont * returnType19;
   9980   cropElemG(self2, returnType19, index13);
   9981 }
   9982 {
   9983   smallJsont* self2;
   9984   const char* index0;
   9985   smallJsont * returnType0;
   9986   cropElemG(self2, returnType0, index0);
   9987 }
   9988 {
   9989   smallArrayt* self3;
   9990   int64_t index15;
   9991   baset* returnType0;
   9992   cropElemG(self3, returnType0, index15);
   9993   undefinedt* returnType1;
   9994   cropElemG(self3, returnType1, index15);
   9995   bool returnType2;
   9996   cropElemG(self3, returnType2, index15);
   9997   double returnType3;
   9998   cropElemG(self3, returnType3, index15);
   9999   int64_t returnType4;
  10000   cropElemG(self3, returnType4, index15);
  10001   int32_t returnType5;
  10002   cropElemG(self3, returnType5, index15);
  10003   uint64_t returnType6;
  10004   cropElemG(self3, returnType6, index15);
  10005   uint32_t returnType7;
  10006   cropElemG(self3, returnType7, index15);
  10007   char* returnType8;
  10008   cropElemG(self3, returnType8, index15);
  10009   smallDictt* returnType9;
  10010   cropElemG(self3, returnType9, index15);
  10011   smallArrayt* returnType10;
  10012   cropElemG(self3, returnType10, index15);
  10013   smallBoolt* returnType11;
  10014   cropElemG(self3, returnType11, index15);
  10015   smallBytest* returnType12;
  10016   cropElemG(self3, returnType12, index15);
  10017   smallDoublet* returnType13;
  10018   cropElemG(self3, returnType13, index15);
  10019   smallIntt* returnType14;
  10020   cropElemG(self3, returnType14, index15);
  10021   smallJsont* returnType15;
  10022   cropElemG(self3, returnType15, index15);
  10023   smallStringt* returnType16;
  10024   cropElemG(self3, returnType16, index15);
  10025   void* returnType17;
  10026   cropElemG(self3, returnType17, index15);
  10027   smallContainert* returnType18;
  10028   cropElemG(self3, returnType18, index15);
  10029   smallArrayt * returnType19;
  10030   cropElemG(self3, returnType19, index15);
  10031 }
  10032 {
  10033   smallStringt* self4;
  10034   int64_t index15;
  10035   smallStringt * returnType0;
  10036   cropElemG(self4, returnType0, index15);
  10037 }
  10038 {
  10039   char * self5;
  10040   int64_t index15;
  10041   char * returnType0;
  10042   cropElemG(self5, returnType0, index15);
  10043 }
  10044 {
  10045   char ** self6;
  10046   int64_t index15;
  10047   char ** returnType0;
  10048   cropElemG(self6, returnType0, index15);
  10049 }
  10050 {
  10051   char *** self7;
  10052   int64_t index15;
  10053   char *** returnType0;
  10054   cropElemG(self7, returnType0, index15);
  10055 }
  10056 {
  10057   char * self1;
  10058   int64_t start1;
  10059   int64_t end0;
  10060   copyRngG(self1, start1, end0);
  10061 }
  10062 {
  10063   const char * self2;
  10064   int64_t start2;
  10065   int64_t end0;
  10066   copyRngG(self2, start2, end0);
  10067 }
  10068 {
  10069   char ** self3;
  10070   int64_t start3;
  10071   int64_t end0;
  10072   copyRngG(self3, start3, end0);
  10073 }
  10074 {
  10075   smallArrayt * self4;
  10076   int64_t start4;
  10077   int64_t end0;
  10078   copyRngG(self4, start4, end0);
  10079 }
  10080 {
  10081   smallJsont * self5;
  10082   int64_t start5;
  10083   int64_t end0;
  10084   copyRngG(self5, start5, end0);
  10085 }
  10086 {
  10087   smallStringt * self6;
  10088   int64_t start6;
  10089   int64_t end0;
  10090   copyRngG(self6, start6, end0);
  10091 }
  10092 {
  10093   char * self1;
  10094   int64_t index1;
  10095   char toInsert0;
  10096   insertG(self1, index1, toInsert0);
  10097   int toInsert1;
  10098   insertG(self1, index1, toInsert1);
  10099   char toInsert2;
  10100   insertG(self1, index1, toInsert2);
  10101 }
  10102 {
  10103   const char * self2;
  10104   int64_t index2;
  10105   char toInsert0;
  10106   insertG(self2, index2, toInsert0);
  10107   int toInsert1;
  10108   insertG(self2, index2, toInsert1);
  10109   char toInsert2;
  10110   insertG(self2, index2, toInsert2);
  10111 }
  10112 {
  10113   char ** self3;
  10114   int64_t index3;
  10115   char toInsert0;
  10116   insertG(self3, index3, toInsert0);
  10117   int toInsert1;
  10118   insertG(self3, index3, toInsert1);
  10119   char toInsert2;
  10120   insertG(self3, index3, toInsert2);
  10121 }
  10122 {
  10123   char *** self4;
  10124   int64_t index4;
  10125   char * toInsert0;
  10126   insertG(self4, index4, toInsert0);
  10127   char toInsert1;
  10128   insertG(self4, index4, toInsert1);
  10129   int toInsert2;
  10130   insertG(self4, index4, toInsert2);
  10131   char * toInsert3;
  10132   insertG(self4, index4, toInsert3);
  10133 }
  10134 {
  10135   smallArrayt* self5;
  10136   int64_t index5;
  10137   bool toInsert0;
  10138   insertG(self5, index5, toInsert0);
  10139   double toInsert1;
  10140   insertG(self5, index5, toInsert1);
  10141   int64_t toInsert2;
  10142   insertG(self5, index5, toInsert2);
  10143   int32_t toInsert3;
  10144   insertG(self5, index5, toInsert3);
  10145   uint32_t toInsert4;
  10146   insertG(self5, index5, toInsert4);
  10147   uint64_t toInsert5;
  10148   insertG(self5, index5, toInsert5);
  10149   char* toInsert6;
  10150   insertG(self5, index5, toInsert6);
  10151   char toInsert7;
  10152   insertG(self5, index5, toInsert7);
  10153   const char* toInsert8;
  10154   insertG(self5, index5, toInsert8);
  10155   smallDictt* toInsert9;
  10156   insertG(self5, index5, toInsert9);
  10157   smallArrayt* toInsert10;
  10158   insertG(self5, index5, toInsert10);
  10159   char ** toInsert11;
  10160   insertG(self5, index5, toInsert11);
  10161   const char ** toInsert12;
  10162   insertG(self5, index5, toInsert12);
  10163   smallBoolt* toInsert13;
  10164   insertG(self5, index5, toInsert13);
  10165   smallBytest* toInsert14;
  10166   insertG(self5, index5, toInsert14);
  10167   smallDoublet* toInsert15;
  10168   insertG(self5, index5, toInsert15);
  10169   smallIntt* toInsert16;
  10170   insertG(self5, index5, toInsert16);
  10171   smallJsont* toInsert17;
  10172   insertG(self5, index5, toInsert17);
  10173   smallStringt* toInsert18;
  10174   insertG(self5, index5, toInsert18);
  10175   smallContainert* toInsert19;
  10176   insertG(self5, index5, toInsert19);
  10177   undefinedt* toInsert20;
  10178   insertG(self5, index5, toInsert20);
  10179   void * toInsert21;
  10180   insertG(self5, index5, toInsert21);
  10181 }
  10182 {
  10183   smallJsont* self6;
  10184   int64_t index6;
  10185   bool toInsert0;
  10186   insertG(self6, index6, toInsert0);
  10187   double toInsert1;
  10188   insertG(self6, index6, toInsert1);
  10189   int64_t toInsert2;
  10190   insertG(self6, index6, toInsert2);
  10191   int32_t toInsert3;
  10192   insertG(self6, index6, toInsert3);
  10193   uint32_t toInsert4;
  10194   insertG(self6, index6, toInsert4);
  10195   uint64_t toInsert5;
  10196   insertG(self6, index6, toInsert5);
  10197   char* toInsert6;
  10198   insertG(self6, index6, toInsert6);
  10199   char toInsert7;
  10200   insertG(self6, index6, toInsert7);
  10201   const char* toInsert8;
  10202   insertG(self6, index6, toInsert8);
  10203   smallDictt* toInsert9;
  10204   insertG(self6, index6, toInsert9);
  10205   smallArrayt* toInsert10;
  10206   insertG(self6, index6, toInsert10);
  10207   char ** toInsert11;
  10208   insertG(self6, index6, toInsert11);
  10209   const char ** toInsert12;
  10210   insertG(self6, index6, toInsert12);
  10211   smallBoolt* toInsert13;
  10212   insertG(self6, index6, toInsert13);
  10213   smallBytest* toInsert14;
  10214   insertG(self6, index6, toInsert14);
  10215   smallDoublet* toInsert15;
  10216   insertG(self6, index6, toInsert15);
  10217   smallIntt* toInsert16;
  10218   insertG(self6, index6, toInsert16);
  10219   smallJsont* toInsert17;
  10220   insertG(self6, index6, toInsert17);
  10221   smallStringt* toInsert18;
  10222   insertG(self6, index6, toInsert18);
  10223   smallContainert* toInsert19;
  10224   insertG(self6, index6, toInsert19);
  10225   undefinedt* toInsert20;
  10226   insertG(self6, index6, toInsert20);
  10227   void * toInsert21;
  10228   insertG(self6, index6, toInsert21);
  10229 }
  10230 {
  10231   smallStringt * self7;
  10232   int64_t index7;
  10233   const char * toInsert0;
  10234   insertG(self7, index7, toInsert0);
  10235   char toInsert1;
  10236   insertG(self7, index7, toInsert1);
  10237   int toInsert2;
  10238   insertG(self7, index7, toInsert2);
  10239   smallJsont * toInsert3;
  10240   insertG(self7, index7, toInsert3);
  10241   smallStringt * toInsert4;
  10242   insertG(self7, index7, toInsert4);
  10243   const char * toInsert5;
  10244   insertG(self7, index7, toInsert5);
  10245 }
  10246 {
  10247   char * self1;
  10248   int64_t index1;
  10249   char toInsert0;
  10250   insertNSmashG(self1, index1, toInsert0);
  10251   int toInsert1;
  10252   insertNSmashG(self1, index1, toInsert1);
  10253   char toInsert2;
  10254   insertNSmashG(self1, index1, toInsert2);
  10255 }
  10256 {
  10257   const char * self2;
  10258   int64_t index2;
  10259   char toInsert0;
  10260   insertNSmashG(self2, index2, toInsert0);
  10261   int toInsert1;
  10262   insertNSmashG(self2, index2, toInsert1);
  10263   char toInsert2;
  10264   insertNSmashG(self2, index2, toInsert2);
  10265 }
  10266 {
  10267   char ** self3;
  10268   int64_t index3;
  10269   char toInsert0;
  10270   insertNSmashG(self3, index3, toInsert0);
  10271   int toInsert1;
  10272   insertNSmashG(self3, index3, toInsert1);
  10273   char toInsert2;
  10274   insertNSmashG(self3, index3, toInsert2);
  10275 }
  10276 {
  10277   char *** self4;
  10278   int64_t index4;
  10279   char * toInsert0;
  10280   insertNSmashG(self4, index4, toInsert0);
  10281   char toInsert1;
  10282   insertNSmashG(self4, index4, toInsert1);
  10283   int toInsert2;
  10284   insertNSmashG(self4, index4, toInsert2);
  10285   char * toInsert3;
  10286   insertNSmashG(self4, index4, toInsert3);
  10287 }
  10288 {
  10289   smallArrayt* self5;
  10290   int64_t index5;
  10291   bool toInsert0;
  10292   insertNSmashG(self5, index5, toInsert0);
  10293   double toInsert1;
  10294   insertNSmashG(self5, index5, toInsert1);
  10295   int64_t toInsert2;
  10296   insertNSmashG(self5, index5, toInsert2);
  10297   int32_t toInsert3;
  10298   insertNSmashG(self5, index5, toInsert3);
  10299   uint32_t toInsert4;
  10300   insertNSmashG(self5, index5, toInsert4);
  10301   uint64_t toInsert5;
  10302   insertNSmashG(self5, index5, toInsert5);
  10303   char* toInsert6;
  10304   insertNSmashG(self5, index5, toInsert6);
  10305   char toInsert7;
  10306   insertNSmashG(self5, index5, toInsert7);
  10307   smallDictt* toInsert8;
  10308   insertNSmashG(self5, index5, toInsert8);
  10309   smallArrayt* toInsert9;
  10310   insertNSmashG(self5, index5, toInsert9);
  10311   char ** toInsert10;
  10312   insertNSmashG(self5, index5, toInsert10);
  10313   smallBoolt* toInsert11;
  10314   insertNSmashG(self5, index5, toInsert11);
  10315   smallBytest* toInsert12;
  10316   insertNSmashG(self5, index5, toInsert12);
  10317   smallDoublet* toInsert13;
  10318   insertNSmashG(self5, index5, toInsert13);
  10319   smallIntt* toInsert14;
  10320   insertNSmashG(self5, index5, toInsert14);
  10321   smallJsont* toInsert15;
  10322   insertNSmashG(self5, index5, toInsert15);
  10323   smallStringt* toInsert16;
  10324   insertNSmashG(self5, index5, toInsert16);
  10325   smallContainert* toInsert17;
  10326   insertNSmashG(self5, index5, toInsert17);
  10327   undefinedt* toInsert18;
  10328   insertNSmashG(self5, index5, toInsert18);
  10329   void * toInsert19;
  10330   insertNSmashG(self5, index5, toInsert19);
  10331 }
  10332 {
  10333   smallJsont* self6;
  10334   int64_t index6;
  10335   bool toInsert0;
  10336   insertNSmashG(self6, index6, toInsert0);
  10337   double toInsert1;
  10338   insertNSmashG(self6, index6, toInsert1);
  10339   int64_t toInsert2;
  10340   insertNSmashG(self6, index6, toInsert2);
  10341   int32_t toInsert3;
  10342   insertNSmashG(self6, index6, toInsert3);
  10343   uint32_t toInsert4;
  10344   insertNSmashG(self6, index6, toInsert4);
  10345   uint64_t toInsert5;
  10346   insertNSmashG(self6, index6, toInsert5);
  10347   char* toInsert6;
  10348   insertNSmashG(self6, index6, toInsert6);
  10349   char toInsert7;
  10350   insertNSmashG(self6, index6, toInsert7);
  10351   smallDictt* toInsert8;
  10352   insertNSmashG(self6, index6, toInsert8);
  10353   smallArrayt* toInsert9;
  10354   insertNSmashG(self6, index6, toInsert9);
  10355   char ** toInsert10;
  10356   insertNSmashG(self6, index6, toInsert10);
  10357   smallBoolt* toInsert11;
  10358   insertNSmashG(self6, index6, toInsert11);
  10359   smallBytest* toInsert12;
  10360   insertNSmashG(self6, index6, toInsert12);
  10361   smallDoublet* toInsert13;
  10362   insertNSmashG(self6, index6, toInsert13);
  10363   smallIntt* toInsert14;
  10364   insertNSmashG(self6, index6, toInsert14);
  10365   smallJsont* toInsert15;
  10366   insertNSmashG(self6, index6, toInsert15);
  10367   smallStringt* toInsert16;
  10368   insertNSmashG(self6, index6, toInsert16);
  10369   smallContainert* toInsert17;
  10370   insertNSmashG(self6, index6, toInsert17);
  10371   undefinedt* toInsert18;
  10372   insertNSmashG(self6, index6, toInsert18);
  10373   void * toInsert19;
  10374   insertNSmashG(self6, index6, toInsert19);
  10375 }
  10376 {
  10377   smallStringt * self7;
  10378   int64_t index7;
  10379   char toInsert0;
  10380   insertNSmashG(self7, index7, toInsert0);
  10381   int toInsert1;
  10382   insertNSmashG(self7, index7, toInsert1);
  10383   smallJsont * toInsert2;
  10384   insertNSmashG(self7, index7, toInsert2);
  10385   smallStringt * toInsert3;
  10386   insertNSmashG(self7, index7, toInsert3);
  10387   char * toInsert4;
  10388   insertNSmashG(self7, index7, toInsert4);
  10389 }
  10390 {
  10391   char * self1;
  10392   int64_t index1;
  10393   char value0;
  10394   injectG(self1, index1, value0);
  10395 }
  10396 {
  10397   const char * self2;
  10398   int64_t index2;
  10399   char value0;
  10400   injectG(self2, index2, value0);
  10401 }
  10402 {
  10403   char ** self3;
  10404   int64_t index3;
  10405   char value0;
  10406   injectG(self3, index3, value0);
  10407 }
  10408 {
  10409   char *** self4;
  10410   int64_t index4;
  10411   char value0;
  10412   injectG(self4, index4, value0);
  10413   int value1;
  10414   injectG(self4, index4, value1);
  10415   char * value2;
  10416   injectG(self4, index4, value2);
  10417 }
  10418 {
  10419   smallArrayt* self5;
  10420   int64_t index5;
  10421   bool value0;
  10422   injectG(self5, index5, value0);
  10423   double value1;
  10424   injectG(self5, index5, value1);
  10425   int64_t value2;
  10426   injectG(self5, index5, value2);
  10427   int32_t value3;
  10428   injectG(self5, index5, value3);
  10429   uint32_t value4;
  10430   injectG(self5, index5, value4);
  10431   uint64_t value5;
  10432   injectG(self5, index5, value5);
  10433   char* value6;
  10434   injectG(self5, index5, value6);
  10435   char value7;
  10436   injectG(self5, index5, value7);
  10437   const char* value8;
  10438   injectG(self5, index5, value8);
  10439   smallDictt* value9;
  10440   injectG(self5, index5, value9);
  10441   smallArrayt* value10;
  10442   injectG(self5, index5, value10);
  10443   char ** value11;
  10444   injectG(self5, index5, value11);
  10445   const char ** value12;
  10446   injectG(self5, index5, value12);
  10447   smallBoolt* value13;
  10448   injectG(self5, index5, value13);
  10449   smallBytest* value14;
  10450   injectG(self5, index5, value14);
  10451   smallDoublet* value15;
  10452   injectG(self5, index5, value15);
  10453   smallIntt* value16;
  10454   injectG(self5, index5, value16);
  10455   smallJsont* value17;
  10456   injectG(self5, index5, value17);
  10457   smallStringt* value18;
  10458   injectG(self5, index5, value18);
  10459   smallContainert* value19;
  10460   injectG(self5, index5, value19);
  10461   undefinedt* value20;
  10462   injectG(self5, index5, value20);
  10463   void * value21;
  10464   injectG(self5, index5, value21);
  10465 }
  10466 {
  10467   smallJsont* self6;
  10468   int64_t index6;
  10469   bool value0;
  10470   injectG(self6, index6, value0);
  10471   double value1;
  10472   injectG(self6, index6, value1);
  10473   int64_t value2;
  10474   injectG(self6, index6, value2);
  10475   int32_t value3;
  10476   injectG(self6, index6, value3);
  10477   uint32_t value4;
  10478   injectG(self6, index6, value4);
  10479   uint64_t value5;
  10480   injectG(self6, index6, value5);
  10481   char* value6;
  10482   injectG(self6, index6, value6);
  10483   char value7;
  10484   injectG(self6, index6, value7);
  10485   const char* value8;
  10486   injectG(self6, index6, value8);
  10487   smallDictt* value9;
  10488   injectG(self6, index6, value9);
  10489   smallArrayt* value10;
  10490   injectG(self6, index6, value10);
  10491   char ** value11;
  10492   injectG(self6, index6, value11);
  10493   const char ** value12;
  10494   injectG(self6, index6, value12);
  10495   smallBoolt* value13;
  10496   injectG(self6, index6, value13);
  10497   smallBytest* value14;
  10498   injectG(self6, index6, value14);
  10499   smallDoublet* value15;
  10500   injectG(self6, index6, value15);
  10501   smallIntt* value16;
  10502   injectG(self6, index6, value16);
  10503   smallJsont* value17;
  10504   injectG(self6, index6, value17);
  10505   smallStringt* value18;
  10506   injectG(self6, index6, value18);
  10507   smallContainert* value19;
  10508   injectG(self6, index6, value19);
  10509   undefinedt* value20;
  10510   injectG(self6, index6, value20);
  10511   void * value21;
  10512   injectG(self6, index6, value21);
  10513 }
  10514 {
  10515   smallStringt * self7;
  10516   int64_t index7;
  10517   char value0;
  10518   injectG(self7, index7, value0);
  10519 }
  10520 {
  10521   char * self1;
  10522   int64_t index1;
  10523   char value0;
  10524   injectNFreeG(self1, index1, value0);
  10525 }
  10526 {
  10527   const char * self2;
  10528   int64_t index2;
  10529   char value0;
  10530   injectNFreeG(self2, index2, value0);
  10531 }
  10532 {
  10533   char ** self3;
  10534   int64_t index3;
  10535   char value0;
  10536   injectNFreeG(self3, index3, value0);
  10537 }
  10538 {
  10539   char *** self4;
  10540   int64_t index4;
  10541   char * value0;
  10542   injectNFreeG(self4, index4, value0);
  10543 }
  10544 {
  10545   smallArrayt* self5;
  10546   int64_t index5;
  10547   bool value0;
  10548   injectNFreeG(self5, index5, value0);
  10549   double value1;
  10550   injectNFreeG(self5, index5, value1);
  10551   int64_t value2;
  10552   injectNFreeG(self5, index5, value2);
  10553   int32_t value3;
  10554   injectNFreeG(self5, index5, value3);
  10555   uint32_t value4;
  10556   injectNFreeG(self5, index5, value4);
  10557   uint64_t value5;
  10558   injectNFreeG(self5, index5, value5);
  10559   char* value6;
  10560   injectNFreeG(self5, index5, value6);
  10561   char value7;
  10562   injectNFreeG(self5, index5, value7);
  10563   smallDictt* value8;
  10564   injectNFreeG(self5, index5, value8);
  10565   smallArrayt* value9;
  10566   injectNFreeG(self5, index5, value9);
  10567   char ** value10;
  10568   injectNFreeG(self5, index5, value10);
  10569   smallBoolt* value11;
  10570   injectNFreeG(self5, index5, value11);
  10571   smallBytest* value12;
  10572   injectNFreeG(self5, index5, value12);
  10573   smallDoublet* value13;
  10574   injectNFreeG(self5, index5, value13);
  10575   smallIntt* value14;
  10576   injectNFreeG(self5, index5, value14);
  10577   smallJsont* value15;
  10578   injectNFreeG(self5, index5, value15);
  10579   smallStringt* value16;
  10580   injectNFreeG(self5, index5, value16);
  10581   smallContainert* value17;
  10582   injectNFreeG(self5, index5, value17);
  10583   undefinedt* value18;
  10584   injectNFreeG(self5, index5, value18);
  10585   void * value19;
  10586   injectNFreeG(self5, index5, value19);
  10587 }
  10588 {
  10589   smallJsont* self6;
  10590   int64_t index6;
  10591   bool value0;
  10592   injectNFreeG(self6, index6, value0);
  10593   double value1;
  10594   injectNFreeG(self6, index6, value1);
  10595   int64_t value2;
  10596   injectNFreeG(self6, index6, value2);
  10597   int32_t value3;
  10598   injectNFreeG(self6, index6, value3);
  10599   uint32_t value4;
  10600   injectNFreeG(self6, index6, value4);
  10601   uint64_t value5;
  10602   injectNFreeG(self6, index6, value5);
  10603   char* value6;
  10604   injectNFreeG(self6, index6, value6);
  10605   char value7;
  10606   injectNFreeG(self6, index6, value7);
  10607   smallDictt* value8;
  10608   injectNFreeG(self6, index6, value8);
  10609   smallArrayt* value9;
  10610   injectNFreeG(self6, index6, value9);
  10611   char ** value10;
  10612   injectNFreeG(self6, index6, value10);
  10613   smallBoolt* value11;
  10614   injectNFreeG(self6, index6, value11);
  10615   smallBytest* value12;
  10616   injectNFreeG(self6, index6, value12);
  10617   smallDoublet* value13;
  10618   injectNFreeG(self6, index6, value13);
  10619   smallIntt* value14;
  10620   injectNFreeG(self6, index6, value14);
  10621   smallJsont* value15;
  10622   injectNFreeG(self6, index6, value15);
  10623   smallStringt* value16;
  10624   injectNFreeG(self6, index6, value16);
  10625   smallContainert* value17;
  10626   injectNFreeG(self6, index6, value17);
  10627   undefinedt* value18;
  10628   injectNFreeG(self6, index6, value18);
  10629   void * value19;
  10630   injectNFreeG(self6, index6, value19);
  10631 }
  10632 {
  10633   smallStringt * self7;
  10634   int64_t index7;
  10635   char value0;
  10636   injectNFreeG(self7, index7, value0);
  10637 }
  10638 {
  10639   char * self1;
  10640   char * needle0;
  10641   findG(self1, needle0);
  10642   const char * needle1;
  10643   findG(self1, needle1);
  10644   char needle2;
  10645   findG(self1, needle2);
  10646   int needle3;
  10647   findG(self1, needle3);
  10648   const char * needle4;
  10649   findG(self1, needle4);
  10650 }
  10651 {
  10652   const char * self2;
  10653   char * needle0;
  10654   findG(self2, needle0);
  10655   const char * needle1;
  10656   findG(self2, needle1);
  10657   char needle2;
  10658   findG(self2, needle2);
  10659   int needle3;
  10660   findG(self2, needle3);
  10661   const char * needle4;
  10662   findG(self2, needle4);
  10663 }
  10664 {
  10665   char ** self3;
  10666   const char * needle0;
  10667   findG(self3, needle0);
  10668 }
  10669 {
  10670   const char ** self4;
  10671   const char * needle0;
  10672   findG(self4, needle0);
  10673 }
  10674 {
  10675   smallArrayt * self5;
  10676   char * needle0;
  10677   findG(self5, needle0);
  10678   const char * needle1;
  10679   findG(self5, needle1);
  10680   char needle2;
  10681   findG(self5, needle2);
  10682   int needle3;
  10683   findG(self5, needle3);
  10684   smallJsont* needle4;
  10685   findG(self5, needle4);
  10686   smallStringt* needle5;
  10687   findG(self5, needle5);
  10688   const char * needle6;
  10689   findG(self5, needle6);
  10690 }
  10691 {
  10692   smallJsont * self6;
  10693   char * needle0;
  10694   findG(self6, needle0);
  10695   const char * needle1;
  10696   findG(self6, needle1);
  10697   char needle2;
  10698   findG(self6, needle2);
  10699   int needle3;
  10700   findG(self6, needle3);
  10701   smallJsont * needle4;
  10702   findG(self6, needle4);
  10703   smallStringt * needle5;
  10704   findG(self6, needle5);
  10705 }
  10706 {
  10707   smallStringt * self7;
  10708   char * needle0;
  10709   findG(self7, needle0);
  10710   const char * needle1;
  10711   findG(self7, needle1);
  10712   char needle2;
  10713   findG(self7, needle2);
  10714   int needle3;
  10715   findG(self7, needle3);
  10716   smallJsont * needle4;
  10717   findG(self7, needle4);
  10718   smallStringt * needle5;
  10719   findG(self7, needle5);
  10720 }
  10721 {
  10722   char * self1;
  10723   char * needle0;
  10724   hasG(self1, needle0);
  10725   const char * needle1;
  10726   hasG(self1, needle1);
  10727   char needle2;
  10728   hasG(self1, needle2);
  10729   int needle3;
  10730   hasG(self1, needle3);
  10731   const char * needle4;
  10732   hasG(self1, needle4);
  10733 }
  10734 {
  10735   const char * self2;
  10736   char * needle0;
  10737   hasG(self2, needle0);
  10738   const char * needle1;
  10739   hasG(self2, needle1);
  10740   char needle2;
  10741   hasG(self2, needle2);
  10742   int needle3;
  10743   hasG(self2, needle3);
  10744   const char * needle4;
  10745   hasG(self2, needle4);
  10746 }
  10747 {
  10748   char ** self3;
  10749   char * needle0;
  10750   hasG(self3, needle0);
  10751   const char * needle1;
  10752   hasG(self3, needle1);
  10753   char needle2;
  10754   hasG(self3, needle2);
  10755   int needle3;
  10756   hasG(self3, needle3);
  10757   const char * needle4;
  10758   hasG(self3, needle4);
  10759 }
  10760 {
  10761   const char ** self4;
  10762   char * needle0;
  10763   hasG(self4, needle0);
  10764   const char * needle1;
  10765   hasG(self4, needle1);
  10766   char needle2;
  10767   hasG(self4, needle2);
  10768   int needle3;
  10769   hasG(self4, needle3);
  10770   const char * needle4;
  10771   hasG(self4, needle4);
  10772 }
  10773 {
  10774   smallArrayt* self5;
  10775   baset* needle0;
  10776   hasG(self5, needle0);
  10777   bool needle1;
  10778   hasG(self5, needle1);
  10779   double needle2;
  10780   hasG(self5, needle2);
  10781   int64_t needle3;
  10782   hasG(self5, needle3);
  10783   int32_t needle4;
  10784   hasG(self5, needle4);
  10785   uint32_t needle5;
  10786   hasG(self5, needle5);
  10787   uint64_t needle6;
  10788   hasG(self5, needle6);
  10789   char* needle7;
  10790   hasG(self5, needle7);
  10791   char needle8;
  10792   hasG(self5, needle8);
  10793   const char* needle9;
  10794   hasG(self5, needle9);
  10795   smallDictt* needle10;
  10796   hasG(self5, needle10);
  10797   smallArrayt* needle11;
  10798   hasG(self5, needle11);
  10799   char ** needle12;
  10800   hasG(self5, needle12);
  10801   const char ** needle13;
  10802   hasG(self5, needle13);
  10803   smallBoolt* needle14;
  10804   hasG(self5, needle14);
  10805   smallBytest* needle15;
  10806   hasG(self5, needle15);
  10807   smallDoublet* needle16;
  10808   hasG(self5, needle16);
  10809   smallIntt* needle17;
  10810   hasG(self5, needle17);
  10811   smallJsont* needle18;
  10812   hasG(self5, needle18);
  10813   smallStringt* needle19;
  10814   hasG(self5, needle19);
  10815   smallContainert* needle20;
  10816   hasG(self5, needle20);
  10817   undefinedt* needle21;
  10818   hasG(self5, needle21);
  10819   undefinedt * needle22;
  10820   hasG(self5, needle22);
  10821 }
  10822 {
  10823   smallJsont* self6;
  10824   baset* needle0;
  10825   hasG(self6, needle0);
  10826   bool needle1;
  10827   hasG(self6, needle1);
  10828   double needle2;
  10829   hasG(self6, needle2);
  10830   int64_t needle3;
  10831   hasG(self6, needle3);
  10832   int32_t needle4;
  10833   hasG(self6, needle4);
  10834   uint32_t needle5;
  10835   hasG(self6, needle5);
  10836   uint64_t needle6;
  10837   hasG(self6, needle6);
  10838   char* needle7;
  10839   hasG(self6, needle7);
  10840   char needle8;
  10841   hasG(self6, needle8);
  10842   const char* needle9;
  10843   hasG(self6, needle9);
  10844   smallDictt* needle10;
  10845   hasG(self6, needle10);
  10846   smallArrayt* needle11;
  10847   hasG(self6, needle11);
  10848   char ** needle12;
  10849   hasG(self6, needle12);
  10850   const char ** needle13;
  10851   hasG(self6, needle13);
  10852   smallBoolt* needle14;
  10853   hasG(self6, needle14);
  10854   smallBytest* needle15;
  10855   hasG(self6, needle15);
  10856   smallDoublet* needle16;
  10857   hasG(self6, needle16);
  10858   smallIntt* needle17;
  10859   hasG(self6, needle17);
  10860   smallJsont* needle18;
  10861   hasG(self6, needle18);
  10862   smallStringt* needle19;
  10863   hasG(self6, needle19);
  10864   smallContainert* needle20;
  10865   hasG(self6, needle20);
  10866   undefinedt* needle21;
  10867   hasG(self6, needle21);
  10868   undefinedt * needle22;
  10869   hasG(self6, needle22);
  10870 }
  10871 {
  10872   smallDictt * self7;
  10873   char * needle0;
  10874   hasG(self7, needle0);
  10875   const char * needle1;
  10876   hasG(self7, needle1);
  10877   char needle2;
  10878   hasG(self7, needle2);
  10879   int needle3;
  10880   hasG(self7, needle3);
  10881   const char * needle4;
  10882   hasG(self7, needle4);
  10883 }
  10884 {
  10885   smallStringt * self8;
  10886   char * needle0;
  10887   hasG(self8, needle0);
  10888   const char * needle1;
  10889   hasG(self8, needle1);
  10890   char needle2;
  10891   hasG(self8, needle2);
  10892   int needle3;
  10893   hasG(self8, needle3);
  10894   smallJsont * needle4;
  10895   hasG(self8, needle4);
  10896   smallStringt * needle5;
  10897   hasG(self8, needle5);
  10898   const char * needle6;
  10899   hasG(self8, needle6);
  10900 }
  10901 {
  10902   char * self1;
  10903   char * needle0;
  10904   indexOfG(self1, needle0);
  10905   const char * needle1;
  10906   indexOfG(self1, needle1);
  10907   char needle2;
  10908   indexOfG(self1, needle2);
  10909   int needle3;
  10910   indexOfG(self1, needle3);
  10911   const char * needle4;
  10912   indexOfG(self1, needle4);
  10913 }
  10914 {
  10915   const char * self2;
  10916   char * needle0;
  10917   indexOfG(self2, needle0);
  10918   const char * needle1;
  10919   indexOfG(self2, needle1);
  10920   char needle2;
  10921   indexOfG(self2, needle2);
  10922   int needle3;
  10923   indexOfG(self2, needle3);
  10924   const char * needle4;
  10925   indexOfG(self2, needle4);
  10926 }
  10927 {
  10928   char ** self3;
  10929   char * needle0;
  10930   indexOfG(self3, needle0);
  10931   const char * needle1;
  10932   indexOfG(self3, needle1);
  10933   char needle2;
  10934   indexOfG(self3, needle2);
  10935   int needle3;
  10936   indexOfG(self3, needle3);
  10937   const char * needle4;
  10938   indexOfG(self3, needle4);
  10939 }
  10940 {
  10941   const char ** self4;
  10942   char * needle0;
  10943   indexOfG(self4, needle0);
  10944   const char * needle1;
  10945   indexOfG(self4, needle1);
  10946   char needle2;
  10947   indexOfG(self4, needle2);
  10948   int needle3;
  10949   indexOfG(self4, needle3);
  10950   const char * needle4;
  10951   indexOfG(self4, needle4);
  10952 }
  10953 {
  10954   smallArrayt* self5;
  10955   baset* needle0;
  10956   indexOfG(self5, needle0);
  10957   bool needle1;
  10958   indexOfG(self5, needle1);
  10959   double needle2;
  10960   indexOfG(self5, needle2);
  10961   int64_t needle3;
  10962   indexOfG(self5, needle3);
  10963   int32_t needle4;
  10964   indexOfG(self5, needle4);
  10965   uint32_t needle5;
  10966   indexOfG(self5, needle5);
  10967   uint64_t needle6;
  10968   indexOfG(self5, needle6);
  10969   char* needle7;
  10970   indexOfG(self5, needle7);
  10971   char needle8;
  10972   indexOfG(self5, needle8);
  10973   const char* needle9;
  10974   indexOfG(self5, needle9);
  10975   smallDictt* needle10;
  10976   indexOfG(self5, needle10);
  10977   smallArrayt* needle11;
  10978   indexOfG(self5, needle11);
  10979   char ** needle12;
  10980   indexOfG(self5, needle12);
  10981   const char ** needle13;
  10982   indexOfG(self5, needle13);
  10983   smallBoolt* needle14;
  10984   indexOfG(self5, needle14);
  10985   smallBytest* needle15;
  10986   indexOfG(self5, needle15);
  10987   smallDoublet* needle16;
  10988   indexOfG(self5, needle16);
  10989   smallIntt* needle17;
  10990   indexOfG(self5, needle17);
  10991   smallJsont* needle18;
  10992   indexOfG(self5, needle18);
  10993   smallStringt* needle19;
  10994   indexOfG(self5, needle19);
  10995   smallContainert* needle20;
  10996   indexOfG(self5, needle20);
  10997   undefinedt* needle21;
  10998   indexOfG(self5, needle21);
  10999   undefinedt * needle22;
  11000   indexOfG(self5, needle22);
  11001 }
  11002 {
  11003   smallJsont* self6;
  11004   baset* needle0;
  11005   indexOfG(self6, needle0);
  11006   bool needle1;
  11007   indexOfG(self6, needle1);
  11008   double needle2;
  11009   indexOfG(self6, needle2);
  11010   int64_t needle3;
  11011   indexOfG(self6, needle3);
  11012   int32_t needle4;
  11013   indexOfG(self6, needle4);
  11014   uint32_t needle5;
  11015   indexOfG(self6, needle5);
  11016   uint64_t needle6;
  11017   indexOfG(self6, needle6);
  11018   char* needle7;
  11019   indexOfG(self6, needle7);
  11020   char needle8;
  11021   indexOfG(self6, needle8);
  11022   const char* needle9;
  11023   indexOfG(self6, needle9);
  11024   smallDictt* needle10;
  11025   indexOfG(self6, needle10);
  11026   smallArrayt* needle11;
  11027   indexOfG(self6, needle11);
  11028   char ** needle12;
  11029   indexOfG(self6, needle12);
  11030   const char ** needle13;
  11031   indexOfG(self6, needle13);
  11032   smallBoolt* needle14;
  11033   indexOfG(self6, needle14);
  11034   smallBytest* needle15;
  11035   indexOfG(self6, needle15);
  11036   smallDoublet* needle16;
  11037   indexOfG(self6, needle16);
  11038   smallIntt* needle17;
  11039   indexOfG(self6, needle17);
  11040   smallJsont* needle18;
  11041   indexOfG(self6, needle18);
  11042   smallStringt* needle19;
  11043   indexOfG(self6, needle19);
  11044   smallContainert* needle20;
  11045   indexOfG(self6, needle20);
  11046   undefinedt* needle21;
  11047   indexOfG(self6, needle21);
  11048   undefinedt * needle22;
  11049   indexOfG(self6, needle22);
  11050 }
  11051 {
  11052   smallDictt* self7;
  11053   baset* needle0;
  11054   indexOfG(self7, needle0);
  11055   bool needle1;
  11056   indexOfG(self7, needle1);
  11057   double needle2;
  11058   indexOfG(self7, needle2);
  11059   int64_t needle3;
  11060   indexOfG(self7, needle3);
  11061   int32_t needle4;
  11062   indexOfG(self7, needle4);
  11063   uint32_t needle5;
  11064   indexOfG(self7, needle5);
  11065   uint64_t needle6;
  11066   indexOfG(self7, needle6);
  11067   char* needle7;
  11068   indexOfG(self7, needle7);
  11069   char needle8;
  11070   indexOfG(self7, needle8);
  11071   const char* needle9;
  11072   indexOfG(self7, needle9);
  11073   smallDictt* needle10;
  11074   indexOfG(self7, needle10);
  11075   smallArrayt* needle11;
  11076   indexOfG(self7, needle11);
  11077   char ** needle12;
  11078   indexOfG(self7, needle12);
  11079   const char ** needle13;
  11080   indexOfG(self7, needle13);
  11081   smallBoolt* needle14;
  11082   indexOfG(self7, needle14);
  11083   smallBytest* needle15;
  11084   indexOfG(self7, needle15);
  11085   smallDoublet* needle16;
  11086   indexOfG(self7, needle16);
  11087   smallIntt* needle17;
  11088   indexOfG(self7, needle17);
  11089   smallJsont* needle18;
  11090   indexOfG(self7, needle18);
  11091   smallStringt* needle19;
  11092   indexOfG(self7, needle19);
  11093   smallContainert* needle20;
  11094   indexOfG(self7, needle20);
  11095   undefinedt* needle21;
  11096   indexOfG(self7, needle21);
  11097   undefinedt * needle22;
  11098   indexOfG(self7, needle22);
  11099 }
  11100 {
  11101   smallStringt * self8;
  11102   char * needle0;
  11103   indexOfG(self8, needle0);
  11104   const char * needle1;
  11105   indexOfG(self8, needle1);
  11106   char needle2;
  11107   indexOfG(self8, needle2);
  11108   int needle3;
  11109   indexOfG(self8, needle3);
  11110   smallJsont * needle4;
  11111   indexOfG(self8, needle4);
  11112   smallStringt * needle5;
  11113   indexOfG(self8, needle5);
  11114   const char * needle6;
  11115   indexOfG(self8, needle6);
  11116 }
  11117 {
  11118   char * self1;
  11119   char * needle0;
  11120   keyByG(self1, needle0);
  11121   const char * needle1;
  11122   keyByG(self1, needle1);
  11123   char needle2;
  11124   keyByG(self1, needle2);
  11125   int needle3;
  11126   keyByG(self1, needle3);
  11127   const char * needle4;
  11128   keyByG(self1, needle4);
  11129 }
  11130 {
  11131   const char * self2;
  11132   char * needle0;
  11133   keyByG(self2, needle0);
  11134   const char * needle1;
  11135   keyByG(self2, needle1);
  11136   char needle2;
  11137   keyByG(self2, needle2);
  11138   int needle3;
  11139   keyByG(self2, needle3);
  11140   const char * needle4;
  11141   keyByG(self2, needle4);
  11142 }
  11143 {
  11144   char ** self3;
  11145   char * needle0;
  11146   keyByG(self3, needle0);
  11147   const char * needle1;
  11148   keyByG(self3, needle1);
  11149   char needle2;
  11150   keyByG(self3, needle2);
  11151   int needle3;
  11152   keyByG(self3, needle3);
  11153   const char * needle4;
  11154   keyByG(self3, needle4);
  11155 }
  11156 {
  11157   const char ** self4;
  11158   char * needle0;
  11159   keyByG(self4, needle0);
  11160   const char * needle1;
  11161   keyByG(self4, needle1);
  11162   char needle2;
  11163   keyByG(self4, needle2);
  11164   int needle3;
  11165   keyByG(self4, needle3);
  11166   const char * needle4;
  11167   keyByG(self4, needle4);
  11168 }
  11169 {
  11170   smallArrayt* self5;
  11171   baset* needle0;
  11172   keyByG(self5, needle0);
  11173   bool needle1;
  11174   keyByG(self5, needle1);
  11175   double needle2;
  11176   keyByG(self5, needle2);
  11177   int64_t needle3;
  11178   keyByG(self5, needle3);
  11179   int32_t needle4;
  11180   keyByG(self5, needle4);
  11181   uint32_t needle5;
  11182   keyByG(self5, needle5);
  11183   uint64_t needle6;
  11184   keyByG(self5, needle6);
  11185   char* needle7;
  11186   keyByG(self5, needle7);
  11187   char needle8;
  11188   keyByG(self5, needle8);
  11189   const char* needle9;
  11190   keyByG(self5, needle9);
  11191   smallDictt* needle10;
  11192   keyByG(self5, needle10);
  11193   smallArrayt* needle11;
  11194   keyByG(self5, needle11);
  11195   char ** needle12;
  11196   keyByG(self5, needle12);
  11197   const char ** needle13;
  11198   keyByG(self5, needle13);
  11199   smallBoolt* needle14;
  11200   keyByG(self5, needle14);
  11201   smallBytest* needle15;
  11202   keyByG(self5, needle15);
  11203   smallDoublet* needle16;
  11204   keyByG(self5, needle16);
  11205   smallIntt* needle17;
  11206   keyByG(self5, needle17);
  11207   smallJsont* needle18;
  11208   keyByG(self5, needle18);
  11209   smallStringt* needle19;
  11210   keyByG(self5, needle19);
  11211   smallContainert* needle20;
  11212   keyByG(self5, needle20);
  11213   undefinedt* needle21;
  11214   keyByG(self5, needle21);
  11215   undefinedt * needle22;
  11216   keyByG(self5, needle22);
  11217 }
  11218 {
  11219   smallDictt* self6;
  11220   baset* needle0;
  11221   keyByG(self6, needle0);
  11222   bool needle1;
  11223   keyByG(self6, needle1);
  11224   double needle2;
  11225   keyByG(self6, needle2);
  11226   int64_t needle3;
  11227   keyByG(self6, needle3);
  11228   int32_t needle4;
  11229   keyByG(self6, needle4);
  11230   uint32_t needle5;
  11231   keyByG(self6, needle5);
  11232   uint64_t needle6;
  11233   keyByG(self6, needle6);
  11234   char* needle7;
  11235   keyByG(self6, needle7);
  11236   char needle8;
  11237   keyByG(self6, needle8);
  11238   const char* needle9;
  11239   keyByG(self6, needle9);
  11240   smallDictt* needle10;
  11241   keyByG(self6, needle10);
  11242   smallArrayt* needle11;
  11243   keyByG(self6, needle11);
  11244   char ** needle12;
  11245   keyByG(self6, needle12);
  11246   const char ** needle13;
  11247   keyByG(self6, needle13);
  11248   smallBoolt* needle14;
  11249   keyByG(self6, needle14);
  11250   smallBytest* needle15;
  11251   keyByG(self6, needle15);
  11252   smallDoublet* needle16;
  11253   keyByG(self6, needle16);
  11254   smallIntt* needle17;
  11255   keyByG(self6, needle17);
  11256   smallJsont* needle18;
  11257   keyByG(self6, needle18);
  11258   smallStringt* needle19;
  11259   keyByG(self6, needle19);
  11260   smallContainert* needle20;
  11261   keyByG(self6, needle20);
  11262   undefinedt* needle21;
  11263   keyByG(self6, needle21);
  11264   undefinedt * needle22;
  11265   keyByG(self6, needle22);
  11266 }
  11267 {
  11268   smallJsont* self7;
  11269   baset* needle0;
  11270   keyByG(self7, needle0);
  11271   bool needle1;
  11272   keyByG(self7, needle1);
  11273   double needle2;
  11274   keyByG(self7, needle2);
  11275   int64_t needle3;
  11276   keyByG(self7, needle3);
  11277   int32_t needle4;
  11278   keyByG(self7, needle4);
  11279   uint32_t needle5;
  11280   keyByG(self7, needle5);
  11281   uint64_t needle6;
  11282   keyByG(self7, needle6);
  11283   char* needle7;
  11284   keyByG(self7, needle7);
  11285   char needle8;
  11286   keyByG(self7, needle8);
  11287   const char* needle9;
  11288   keyByG(self7, needle9);
  11289   smallDictt* needle10;
  11290   keyByG(self7, needle10);
  11291   smallArrayt* needle11;
  11292   keyByG(self7, needle11);
  11293   char ** needle12;
  11294   keyByG(self7, needle12);
  11295   const char ** needle13;
  11296   keyByG(self7, needle13);
  11297   smallBoolt* needle14;
  11298   keyByG(self7, needle14);
  11299   smallBytest* needle15;
  11300   keyByG(self7, needle15);
  11301   smallDoublet* needle16;
  11302   keyByG(self7, needle16);
  11303   smallIntt* needle17;
  11304   keyByG(self7, needle17);
  11305   smallJsont* needle18;
  11306   keyByG(self7, needle18);
  11307   smallStringt* needle19;
  11308   keyByG(self7, needle19);
  11309   smallContainert* needle20;
  11310   keyByG(self7, needle20);
  11311   undefinedt* needle21;
  11312   keyByG(self7, needle21);
  11313   undefinedt * needle22;
  11314   keyByG(self7, needle22);
  11315 }
  11316 {
  11317   smallStringt * self8;
  11318   char * needle0;
  11319   keyByG(self8, needle0);
  11320   const char * needle1;
  11321   keyByG(self8, needle1);
  11322   char needle2;
  11323   keyByG(self8, needle2);
  11324   int needle3;
  11325   keyByG(self8, needle3);
  11326   smallJsont * needle4;
  11327   keyByG(self8, needle4);
  11328   smallStringt * needle5;
  11329   keyByG(self8, needle5);
  11330   const char * needle6;
  11331   keyByG(self8, needle6);
  11332 }
  11333 {
  11334   char * self1;
  11335   char * needle0;
  11336   icFindG(self1, needle0);
  11337   const char * needle1;
  11338   icFindG(self1, needle1);
  11339   char needle2;
  11340   icFindG(self1, needle2);
  11341   int needle3;
  11342   icFindG(self1, needle3);
  11343   const char * needle4;
  11344   icFindG(self1, needle4);
  11345 }
  11346 {
  11347   const char * self2;
  11348   char * needle0;
  11349   icFindG(self2, needle0);
  11350   const char * needle1;
  11351   icFindG(self2, needle1);
  11352   char needle2;
  11353   icFindG(self2, needle2);
  11354   int needle3;
  11355   icFindG(self2, needle3);
  11356   const char * needle4;
  11357   icFindG(self2, needle4);
  11358 }
  11359 {
  11360   char ** self3;
  11361   const char * needle0;
  11362   icFindG(self3, needle0);
  11363 }
  11364 {
  11365   const char ** self4;
  11366   const char * needle0;
  11367   icFindG(self4, needle0);
  11368 }
  11369 {
  11370   smallArrayt * self5;
  11371   char * needle0;
  11372   icFindG(self5, needle0);
  11373   const char * needle1;
  11374   icFindG(self5, needle1);
  11375   char needle2;
  11376   icFindG(self5, needle2);
  11377   int needle3;
  11378   icFindG(self5, needle3);
  11379   smallJsont* needle4;
  11380   icFindG(self5, needle4);
  11381   smallStringt* needle5;
  11382   icFindG(self5, needle5);
  11383 }
  11384 {
  11385   smallJsont * self6;
  11386   char * needle0;
  11387   icFindG(self6, needle0);
  11388   const char * needle1;
  11389   icFindG(self6, needle1);
  11390   char needle2;
  11391   icFindG(self6, needle2);
  11392   int needle3;
  11393   icFindG(self6, needle3);
  11394   smallJsont * needle4;
  11395   icFindG(self6, needle4);
  11396   smallStringt * needle5;
  11397   icFindG(self6, needle5);
  11398 }
  11399 {
  11400   smallStringt * self7;
  11401   char * needle0;
  11402   icFindG(self7, needle0);
  11403   const char * needle1;
  11404   icFindG(self7, needle1);
  11405   char needle2;
  11406   icFindG(self7, needle2);
  11407   int needle3;
  11408   icFindG(self7, needle3);
  11409   smallJsont * needle4;
  11410   icFindG(self7, needle4);
  11411   smallStringt * needle5;
  11412   icFindG(self7, needle5);
  11413 }
  11414 {
  11415   char * self1;
  11416   char * needle0;
  11417   icHasG(self1, needle0);
  11418   const char * needle1;
  11419   icHasG(self1, needle1);
  11420   char needle2;
  11421   icHasG(self1, needle2);
  11422   int needle3;
  11423   icHasG(self1, needle3);
  11424   const char * needle4;
  11425   icHasG(self1, needle4);
  11426 }
  11427 {
  11428   const char * self2;
  11429   char * needle0;
  11430   icHasG(self2, needle0);
  11431   const char * needle1;
  11432   icHasG(self2, needle1);
  11433   char needle2;
  11434   icHasG(self2, needle2);
  11435   int needle3;
  11436   icHasG(self2, needle3);
  11437   const char * needle4;
  11438   icHasG(self2, needle4);
  11439 }
  11440 {
  11441   char ** self3;
  11442   char * needle0;
  11443   icHasG(self3, needle0);
  11444   const char * needle1;
  11445   icHasG(self3, needle1);
  11446   char needle2;
  11447   icHasG(self3, needle2);
  11448   int needle3;
  11449   icHasG(self3, needle3);
  11450   const char * needle4;
  11451   icHasG(self3, needle4);
  11452 }
  11453 {
  11454   const char ** self4;
  11455   char * needle0;
  11456   icHasG(self4, needle0);
  11457   const char * needle1;
  11458   icHasG(self4, needle1);
  11459   char needle2;
  11460   icHasG(self4, needle2);
  11461   int needle3;
  11462   icHasG(self4, needle3);
  11463   const char * needle4;
  11464   icHasG(self4, needle4);
  11465 }
  11466 {
  11467   smallArrayt* self5;
  11468   baset* needle0;
  11469   icHasG(self5, needle0);
  11470   bool needle1;
  11471   icHasG(self5, needle1);
  11472   double needle2;
  11473   icHasG(self5, needle2);
  11474   int64_t needle3;
  11475   icHasG(self5, needle3);
  11476   int32_t needle4;
  11477   icHasG(self5, needle4);
  11478   uint32_t needle5;
  11479   icHasG(self5, needle5);
  11480   uint64_t needle6;
  11481   icHasG(self5, needle6);
  11482   char* needle7;
  11483   icHasG(self5, needle7);
  11484   char needle8;
  11485   icHasG(self5, needle8);
  11486   const char* needle9;
  11487   icHasG(self5, needle9);
  11488   smallDictt* needle10;
  11489   icHasG(self5, needle10);
  11490   smallArrayt* needle11;
  11491   icHasG(self5, needle11);
  11492   char ** needle12;
  11493   icHasG(self5, needle12);
  11494   const char ** needle13;
  11495   icHasG(self5, needle13);
  11496   smallBoolt* needle14;
  11497   icHasG(self5, needle14);
  11498   smallBytest* needle15;
  11499   icHasG(self5, needle15);
  11500   smallDoublet* needle16;
  11501   icHasG(self5, needle16);
  11502   smallIntt* needle17;
  11503   icHasG(self5, needle17);
  11504   smallJsont* needle18;
  11505   icHasG(self5, needle18);
  11506   smallStringt* needle19;
  11507   icHasG(self5, needle19);
  11508   smallContainert* needle20;
  11509   icHasG(self5, needle20);
  11510   undefinedt* needle21;
  11511   icHasG(self5, needle21);
  11512   undefinedt * needle22;
  11513   icHasG(self5, needle22);
  11514 }
  11515 {
  11516   smallJsont* self6;
  11517   baset* needle0;
  11518   icHasG(self6, needle0);
  11519   bool needle1;
  11520   icHasG(self6, needle1);
  11521   double needle2;
  11522   icHasG(self6, needle2);
  11523   int64_t needle3;
  11524   icHasG(self6, needle3);
  11525   int32_t needle4;
  11526   icHasG(self6, needle4);
  11527   uint32_t needle5;
  11528   icHasG(self6, needle5);
  11529   uint64_t needle6;
  11530   icHasG(self6, needle6);
  11531   char* needle7;
  11532   icHasG(self6, needle7);
  11533   char needle8;
  11534   icHasG(self6, needle8);
  11535   const char* needle9;
  11536   icHasG(self6, needle9);
  11537   smallDictt* needle10;
  11538   icHasG(self6, needle10);
  11539   smallArrayt* needle11;
  11540   icHasG(self6, needle11);
  11541   char ** needle12;
  11542   icHasG(self6, needle12);
  11543   const char ** needle13;
  11544   icHasG(self6, needle13);
  11545   smallBoolt* needle14;
  11546   icHasG(self6, needle14);
  11547   smallBytest* needle15;
  11548   icHasG(self6, needle15);
  11549   smallDoublet* needle16;
  11550   icHasG(self6, needle16);
  11551   smallIntt* needle17;
  11552   icHasG(self6, needle17);
  11553   smallJsont* needle18;
  11554   icHasG(self6, needle18);
  11555   smallStringt* needle19;
  11556   icHasG(self6, needle19);
  11557   smallContainert* needle20;
  11558   icHasG(self6, needle20);
  11559   undefinedt* needle21;
  11560   icHasG(self6, needle21);
  11561   undefinedt * needle22;
  11562   icHasG(self6, needle22);
  11563 }
  11564 {
  11565   smallDictt * self7;
  11566   char * needle0;
  11567   icHasG(self7, needle0);
  11568   const char * needle1;
  11569   icHasG(self7, needle1);
  11570   char needle2;
  11571   icHasG(self7, needle2);
  11572   int needle3;
  11573   icHasG(self7, needle3);
  11574   const char * needle4;
  11575   icHasG(self7, needle4);
  11576 }
  11577 {
  11578   smallStringt * self8;
  11579   char * needle0;
  11580   icHasG(self8, needle0);
  11581   const char * needle1;
  11582   icHasG(self8, needle1);
  11583   char needle2;
  11584   icHasG(self8, needle2);
  11585   int needle3;
  11586   icHasG(self8, needle3);
  11587   smallJsont * needle4;
  11588   icHasG(self8, needle4);
  11589   smallStringt * needle5;
  11590   icHasG(self8, needle5);
  11591   const char * needle6;
  11592   icHasG(self8, needle6);
  11593 }
  11594 {
  11595   char * self1;
  11596   char * needle0;
  11597   icIndexOfG(self1, needle0);
  11598   const char * needle1;
  11599   icIndexOfG(self1, needle1);
  11600   char needle2;
  11601   icIndexOfG(self1, needle2);
  11602   int needle3;
  11603   icIndexOfG(self1, needle3);
  11604   const char * needle4;
  11605   icIndexOfG(self1, needle4);
  11606 }
  11607 {
  11608   const char * self2;
  11609   char * needle0;
  11610   icIndexOfG(self2, needle0);
  11611   const char * needle1;
  11612   icIndexOfG(self2, needle1);
  11613   char needle2;
  11614   icIndexOfG(self2, needle2);
  11615   int needle3;
  11616   icIndexOfG(self2, needle3);
  11617   const char * needle4;
  11618   icIndexOfG(self2, needle4);
  11619 }
  11620 {
  11621   char ** self3;
  11622   char * needle0;
  11623   icIndexOfG(self3, needle0);
  11624   const char * needle1;
  11625   icIndexOfG(self3, needle1);
  11626   char needle2;
  11627   icIndexOfG(self3, needle2);
  11628   int needle3;
  11629   icIndexOfG(self3, needle3);
  11630   const char * needle4;
  11631   icIndexOfG(self3, needle4);
  11632 }
  11633 {
  11634   const char ** self4;
  11635   char * needle0;
  11636   icIndexOfG(self4, needle0);
  11637   const char * needle1;
  11638   icIndexOfG(self4, needle1);
  11639   char needle2;
  11640   icIndexOfG(self4, needle2);
  11641   int needle3;
  11642   icIndexOfG(self4, needle3);
  11643   const char * needle4;
  11644   icIndexOfG(self4, needle4);
  11645 }
  11646 {
  11647   smallArrayt* self5;
  11648   baset* needle0;
  11649   icIndexOfG(self5, needle0);
  11650   bool needle1;
  11651   icIndexOfG(self5, needle1);
  11652   double needle2;
  11653   icIndexOfG(self5, needle2);
  11654   int64_t needle3;
  11655   icIndexOfG(self5, needle3);
  11656   int32_t needle4;
  11657   icIndexOfG(self5, needle4);
  11658   uint32_t needle5;
  11659   icIndexOfG(self5, needle5);
  11660   uint64_t needle6;
  11661   icIndexOfG(self5, needle6);
  11662   char* needle7;
  11663   icIndexOfG(self5, needle7);
  11664   char needle8;
  11665   icIndexOfG(self5, needle8);
  11666   const char* needle9;
  11667   icIndexOfG(self5, needle9);
  11668   smallDictt* needle10;
  11669   icIndexOfG(self5, needle10);
  11670   smallArrayt* needle11;
  11671   icIndexOfG(self5, needle11);
  11672   char ** needle12;
  11673   icIndexOfG(self5, needle12);
  11674   const char ** needle13;
  11675   icIndexOfG(self5, needle13);
  11676   smallBoolt* needle14;
  11677   icIndexOfG(self5, needle14);
  11678   smallBytest* needle15;
  11679   icIndexOfG(self5, needle15);
  11680   smallDoublet* needle16;
  11681   icIndexOfG(self5, needle16);
  11682   smallIntt* needle17;
  11683   icIndexOfG(self5, needle17);
  11684   smallJsont* needle18;
  11685   icIndexOfG(self5, needle18);
  11686   smallStringt* needle19;
  11687   icIndexOfG(self5, needle19);
  11688   smallContainert* needle20;
  11689   icIndexOfG(self5, needle20);
  11690   undefinedt* needle21;
  11691   icIndexOfG(self5, needle21);
  11692   undefinedt * needle22;
  11693   icIndexOfG(self5, needle22);
  11694 }
  11695 {
  11696   smallJsont* self6;
  11697   baset* needle0;
  11698   icIndexOfG(self6, needle0);
  11699   bool needle1;
  11700   icIndexOfG(self6, needle1);
  11701   double needle2;
  11702   icIndexOfG(self6, needle2);
  11703   int64_t needle3;
  11704   icIndexOfG(self6, needle3);
  11705   int32_t needle4;
  11706   icIndexOfG(self6, needle4);
  11707   uint32_t needle5;
  11708   icIndexOfG(self6, needle5);
  11709   uint64_t needle6;
  11710   icIndexOfG(self6, needle6);
  11711   char* needle7;
  11712   icIndexOfG(self6, needle7);
  11713   char needle8;
  11714   icIndexOfG(self6, needle8);
  11715   const char* needle9;
  11716   icIndexOfG(self6, needle9);
  11717   smallDictt* needle10;
  11718   icIndexOfG(self6, needle10);
  11719   smallArrayt* needle11;
  11720   icIndexOfG(self6, needle11);
  11721   char ** needle12;
  11722   icIndexOfG(self6, needle12);
  11723   const char ** needle13;
  11724   icIndexOfG(self6, needle13);
  11725   smallBoolt* needle14;
  11726   icIndexOfG(self6, needle14);
  11727   smallBytest* needle15;
  11728   icIndexOfG(self6, needle15);
  11729   smallDoublet* needle16;
  11730   icIndexOfG(self6, needle16);
  11731   smallIntt* needle17;
  11732   icIndexOfG(self6, needle17);
  11733   smallJsont* needle18;
  11734   icIndexOfG(self6, needle18);
  11735   smallStringt* needle19;
  11736   icIndexOfG(self6, needle19);
  11737   smallContainert* needle20;
  11738   icIndexOfG(self6, needle20);
  11739   undefinedt* needle21;
  11740   icIndexOfG(self6, needle21);
  11741   undefinedt * needle22;
  11742   icIndexOfG(self6, needle22);
  11743 }
  11744 {
  11745   smallDictt* self7;
  11746   baset* needle0;
  11747   icIndexOfG(self7, needle0);
  11748   bool needle1;
  11749   icIndexOfG(self7, needle1);
  11750   double needle2;
  11751   icIndexOfG(self7, needle2);
  11752   int64_t needle3;
  11753   icIndexOfG(self7, needle3);
  11754   int32_t needle4;
  11755   icIndexOfG(self7, needle4);
  11756   uint32_t needle5;
  11757   icIndexOfG(self7, needle5);
  11758   uint64_t needle6;
  11759   icIndexOfG(self7, needle6);
  11760   char* needle7;
  11761   icIndexOfG(self7, needle7);
  11762   char needle8;
  11763   icIndexOfG(self7, needle8);
  11764   const char* needle9;
  11765   icIndexOfG(self7, needle9);
  11766   smallDictt* needle10;
  11767   icIndexOfG(self7, needle10);
  11768   smallArrayt* needle11;
  11769   icIndexOfG(self7, needle11);
  11770   char ** needle12;
  11771   icIndexOfG(self7, needle12);
  11772   const char ** needle13;
  11773   icIndexOfG(self7, needle13);
  11774   smallBoolt* needle14;
  11775   icIndexOfG(self7, needle14);
  11776   smallBytest* needle15;
  11777   icIndexOfG(self7, needle15);
  11778   smallDoublet* needle16;
  11779   icIndexOfG(self7, needle16);
  11780   smallIntt* needle17;
  11781   icIndexOfG(self7, needle17);
  11782   smallJsont* needle18;
  11783   icIndexOfG(self7, needle18);
  11784   smallStringt* needle19;
  11785   icIndexOfG(self7, needle19);
  11786   smallContainert* needle20;
  11787   icIndexOfG(self7, needle20);
  11788   undefinedt* needle21;
  11789   icIndexOfG(self7, needle21);
  11790   undefinedt * needle22;
  11791   icIndexOfG(self7, needle22);
  11792 }
  11793 {
  11794   smallStringt * self8;
  11795   char * needle0;
  11796   icIndexOfG(self8, needle0);
  11797   const char * needle1;
  11798   icIndexOfG(self8, needle1);
  11799   char needle2;
  11800   icIndexOfG(self8, needle2);
  11801   int needle3;
  11802   icIndexOfG(self8, needle3);
  11803   smallJsont * needle4;
  11804   icIndexOfG(self8, needle4);
  11805   smallStringt * needle5;
  11806   icIndexOfG(self8, needle5);
  11807   const char * needle6;
  11808   icIndexOfG(self8, needle6);
  11809 }
  11810 {
  11811   char * self1;
  11812   char * needle0;
  11813   icKeyByG(self1, needle0);
  11814   const char * needle1;
  11815   icKeyByG(self1, needle1);
  11816   char needle2;
  11817   icKeyByG(self1, needle2);
  11818   int needle3;
  11819   icKeyByG(self1, needle3);
  11820   const char * needle4;
  11821   icKeyByG(self1, needle4);
  11822 }
  11823 {
  11824   const char * self2;
  11825   char * needle0;
  11826   icKeyByG(self2, needle0);
  11827   const char * needle1;
  11828   icKeyByG(self2, needle1);
  11829   char needle2;
  11830   icKeyByG(self2, needle2);
  11831   int needle3;
  11832   icKeyByG(self2, needle3);
  11833   const char * needle4;
  11834   icKeyByG(self2, needle4);
  11835 }
  11836 {
  11837   char ** self3;
  11838   char * needle0;
  11839   icKeyByG(self3, needle0);
  11840   const char * needle1;
  11841   icKeyByG(self3, needle1);
  11842   char needle2;
  11843   icKeyByG(self3, needle2);
  11844   int needle3;
  11845   icKeyByG(self3, needle3);
  11846   const char * needle4;
  11847   icKeyByG(self3, needle4);
  11848 }
  11849 {
  11850   const char ** self4;
  11851   char * needle0;
  11852   icKeyByG(self4, needle0);
  11853   const char * needle1;
  11854   icKeyByG(self4, needle1);
  11855   char needle2;
  11856   icKeyByG(self4, needle2);
  11857   int needle3;
  11858   icKeyByG(self4, needle3);
  11859   const char * needle4;
  11860   icKeyByG(self4, needle4);
  11861 }
  11862 {
  11863   smallArrayt* self5;
  11864   baset* needle0;
  11865   icKeyByG(self5, needle0);
  11866   bool needle1;
  11867   icKeyByG(self5, needle1);
  11868   double needle2;
  11869   icKeyByG(self5, needle2);
  11870   int64_t needle3;
  11871   icKeyByG(self5, needle3);
  11872   int32_t needle4;
  11873   icKeyByG(self5, needle4);
  11874   uint32_t needle5;
  11875   icKeyByG(self5, needle5);
  11876   uint64_t needle6;
  11877   icKeyByG(self5, needle6);
  11878   char* needle7;
  11879   icKeyByG(self5, needle7);
  11880   char needle8;
  11881   icKeyByG(self5, needle8);
  11882   const char* needle9;
  11883   icKeyByG(self5, needle9);
  11884   smallDictt* needle10;
  11885   icKeyByG(self5, needle10);
  11886   smallArrayt* needle11;
  11887   icKeyByG(self5, needle11);
  11888   char ** needle12;
  11889   icKeyByG(self5, needle12);
  11890   const char ** needle13;
  11891   icKeyByG(self5, needle13);
  11892   smallBoolt* needle14;
  11893   icKeyByG(self5, needle14);
  11894   smallBytest* needle15;
  11895   icKeyByG(self5, needle15);
  11896   smallDoublet* needle16;
  11897   icKeyByG(self5, needle16);
  11898   smallIntt* needle17;
  11899   icKeyByG(self5, needle17);
  11900   smallJsont* needle18;
  11901   icKeyByG(self5, needle18);
  11902   smallStringt* needle19;
  11903   icKeyByG(self5, needle19);
  11904   smallContainert* needle20;
  11905   icKeyByG(self5, needle20);
  11906   undefinedt* needle21;
  11907   icKeyByG(self5, needle21);
  11908   undefinedt * needle22;
  11909   icKeyByG(self5, needle22);
  11910 }
  11911 {
  11912   smallDictt* self6;
  11913   baset* needle0;
  11914   icKeyByG(self6, needle0);
  11915   bool needle1;
  11916   icKeyByG(self6, needle1);
  11917   double needle2;
  11918   icKeyByG(self6, needle2);
  11919   int64_t needle3;
  11920   icKeyByG(self6, needle3);
  11921   int32_t needle4;
  11922   icKeyByG(self6, needle4);
  11923   uint32_t needle5;
  11924   icKeyByG(self6, needle5);
  11925   uint64_t needle6;
  11926   icKeyByG(self6, needle6);
  11927   char* needle7;
  11928   icKeyByG(self6, needle7);
  11929   char needle8;
  11930   icKeyByG(self6, needle8);
  11931   const char* needle9;
  11932   icKeyByG(self6, needle9);
  11933   smallDictt* needle10;
  11934   icKeyByG(self6, needle10);
  11935   smallArrayt* needle11;
  11936   icKeyByG(self6, needle11);
  11937   char ** needle12;
  11938   icKeyByG(self6, needle12);
  11939   const char ** needle13;
  11940   icKeyByG(self6, needle13);
  11941   smallBoolt* needle14;
  11942   icKeyByG(self6, needle14);
  11943   smallBytest* needle15;
  11944   icKeyByG(self6, needle15);
  11945   smallDoublet* needle16;
  11946   icKeyByG(self6, needle16);
  11947   smallIntt* needle17;
  11948   icKeyByG(self6, needle17);
  11949   smallJsont* needle18;
  11950   icKeyByG(self6, needle18);
  11951   smallStringt* needle19;
  11952   icKeyByG(self6, needle19);
  11953   smallContainert* needle20;
  11954   icKeyByG(self6, needle20);
  11955   undefinedt* needle21;
  11956   icKeyByG(self6, needle21);
  11957   undefinedt * needle22;
  11958   icKeyByG(self6, needle22);
  11959 }
  11960 {
  11961   smallJsont* self7;
  11962   baset* needle0;
  11963   icKeyByG(self7, needle0);
  11964   bool needle1;
  11965   icKeyByG(self7, needle1);
  11966   double needle2;
  11967   icKeyByG(self7, needle2);
  11968   int64_t needle3;
  11969   icKeyByG(self7, needle3);
  11970   int32_t needle4;
  11971   icKeyByG(self7, needle4);
  11972   uint32_t needle5;
  11973   icKeyByG(self7, needle5);
  11974   uint64_t needle6;
  11975   icKeyByG(self7, needle6);
  11976   char* needle7;
  11977   icKeyByG(self7, needle7);
  11978   char needle8;
  11979   icKeyByG(self7, needle8);
  11980   const char* needle9;
  11981   icKeyByG(self7, needle9);
  11982   smallDictt* needle10;
  11983   icKeyByG(self7, needle10);
  11984   smallArrayt* needle11;
  11985   icKeyByG(self7, needle11);
  11986   char ** needle12;
  11987   icKeyByG(self7, needle12);
  11988   const char ** needle13;
  11989   icKeyByG(self7, needle13);
  11990   smallBoolt* needle14;
  11991   icKeyByG(self7, needle14);
  11992   smallBytest* needle15;
  11993   icKeyByG(self7, needle15);
  11994   smallDoublet* needle16;
  11995   icKeyByG(self7, needle16);
  11996   smallIntt* needle17;
  11997   icKeyByG(self7, needle17);
  11998   smallJsont* needle18;
  11999   icKeyByG(self7, needle18);
  12000   smallStringt* needle19;
  12001   icKeyByG(self7, needle19);
  12002   smallContainert* needle20;
  12003   icKeyByG(self7, needle20);
  12004   undefinedt* needle21;
  12005   icKeyByG(self7, needle21);
  12006   undefinedt * needle22;
  12007   icKeyByG(self7, needle22);
  12008 }
  12009 {
  12010   smallStringt * self8;
  12011   char * needle0;
  12012   icKeyByG(self8, needle0);
  12013   const char * needle1;
  12014   icKeyByG(self8, needle1);
  12015   char needle2;
  12016   icKeyByG(self8, needle2);
  12017   int needle3;
  12018   icKeyByG(self8, needle3);
  12019   smallJsont * needle4;
  12020   icKeyByG(self8, needle4);
  12021   smallStringt * needle5;
  12022   icKeyByG(self8, needle5);
  12023   const char * needle6;
  12024   icKeyByG(self8, needle6);
  12025 }
  12026 {
  12027   char ** self0;
  12028   emptyG(self0);
  12029   char *** self1;
  12030   emptyG(self1);
  12031   smallArrayt * self2;
  12032   emptyG(self2);
  12033   smallDictt * self3;
  12034   emptyG(self3);
  12035   smallJsont * self4;
  12036   emptyG(self4);
  12037   smallStringt * self5;
  12038   emptyG(self5);
  12039 }
  12040 {
  12041   char * self0;
  12042   isEmptyG(self0);
  12043   const char * self1;
  12044   isEmptyG(self1);
  12045   char ** self2;
  12046   isEmptyG(self2);
  12047   smallArrayt * self3;
  12048   isEmptyG(self3);
  12049   smallBytest * self4;
  12050   isEmptyG(self4);
  12051   smallDictt * self5;
  12052   isEmptyG(self5);
  12053   smallJsont * self6;
  12054   isEmptyG(self6);
  12055   smallStringt * self7;
  12056   isEmptyG(self7);
  12057 }
  12058 {
  12059   char * self0;
  12060   isBlankG(self0);
  12061   const char * self1;
  12062   isBlankG(self1);
  12063   char ** self2;
  12064   isBlankG(self2);
  12065   smallArrayt * self3;
  12066   isBlankG(self3);
  12067   smallDictt * self4;
  12068   isBlankG(self4);
  12069   smallJsont * self5;
  12070   isBlankG(self5);
  12071   smallStringt * self6;
  12072   isBlankG(self6);
  12073 }
  12074 {
  12075   char ** self1;
  12076   char ** array0;
  12077   size_t size1;
  12078   fromArrayG(self1, array0, size1);
  12079   const char ** array1;
  12080   fromArrayG(self1, array1, size1);
  12081 }
  12082 {
  12083   smallArrayt * self2;
  12084   char ** array0;
  12085   size_t size1;
  12086   fromArrayG(self2, array0, size1);
  12087   const char ** array1;
  12088   fromArrayG(self2, array1, size1);
  12089 }
  12090 {
  12091   smallJsont * self3;
  12092   char ** array0;
  12093   size_t size1;
  12094   fromArrayG(self3, array0, size1);
  12095   const char ** array1;
  12096   fromArrayG(self3, array1, size1);
  12097 }
  12098 {
  12099   char * self1;
  12100   char * delim0;
  12101   splitG(self1, delim0);
  12102   const char * delim1;
  12103   splitG(self1, delim1);
  12104   char delim2;
  12105   splitG(self1, delim2);
  12106   int delim3;
  12107   splitG(self1, delim3);
  12108   const char* delim4;
  12109   splitG(self1, delim4);
  12110 }
  12111 {
  12112   const char * self2;
  12113   char * delim0;
  12114   splitG(self2, delim0);
  12115   const char * delim1;
  12116   splitG(self2, delim1);
  12117   char delim2;
  12118   splitG(self2, delim2);
  12119   int delim3;
  12120   splitG(self2, delim3);
  12121   const char* delim4;
  12122   splitG(self2, delim4);
  12123 }
  12124 {
  12125   smallJsont * self3;
  12126   char * delim0;
  12127   splitG(self3, delim0);
  12128   const char * delim1;
  12129   splitG(self3, delim1);
  12130   char delim2;
  12131   splitG(self3, delim2);
  12132   int delim3;
  12133   splitG(self3, delim3);
  12134   smallJsont * delim4;
  12135   splitG(self3, delim4);
  12136   smallStringt * delim5;
  12137   splitG(self3, delim5);
  12138 }
  12139 {
  12140   smallStringt * self4;
  12141   char * delim0;
  12142   splitG(self4, delim0);
  12143   const char * delim1;
  12144   splitG(self4, delim1);
  12145   char delim2;
  12146   splitG(self4, delim2);
  12147   int delim3;
  12148   splitG(self4, delim3);
  12149   smallJsont * delim4;
  12150   splitG(self4, delim4);
  12151   smallStringt * delim5;
  12152   splitG(self4, delim5);
  12153 }
  12154 {
  12155   char * self1;
  12156   char * delim0;
  12157   icSplitG(self1, delim0);
  12158   const char * delim1;
  12159   icSplitG(self1, delim1);
  12160   char delim2;
  12161   icSplitG(self1, delim2);
  12162   int delim3;
  12163   icSplitG(self1, delim3);
  12164   const char* delim4;
  12165   icSplitG(self1, delim4);
  12166 }
  12167 {
  12168   const char * self2;
  12169   char * delim0;
  12170   icSplitG(self2, delim0);
  12171   const char * delim1;
  12172   icSplitG(self2, delim1);
  12173   char delim2;
  12174   icSplitG(self2, delim2);
  12175   int delim3;
  12176   icSplitG(self2, delim3);
  12177   const char* delim4;
  12178   icSplitG(self2, delim4);
  12179 }
  12180 {
  12181   smallJsont * self3;
  12182   char * delim0;
  12183   icSplitG(self3, delim0);
  12184   const char * delim1;
  12185   icSplitG(self3, delim1);
  12186   char delim2;
  12187   icSplitG(self3, delim2);
  12188   int delim3;
  12189   icSplitG(self3, delim3);
  12190   smallJsont * delim4;
  12191   icSplitG(self3, delim4);
  12192   smallStringt * delim5;
  12193   icSplitG(self3, delim5);
  12194 }
  12195 {
  12196   smallStringt * self4;
  12197   char * delim0;
  12198   icSplitG(self4, delim0);
  12199   const char * delim1;
  12200   icSplitG(self4, delim1);
  12201   char delim2;
  12202   icSplitG(self4, delim2);
  12203   int delim3;
  12204   icSplitG(self4, delim3);
  12205   smallJsont * delim4;
  12206   icSplitG(self4, delim4);
  12207   smallStringt * delim5;
  12208   icSplitG(self4, delim5);
  12209 }
  12210 {
  12211   char ** self1;
  12212   char * delim0;
  12213   joinG(self1, delim0);
  12214   const char * delim1;
  12215   joinG(self1, delim1);
  12216   char delim2;
  12217   joinG(self1, delim2);
  12218   int delim3;
  12219   joinG(self1, delim3);
  12220   const char* delim4;
  12221   joinG(self1, delim4);
  12222 }
  12223 {
  12224   const char ** self2;
  12225   char * delim0;
  12226   joinG(self2, delim0);
  12227   const char * delim1;
  12228   joinG(self2, delim1);
  12229   char delim2;
  12230   joinG(self2, delim2);
  12231   int delim3;
  12232   joinG(self2, delim3);
  12233   const char* delim4;
  12234   joinG(self2, delim4);
  12235 }
  12236 {
  12237   smallArrayt * self3;
  12238   char * delim0;
  12239   joinG(self3, delim0);
  12240   const char* delim1;
  12241   joinG(self3, delim1);
  12242   char delim2;
  12243   joinG(self3, delim2);
  12244   int delim3;
  12245   joinG(self3, delim3);
  12246   smallJsont * delim4;
  12247   joinG(self3, delim4);
  12248   smallStringt * delim5;
  12249   joinG(self3, delim5);
  12250 }
  12251 {
  12252   smallJsont * self4;
  12253   char * delim0;
  12254   joinG(self4, delim0);
  12255   const char* delim1;
  12256   joinG(self4, delim1);
  12257   char delim2;
  12258   joinG(self4, delim2);
  12259   int delim3;
  12260   joinG(self4, delim3);
  12261   smallJsont * delim4;
  12262   joinG(self4, delim4);
  12263   smallStringt * delim5;
  12264   joinG(self4, delim5);
  12265 }
  12266 {
  12267   char ** self1;
  12268   char * delim0;
  12269   joinSG(self1, delim0);
  12270   const char * delim1;
  12271   joinSG(self1, delim1);
  12272   char delim2;
  12273   joinSG(self1, delim2);
  12274   int delim3;
  12275   joinSG(self1, delim3);
  12276   const char* delim4;
  12277   joinSG(self1, delim4);
  12278 }
  12279 {
  12280   const char ** self2;
  12281   char * delim0;
  12282   joinSG(self2, delim0);
  12283   const char * delim1;
  12284   joinSG(self2, delim1);
  12285   char delim2;
  12286   joinSG(self2, delim2);
  12287   int delim3;
  12288   joinSG(self2, delim3);
  12289   const char* delim4;
  12290   joinSG(self2, delim4);
  12291 }
  12292 {
  12293   smallArrayt * self3;
  12294   char * delim0;
  12295   joinSG(self3, delim0);
  12296   const char* delim1;
  12297   joinSG(self3, delim1);
  12298   char delim2;
  12299   joinSG(self3, delim2);
  12300   int delim3;
  12301   joinSG(self3, delim3);
  12302   smallJsont * delim4;
  12303   joinSG(self3, delim4);
  12304   smallStringt * delim5;
  12305   joinSG(self3, delim5);
  12306 }
  12307 {
  12308   smallJsont * self4;
  12309   char * delim0;
  12310   joinSG(self4, delim0);
  12311   const char* delim1;
  12312   joinSG(self4, delim1);
  12313   char delim2;
  12314   joinSG(self4, delim2);
  12315   int delim3;
  12316   joinSG(self4, delim3);
  12317   smallJsont * delim4;
  12318   joinSG(self4, delim4);
  12319   smallStringt * delim5;
  12320   joinSG(self4, delim5);
  12321 }
  12322 {
  12323   char * self1;
  12324   char * delim11;
  12325   char * delim20;
  12326   extractG(self1, delim11, delim20);
  12327   const char * delim21;
  12328   extractG(self1, delim11, delim21);
  12329   char delim22;
  12330   extractG(self1, delim11, delim22);
  12331   int delim23;
  12332   extractG(self1, delim11, delim23);
  12333   const char* delim24;
  12334   extractG(self1, delim11, delim24);
  12335 }
  12336 {
  12337   char * self1;
  12338   const char * delim12;
  12339   char * delim20;
  12340   extractG(self1, delim12, delim20);
  12341   const char * delim21;
  12342   extractG(self1, delim12, delim21);
  12343   char delim22;
  12344   extractG(self1, delim12, delim22);
  12345   int delim23;
  12346   extractG(self1, delim12, delim23);
  12347   const char* delim24;
  12348   extractG(self1, delim12, delim24);
  12349 }
  12350 {
  12351   char * self1;
  12352   char delim13;
  12353   char * delim20;
  12354   extractG(self1, delim13, delim20);
  12355   const char * delim21;
  12356   extractG(self1, delim13, delim21);
  12357   char delim22;
  12358   extractG(self1, delim13, delim22);
  12359   int delim23;
  12360   extractG(self1, delim13, delim23);
  12361   const char* delim24;
  12362   extractG(self1, delim13, delim24);
  12363 }
  12364 {
  12365   char * self1;
  12366   int delim14;
  12367   char * delim20;
  12368   extractG(self1, delim14, delim20);
  12369   const char * delim21;
  12370   extractG(self1, delim14, delim21);
  12371   char delim22;
  12372   extractG(self1, delim14, delim22);
  12373   int delim23;
  12374   extractG(self1, delim14, delim23);
  12375   const char* delim24;
  12376   extractG(self1, delim14, delim24);
  12377 }
  12378 {
  12379   char * self1;
  12380   const char* delim10;
  12381   const char* delim20;
  12382   extractG(self1, delim10, delim20);
  12383 }
  12384 {
  12385   const char * self2;
  12386   char * delim16;
  12387   char * delim20;
  12388   extractG(self2, delim16, delim20);
  12389   const char * delim21;
  12390   extractG(self2, delim16, delim21);
  12391   char delim22;
  12392   extractG(self2, delim16, delim22);
  12393   int delim23;
  12394   extractG(self2, delim16, delim23);
  12395   const char* delim24;
  12396   extractG(self2, delim16, delim24);
  12397 }
  12398 {
  12399   const char * self2;
  12400   const char * delim17;
  12401   char * delim20;
  12402   extractG(self2, delim17, delim20);
  12403   const char * delim21;
  12404   extractG(self2, delim17, delim21);
  12405   char delim22;
  12406   extractG(self2, delim17, delim22);
  12407   int delim23;
  12408   extractG(self2, delim17, delim23);
  12409   const char* delim24;
  12410   extractG(self2, delim17, delim24);
  12411 }
  12412 {
  12413   const char * self2;
  12414   char delim18;
  12415   char * delim20;
  12416   extractG(self2, delim18, delim20);
  12417   const char * delim21;
  12418   extractG(self2, delim18, delim21);
  12419   char delim22;
  12420   extractG(self2, delim18, delim22);
  12421   int delim23;
  12422   extractG(self2, delim18, delim23);
  12423   const char* delim24;
  12424   extractG(self2, delim18, delim24);
  12425 }
  12426 {
  12427   const char * self2;
  12428   int delim19;
  12429   char * delim20;
  12430   extractG(self2, delim19, delim20);
  12431   const char * delim21;
  12432   extractG(self2, delim19, delim21);
  12433   char delim22;
  12434   extractG(self2, delim19, delim22);
  12435   int delim23;
  12436   extractG(self2, delim19, delim23);
  12437   const char* delim24;
  12438   extractG(self2, delim19, delim24);
  12439 }
  12440 {
  12441   const char * self2;
  12442   const char* delim10;
  12443   const char* delim20;
  12444   extractG(self2, delim10, delim20);
  12445 }
  12446 {
  12447   smallJsont * self3;
  12448   char * delim111;
  12449   char * delim20;
  12450   extractG(self3, delim111, delim20);
  12451   const char * delim21;
  12452   extractG(self3, delim111, delim21);
  12453   char delim22;
  12454   extractG(self3, delim111, delim22);
  12455   int delim23;
  12456   extractG(self3, delim111, delim23);
  12457   smallJsont * delim24;
  12458   extractG(self3, delim111, delim24);
  12459   smallStringt * delim25;
  12460   extractG(self3, delim111, delim25);
  12461 }
  12462 {
  12463   smallJsont * self3;
  12464   const char * delim112;
  12465   char * delim20;
  12466   extractG(self3, delim112, delim20);
  12467   const char * delim21;
  12468   extractG(self3, delim112, delim21);
  12469   char delim22;
  12470   extractG(self3, delim112, delim22);
  12471   int delim23;
  12472   extractG(self3, delim112, delim23);
  12473   smallJsont * delim24;
  12474   extractG(self3, delim112, delim24);
  12475   smallStringt * delim25;
  12476   extractG(self3, delim112, delim25);
  12477 }
  12478 {
  12479   smallJsont * self3;
  12480   char delim113;
  12481   char * delim20;
  12482   extractG(self3, delim113, delim20);
  12483   const char * delim21;
  12484   extractG(self3, delim113, delim21);
  12485   char delim22;
  12486   extractG(self3, delim113, delim22);
  12487   int delim23;
  12488   extractG(self3, delim113, delim23);
  12489   smallJsont * delim24;
  12490   extractG(self3, delim113, delim24);
  12491   smallStringt * delim25;
  12492   extractG(self3, delim113, delim25);
  12493 }
  12494 {
  12495   smallJsont * self3;
  12496   int delim114;
  12497   char * delim20;
  12498   extractG(self3, delim114, delim20);
  12499   const char * delim21;
  12500   extractG(self3, delim114, delim21);
  12501   char delim22;
  12502   extractG(self3, delim114, delim22);
  12503   int delim23;
  12504   extractG(self3, delim114, delim23);
  12505   smallJsont * delim24;
  12506   extractG(self3, delim114, delim24);
  12507   smallStringt * delim25;
  12508   extractG(self3, delim114, delim25);
  12509 }
  12510 {
  12511   smallJsont * self3;
  12512   smallJsont * delim115;
  12513   char * delim20;
  12514   extractG(self3, delim115, delim20);
  12515   const char * delim21;
  12516   extractG(self3, delim115, delim21);
  12517   char delim22;
  12518   extractG(self3, delim115, delim22);
  12519   int delim23;
  12520   extractG(self3, delim115, delim23);
  12521   smallJsont * delim24;
  12522   extractG(self3, delim115, delim24);
  12523   smallStringt * delim25;
  12524   extractG(self3, delim115, delim25);
  12525 }
  12526 {
  12527   smallJsont * self3;
  12528   smallStringt * delim116;
  12529   char * delim20;
  12530   extractG(self3, delim116, delim20);
  12531   const char * delim21;
  12532   extractG(self3, delim116, delim21);
  12533   char delim22;
  12534   extractG(self3, delim116, delim22);
  12535   int delim23;
  12536   extractG(self3, delim116, delim23);
  12537   smallJsont * delim24;
  12538   extractG(self3, delim116, delim24);
  12539   smallStringt * delim25;
  12540   extractG(self3, delim116, delim25);
  12541 }
  12542 {
  12543   smallStringt * self4;
  12544   char * delim117;
  12545   char * delim20;
  12546   extractG(self4, delim117, delim20);
  12547   const char * delim21;
  12548   extractG(self4, delim117, delim21);
  12549   char delim22;
  12550   extractG(self4, delim117, delim22);
  12551   int delim23;
  12552   extractG(self4, delim117, delim23);
  12553   smallJsont * delim24;
  12554   extractG(self4, delim117, delim24);
  12555   smallStringt * delim25;
  12556   extractG(self4, delim117, delim25);
  12557 }
  12558 {
  12559   smallStringt * self4;
  12560   const char * delim118;
  12561   char * delim20;
  12562   extractG(self4, delim118, delim20);
  12563   const char * delim21;
  12564   extractG(self4, delim118, delim21);
  12565   char delim22;
  12566   extractG(self4, delim118, delim22);
  12567   int delim23;
  12568   extractG(self4, delim118, delim23);
  12569   smallJsont * delim24;
  12570   extractG(self4, delim118, delim24);
  12571   smallStringt * delim25;
  12572   extractG(self4, delim118, delim25);
  12573 }
  12574 {
  12575   smallStringt * self4;
  12576   char delim119;
  12577   char * delim20;
  12578   extractG(self4, delim119, delim20);
  12579   const char * delim21;
  12580   extractG(self4, delim119, delim21);
  12581   char delim22;
  12582   extractG(self4, delim119, delim22);
  12583   int delim23;
  12584   extractG(self4, delim119, delim23);
  12585   smallJsont * delim24;
  12586   extractG(self4, delim119, delim24);
  12587   smallStringt * delim25;
  12588   extractG(self4, delim119, delim25);
  12589 }
  12590 {
  12591   smallStringt * self4;
  12592   int delim120;
  12593   char * delim20;
  12594   extractG(self4, delim120, delim20);
  12595   const char * delim21;
  12596   extractG(self4, delim120, delim21);
  12597   char delim22;
  12598   extractG(self4, delim120, delim22);
  12599   int delim23;
  12600   extractG(self4, delim120, delim23);
  12601   smallJsont * delim24;
  12602   extractG(self4, delim120, delim24);
  12603   smallStringt * delim25;
  12604   extractG(self4, delim120, delim25);
  12605 }
  12606 {
  12607   smallStringt * self4;
  12608   smallJsont * delim121;
  12609   char * delim20;
  12610   extractG(self4, delim121, delim20);
  12611   const char * delim21;
  12612   extractG(self4, delim121, delim21);
  12613   char delim22;
  12614   extractG(self4, delim121, delim22);
  12615   int delim23;
  12616   extractG(self4, delim121, delim23);
  12617   smallJsont * delim24;
  12618   extractG(self4, delim121, delim24);
  12619   smallStringt * delim25;
  12620   extractG(self4, delim121, delim25);
  12621 }
  12622 {
  12623   smallStringt * self4;
  12624   smallStringt * delim122;
  12625   char * delim20;
  12626   extractG(self4, delim122, delim20);
  12627   const char * delim21;
  12628   extractG(self4, delim122, delim21);
  12629   char delim22;
  12630   extractG(self4, delim122, delim22);
  12631   int delim23;
  12632   extractG(self4, delim122, delim23);
  12633   smallJsont * delim24;
  12634   extractG(self4, delim122, delim24);
  12635   smallStringt * delim25;
  12636   extractG(self4, delim122, delim25);
  12637 }
  12638 {
  12639   char * self1;
  12640   char * delim11;
  12641   char * delim20;
  12642   icExtractG(self1, delim11, delim20);
  12643   const char * delim21;
  12644   icExtractG(self1, delim11, delim21);
  12645   char delim22;
  12646   icExtractG(self1, delim11, delim22);
  12647   int delim23;
  12648   icExtractG(self1, delim11, delim23);
  12649   const char* delim24;
  12650   icExtractG(self1, delim11, delim24);
  12651 }
  12652 {
  12653   char * self1;
  12654   const char * delim12;
  12655   char * delim20;
  12656   icExtractG(self1, delim12, delim20);
  12657   const char * delim21;
  12658   icExtractG(self1, delim12, delim21);
  12659   char delim22;
  12660   icExtractG(self1, delim12, delim22);
  12661   int delim23;
  12662   icExtractG(self1, delim12, delim23);
  12663   const char* delim24;
  12664   icExtractG(self1, delim12, delim24);
  12665 }
  12666 {
  12667   char * self1;
  12668   char delim13;
  12669   char * delim20;
  12670   icExtractG(self1, delim13, delim20);
  12671   const char * delim21;
  12672   icExtractG(self1, delim13, delim21);
  12673   char delim22;
  12674   icExtractG(self1, delim13, delim22);
  12675   int delim23;
  12676   icExtractG(self1, delim13, delim23);
  12677   const char* delim24;
  12678   icExtractG(self1, delim13, delim24);
  12679 }
  12680 {
  12681   char * self1;
  12682   int delim14;
  12683   char * delim20;
  12684   icExtractG(self1, delim14, delim20);
  12685   const char * delim21;
  12686   icExtractG(self1, delim14, delim21);
  12687   char delim22;
  12688   icExtractG(self1, delim14, delim22);
  12689   int delim23;
  12690   icExtractG(self1, delim14, delim23);
  12691   const char* delim24;
  12692   icExtractG(self1, delim14, delim24);
  12693 }
  12694 {
  12695   char * self1;
  12696   const char* delim10;
  12697   const char* delim20;
  12698   icExtractG(self1, delim10, delim20);
  12699 }
  12700 {
  12701   const char * self2;
  12702   char * delim16;
  12703   char * delim20;
  12704   icExtractG(self2, delim16, delim20);
  12705   const char * delim21;
  12706   icExtractG(self2, delim16, delim21);
  12707   char delim22;
  12708   icExtractG(self2, delim16, delim22);
  12709   int delim23;
  12710   icExtractG(self2, delim16, delim23);
  12711   const char* delim24;
  12712   icExtractG(self2, delim16, delim24);
  12713 }
  12714 {
  12715   const char * self2;
  12716   const char * delim17;
  12717   char * delim20;
  12718   icExtractG(self2, delim17, delim20);
  12719   const char * delim21;
  12720   icExtractG(self2, delim17, delim21);
  12721   char delim22;
  12722   icExtractG(self2, delim17, delim22);
  12723   int delim23;
  12724   icExtractG(self2, delim17, delim23);
  12725   const char* delim24;
  12726   icExtractG(self2, delim17, delim24);
  12727 }
  12728 {
  12729   const char * self2;
  12730   char delim18;
  12731   char * delim20;
  12732   icExtractG(self2, delim18, delim20);
  12733   const char * delim21;
  12734   icExtractG(self2, delim18, delim21);
  12735   char delim22;
  12736   icExtractG(self2, delim18, delim22);
  12737   int delim23;
  12738   icExtractG(self2, delim18, delim23);
  12739   const char* delim24;
  12740   icExtractG(self2, delim18, delim24);
  12741 }
  12742 {
  12743   const char * self2;
  12744   int delim19;
  12745   char * delim20;
  12746   icExtractG(self2, delim19, delim20);
  12747   const char * delim21;
  12748   icExtractG(self2, delim19, delim21);
  12749   char delim22;
  12750   icExtractG(self2, delim19, delim22);
  12751   int delim23;
  12752   icExtractG(self2, delim19, delim23);
  12753   const char* delim24;
  12754   icExtractG(self2, delim19, delim24);
  12755 }
  12756 {
  12757   const char * self2;
  12758   const char* delim10;
  12759   const char* delim20;
  12760   icExtractG(self2, delim10, delim20);
  12761 }
  12762 {
  12763   smallJsont * self3;
  12764   char * delim111;
  12765   char * delim20;
  12766   icExtractG(self3, delim111, delim20);
  12767   const char * delim21;
  12768   icExtractG(self3, delim111, delim21);
  12769   char delim22;
  12770   icExtractG(self3, delim111, delim22);
  12771   int delim23;
  12772   icExtractG(self3, delim111, delim23);
  12773   smallJsont * delim24;
  12774   icExtractG(self3, delim111, delim24);
  12775   smallStringt * delim25;
  12776   icExtractG(self3, delim111, delim25);
  12777 }
  12778 {
  12779   smallJsont * self3;
  12780   const char * delim112;
  12781   char * delim20;
  12782   icExtractG(self3, delim112, delim20);
  12783   const char * delim21;
  12784   icExtractG(self3, delim112, delim21);
  12785   char delim22;
  12786   icExtractG(self3, delim112, delim22);
  12787   int delim23;
  12788   icExtractG(self3, delim112, delim23);
  12789   smallJsont * delim24;
  12790   icExtractG(self3, delim112, delim24);
  12791   smallStringt * delim25;
  12792   icExtractG(self3, delim112, delim25);
  12793 }
  12794 {
  12795   smallJsont * self3;
  12796   char delim113;
  12797   char * delim20;
  12798   icExtractG(self3, delim113, delim20);
  12799   const char * delim21;
  12800   icExtractG(self3, delim113, delim21);
  12801   char delim22;
  12802   icExtractG(self3, delim113, delim22);
  12803   int delim23;
  12804   icExtractG(self3, delim113, delim23);
  12805   smallJsont * delim24;
  12806   icExtractG(self3, delim113, delim24);
  12807   smallStringt * delim25;
  12808   icExtractG(self3, delim113, delim25);
  12809 }
  12810 {
  12811   smallJsont * self3;
  12812   int delim114;
  12813   char * delim20;
  12814   icExtractG(self3, delim114, delim20);
  12815   const char * delim21;
  12816   icExtractG(self3, delim114, delim21);
  12817   char delim22;
  12818   icExtractG(self3, delim114, delim22);
  12819   int delim23;
  12820   icExtractG(self3, delim114, delim23);
  12821   smallJsont * delim24;
  12822   icExtractG(self3, delim114, delim24);
  12823   smallStringt * delim25;
  12824   icExtractG(self3, delim114, delim25);
  12825 }
  12826 {
  12827   smallJsont * self3;
  12828   smallJsont * delim115;
  12829   char * delim20;
  12830   icExtractG(self3, delim115, delim20);
  12831   const char * delim21;
  12832   icExtractG(self3, delim115, delim21);
  12833   char delim22;
  12834   icExtractG(self3, delim115, delim22);
  12835   int delim23;
  12836   icExtractG(self3, delim115, delim23);
  12837   smallJsont * delim24;
  12838   icExtractG(self3, delim115, delim24);
  12839   smallStringt * delim25;
  12840   icExtractG(self3, delim115, delim25);
  12841 }
  12842 {
  12843   smallJsont * self3;
  12844   smallStringt * delim116;
  12845   char * delim20;
  12846   icExtractG(self3, delim116, delim20);
  12847   const char * delim21;
  12848   icExtractG(self3, delim116, delim21);
  12849   char delim22;
  12850   icExtractG(self3, delim116, delim22);
  12851   int delim23;
  12852   icExtractG(self3, delim116, delim23);
  12853   smallJsont * delim24;
  12854   icExtractG(self3, delim116, delim24);
  12855   smallStringt * delim25;
  12856   icExtractG(self3, delim116, delim25);
  12857 }
  12858 {
  12859   smallStringt * self4;
  12860   char * delim117;
  12861   char * delim20;
  12862   icExtractG(self4, delim117, delim20);
  12863   const char * delim21;
  12864   icExtractG(self4, delim117, delim21);
  12865   char delim22;
  12866   icExtractG(self4, delim117, delim22);
  12867   int delim23;
  12868   icExtractG(self4, delim117, delim23);
  12869   smallJsont * delim24;
  12870   icExtractG(self4, delim117, delim24);
  12871   smallStringt * delim25;
  12872   icExtractG(self4, delim117, delim25);
  12873 }
  12874 {
  12875   smallStringt * self4;
  12876   const char * delim118;
  12877   char * delim20;
  12878   icExtractG(self4, delim118, delim20);
  12879   const char * delim21;
  12880   icExtractG(self4, delim118, delim21);
  12881   char delim22;
  12882   icExtractG(self4, delim118, delim22);
  12883   int delim23;
  12884   icExtractG(self4, delim118, delim23);
  12885   smallJsont * delim24;
  12886   icExtractG(self4, delim118, delim24);
  12887   smallStringt * delim25;
  12888   icExtractG(self4, delim118, delim25);
  12889 }
  12890 {
  12891   smallStringt * self4;
  12892   char delim119;
  12893   char * delim20;
  12894   icExtractG(self4, delim119, delim20);
  12895   const char * delim21;
  12896   icExtractG(self4, delim119, delim21);
  12897   char delim22;
  12898   icExtractG(self4, delim119, delim22);
  12899   int delim23;
  12900   icExtractG(self4, delim119, delim23);
  12901   smallJsont * delim24;
  12902   icExtractG(self4, delim119, delim24);
  12903   smallStringt * delim25;
  12904   icExtractG(self4, delim119, delim25);
  12905 }
  12906 {
  12907   smallStringt * self4;
  12908   int delim120;
  12909   char * delim20;
  12910   icExtractG(self4, delim120, delim20);
  12911   const char * delim21;
  12912   icExtractG(self4, delim120, delim21);
  12913   char delim22;
  12914   icExtractG(self4, delim120, delim22);
  12915   int delim23;
  12916   icExtractG(self4, delim120, delim23);
  12917   smallJsont * delim24;
  12918   icExtractG(self4, delim120, delim24);
  12919   smallStringt * delim25;
  12920   icExtractG(self4, delim120, delim25);
  12921 }
  12922 {
  12923   smallStringt * self4;
  12924   smallJsont * delim121;
  12925   char * delim20;
  12926   icExtractG(self4, delim121, delim20);
  12927   const char * delim21;
  12928   icExtractG(self4, delim121, delim21);
  12929   char delim22;
  12930   icExtractG(self4, delim121, delim22);
  12931   int delim23;
  12932   icExtractG(self4, delim121, delim23);
  12933   smallJsont * delim24;
  12934   icExtractG(self4, delim121, delim24);
  12935   smallStringt * delim25;
  12936   icExtractG(self4, delim121, delim25);
  12937 }
  12938 {
  12939   smallStringt * self4;
  12940   smallStringt * delim122;
  12941   char * delim20;
  12942   icExtractG(self4, delim122, delim20);
  12943   const char * delim21;
  12944   icExtractG(self4, delim122, delim21);
  12945   char delim22;
  12946   icExtractG(self4, delim122, delim22);
  12947   int delim23;
  12948   icExtractG(self4, delim122, delim23);
  12949   smallJsont * delim24;
  12950   icExtractG(self4, delim122, delim24);
  12951   smallStringt * delim25;
  12952   icExtractG(self4, delim122, delim25);
  12953 }
  12954 {
  12955   char ** self0;
  12956   reverseG(self0);
  12957   char *** self1;
  12958   reverseG(self1);
  12959   smallArrayt * self2;
  12960   reverseG(self2);
  12961   smallJsont * self3;
  12962   reverseG(self3);
  12963 }
  12964 {
  12965   char * self1;
  12966   const char * list0;
  12967   addG(self1, list0);
  12968 }
  12969 {
  12970   const char * self2;
  12971   const char * list0;
  12972   addG(self2, list0);
  12973 }
  12974 {
  12975   char ** self3;
  12976   char ** list0;
  12977   addG(self3, list0);
  12978   const char ** list1;
  12979   addG(self3, list1);
  12980   char ** list2;
  12981   addG(self3, list2);
  12982 }
  12983 {
  12984   smallStringt * self4;
  12985   smallStringt * list0;
  12986   addG(self4, list0);
  12987 }
  12988 {
  12989   smallArrayt * self5;
  12990   smallArrayt * list0;
  12991   addG(self5, list0);
  12992 }
  12993 {
  12994   smallJsont * self6;
  12995   smallArrayt * list0;
  12996   addG(self6, list0);
  12997   smallJsont * list1;
  12998   addG(self6, list1);
  12999   smallJsont * list2;
  13000   addG(self6, list2);
  13001 }
  13002 {
  13003   char ** self0;
  13004   sortG(self0);
  13005   char *** self1;
  13006   sortG(self1);
  13007   smallArrayt * self2;
  13008   sortG(self2);
  13009   smallJsont * self3;
  13010   sortG(self3);
  13011 }
  13012 {
  13013   char ** self1;
  13014   char * string0;
  13015   binarySearchG(self1, string0);
  13016   const char * string1;
  13017   binarySearchG(self1, string1);
  13018   char string2;
  13019   binarySearchG(self1, string2);
  13020   int string3;
  13021   binarySearchG(self1, string3);
  13022   const char * string4;
  13023   binarySearchG(self1, string4);
  13024 }
  13025 {
  13026   smallArrayt * self2;
  13027   baset* string0;
  13028   binarySearchG(self2, string0);
  13029   bool string1;
  13030   binarySearchG(self2, string1);
  13031   double string2;
  13032   binarySearchG(self2, string2);
  13033   int64_t string3;
  13034   binarySearchG(self2, string3);
  13035   int32_t string4;
  13036   binarySearchG(self2, string4);
  13037   uint32_t string5;
  13038   binarySearchG(self2, string5);
  13039   uint64_t string6;
  13040   binarySearchG(self2, string6);
  13041   char* string7;
  13042   binarySearchG(self2, string7);
  13043   const char* string8;
  13044   binarySearchG(self2, string8);
  13045   char string9;
  13046   binarySearchG(self2, string9);
  13047   smallDictt* string10;
  13048   binarySearchG(self2, string10);
  13049   smallArrayt* string11;
  13050   binarySearchG(self2, string11);
  13051   char ** string12;
  13052   binarySearchG(self2, string12);
  13053   const char ** string13;
  13054   binarySearchG(self2, string13);
  13055   smallBoolt* string14;
  13056   binarySearchG(self2, string14);
  13057   smallBytest* string15;
  13058   binarySearchG(self2, string15);
  13059   smallDoublet* string16;
  13060   binarySearchG(self2, string16);
  13061   smallIntt* string17;
  13062   binarySearchG(self2, string17);
  13063   smallJsont* string18;
  13064   binarySearchG(self2, string18);
  13065   smallStringt* string19;
  13066   binarySearchG(self2, string19);
  13067   smallContainert* string20;
  13068   binarySearchG(self2, string20);
  13069   undefinedt* string21;
  13070   binarySearchG(self2, string21);
  13071   undefinedt * string22;
  13072   binarySearchG(self2, string22);
  13073 }
  13074 {
  13075   smallJsont * self3;
  13076   baset* string0;
  13077   binarySearchG(self3, string0);
  13078   bool string1;
  13079   binarySearchG(self3, string1);
  13080   double string2;
  13081   binarySearchG(self3, string2);
  13082   int64_t string3;
  13083   binarySearchG(self3, string3);
  13084   int32_t string4;
  13085   binarySearchG(self3, string4);
  13086   uint32_t string5;
  13087   binarySearchG(self3, string5);
  13088   uint64_t string6;
  13089   binarySearchG(self3, string6);
  13090   char* string7;
  13091   binarySearchG(self3, string7);
  13092   const char* string8;
  13093   binarySearchG(self3, string8);
  13094   char string9;
  13095   binarySearchG(self3, string9);
  13096   smallDictt* string10;
  13097   binarySearchG(self3, string10);
  13098   smallArrayt* string11;
  13099   binarySearchG(self3, string11);
  13100   char ** string12;
  13101   binarySearchG(self3, string12);
  13102   const char ** string13;
  13103   binarySearchG(self3, string13);
  13104   smallBoolt* string14;
  13105   binarySearchG(self3, string14);
  13106   smallBytest* string15;
  13107   binarySearchG(self3, string15);
  13108   smallDoublet* string16;
  13109   binarySearchG(self3, string16);
  13110   smallIntt* string17;
  13111   binarySearchG(self3, string17);
  13112   smallJsont* string18;
  13113   binarySearchG(self3, string18);
  13114   smallStringt* string19;
  13115   binarySearchG(self3, string19);
  13116   smallContainert* string20;
  13117   binarySearchG(self3, string20);
  13118   undefinedt* string21;
  13119   binarySearchG(self3, string21);
  13120   undefinedt * string22;
  13121   binarySearchG(self3, string22);
  13122 }
  13123 {
  13124   char ** self0;
  13125   icSortG(self0);
  13126   char *** self1;
  13127   icSortG(self1);
  13128   smallArrayt * self2;
  13129   icSortG(self2);
  13130   smallJsont * self3;
  13131   icSortG(self3);
  13132 }
  13133 {
  13134   char ** self1;
  13135   char * string0;
  13136   icBinarySearchG(self1, string0);
  13137   const char * string1;
  13138   icBinarySearchG(self1, string1);
  13139   char string2;
  13140   icBinarySearchG(self1, string2);
  13141   int string3;
  13142   icBinarySearchG(self1, string3);
  13143   const char * string4;
  13144   icBinarySearchG(self1, string4);
  13145 }
  13146 {
  13147   smallArrayt * self2;
  13148   baset* string0;
  13149   icBinarySearchG(self2, string0);
  13150   bool string1;
  13151   icBinarySearchG(self2, string1);
  13152   double string2;
  13153   icBinarySearchG(self2, string2);
  13154   int64_t string3;
  13155   icBinarySearchG(self2, string3);
  13156   int32_t string4;
  13157   icBinarySearchG(self2, string4);
  13158   uint32_t string5;
  13159   icBinarySearchG(self2, string5);
  13160   uint64_t string6;
  13161   icBinarySearchG(self2, string6);
  13162   char* string7;
  13163   icBinarySearchG(self2, string7);
  13164   const char* string8;
  13165   icBinarySearchG(self2, string8);
  13166   char string9;
  13167   icBinarySearchG(self2, string9);
  13168   smallDictt* string10;
  13169   icBinarySearchG(self2, string10);
  13170   smallArrayt* string11;
  13171   icBinarySearchG(self2, string11);
  13172   char ** string12;
  13173   icBinarySearchG(self2, string12);
  13174   const char ** string13;
  13175   icBinarySearchG(self2, string13);
  13176   smallBoolt* string14;
  13177   icBinarySearchG(self2, string14);
  13178   smallBytest* string15;
  13179   icBinarySearchG(self2, string15);
  13180   smallDoublet* string16;
  13181   icBinarySearchG(self2, string16);
  13182   smallIntt* string17;
  13183   icBinarySearchG(self2, string17);
  13184   smallJsont* string18;
  13185   icBinarySearchG(self2, string18);
  13186   smallStringt* string19;
  13187   icBinarySearchG(self2, string19);
  13188   smallContainert* string20;
  13189   icBinarySearchG(self2, string20);
  13190   undefinedt* string21;
  13191   icBinarySearchG(self2, string21);
  13192   undefinedt * string22;
  13193   icBinarySearchG(self2, string22);
  13194 }
  13195 {
  13196   smallJsont * self3;
  13197   baset* string0;
  13198   icBinarySearchG(self3, string0);
  13199   bool string1;
  13200   icBinarySearchG(self3, string1);
  13201   double string2;
  13202   icBinarySearchG(self3, string2);
  13203   int64_t string3;
  13204   icBinarySearchG(self3, string3);
  13205   int32_t string4;
  13206   icBinarySearchG(self3, string4);
  13207   uint32_t string5;
  13208   icBinarySearchG(self3, string5);
  13209   uint64_t string6;
  13210   icBinarySearchG(self3, string6);
  13211   char* string7;
  13212   icBinarySearchG(self3, string7);
  13213   const char* string8;
  13214   icBinarySearchG(self3, string8);
  13215   char string9;
  13216   icBinarySearchG(self3, string9);
  13217   smallDictt* string10;
  13218   icBinarySearchG(self3, string10);
  13219   smallArrayt* string11;
  13220   icBinarySearchG(self3, string11);
  13221   char ** string12;
  13222   icBinarySearchG(self3, string12);
  13223   const char ** string13;
  13224   icBinarySearchG(self3, string13);
  13225   smallBoolt* string14;
  13226   icBinarySearchG(self3, string14);
  13227   smallBytest* string15;
  13228   icBinarySearchG(self3, string15);
  13229   smallDoublet* string16;
  13230   icBinarySearchG(self3, string16);
  13231   smallIntt* string17;
  13232   icBinarySearchG(self3, string17);
  13233   smallJsont* string18;
  13234   icBinarySearchG(self3, string18);
  13235   smallStringt* string19;
  13236   icBinarySearchG(self3, string19);
  13237   smallContainert* string20;
  13238   icBinarySearchG(self3, string20);
  13239   undefinedt* string21;
  13240   icBinarySearchG(self3, string21);
  13241   undefinedt * string22;
  13242   icBinarySearchG(self3, string22);
  13243 }
  13244 {
  13245   char ** self0;
  13246   compactG(self0);
  13247   char *** self1;
  13248   compactG(self1);
  13249   smallArrayt * self2;
  13250   compactG(self2);
  13251   smallJsont * self3;
  13252   compactG(self3);
  13253 }
  13254 {
  13255   smallJsont * self0;
  13256   char * input0;
  13257   parseG(self0, input0);
  13258   const char * input1;
  13259   parseG(self0, input1);
  13260   smallJsont * input2;
  13261   parseG(self0, input2);
  13262   smallStringt * input3;
  13263   parseG(self0, input3);
  13264 }
  13265 {
  13266   smallJsont * self0;
  13267   char * input0;
  13268   parseYMLG(self0, input0);
  13269   const char * input1;
  13270   parseYMLG(self0, input1);
  13271   smallJsont * input2;
  13272   parseYMLG(self0, input2);
  13273   smallStringt * input3;
  13274   parseYMLG(self0, input3);
  13275 }
  13276 {
  13277   char * cmd1;
  13278   smallArrayt * out1;
  13279   smallArrayt * err0;
  13280   execG(cmd1, out1, err0);
  13281 }
  13282 {
  13283   const char * cmd2;
  13284   smallArrayt * out2;
  13285   smallArrayt * err0;
  13286   execG(cmd2, out2, err0);
  13287 }
  13288 {
  13289   smallJsont * cmd3;
  13290   smallArrayt * out3;
  13291   smallArrayt * err0;
  13292   execG(cmd3, out3, err0);
  13293 }
  13294 {
  13295   smallStringt * cmd4;
  13296   smallArrayt * out4;
  13297   smallArrayt * err0;
  13298   execG(cmd4, out4, err0);
  13299 }
  13300 {
  13301   char * src1;
  13302   char * dst0;
  13303   renameG(src1, dst0);
  13304   const char * dst1;
  13305   renameG(src1, dst1);
  13306   smallJsont * dst2;
  13307   renameG(src1, dst2);
  13308   smallStringt * dst3;
  13309   renameG(src1, dst3);
  13310 }
  13311 {
  13312   const char* src2;
  13313   char * dst0;
  13314   renameG(src2, dst0);
  13315   const char * dst1;
  13316   renameG(src2, dst1);
  13317   smallJsont * dst2;
  13318   renameG(src2, dst2);
  13319   smallStringt * dst3;
  13320   renameG(src2, dst3);
  13321 }
  13322 {
  13323   smallJsont * src3;
  13324   char * dst0;
  13325   renameG(src3, dst0);
  13326   const char * dst1;
  13327   renameG(src3, dst1);
  13328   smallJsont * dst2;
  13329   renameG(src3, dst2);
  13330   smallStringt * dst3;
  13331   renameG(src3, dst3);
  13332 }
  13333 {
  13334   smallStringt * src4;
  13335   char * dst0;
  13336   renameG(src4, dst0);
  13337   const char * dst1;
  13338   renameG(src4, dst1);
  13339   smallJsont * dst2;
  13340   renameG(src4, dst2);
  13341   smallStringt * dst3;
  13342   renameG(src4, dst3);
  13343 }
  13344 {
  13345   char * src1;
  13346   char * dst0;
  13347   moveG(src1, dst0);
  13348   const char * dst1;
  13349   moveG(src1, dst1);
  13350   smallJsont * dst2;
  13351   moveG(src1, dst2);
  13352   smallStringt * dst3;
  13353   moveG(src1, dst3);
  13354 }
  13355 {
  13356   const char* src2;
  13357   char * dst0;
  13358   moveG(src2, dst0);
  13359   const char * dst1;
  13360   moveG(src2, dst1);
  13361   smallJsont * dst2;
  13362   moveG(src2, dst2);
  13363   smallStringt * dst3;
  13364   moveG(src2, dst3);
  13365 }
  13366 {
  13367   smallJsont * src3;
  13368   char * dst0;
  13369   moveG(src3, dst0);
  13370   const char * dst1;
  13371   moveG(src3, dst1);
  13372   smallJsont * dst2;
  13373   moveG(src3, dst2);
  13374   smallStringt * dst3;
  13375   moveG(src3, dst3);
  13376 }
  13377 {
  13378   smallStringt * src4;
  13379   char * dst0;
  13380   moveG(src4, dst0);
  13381   const char * dst1;
  13382   moveG(src4, dst1);
  13383   smallJsont * dst2;
  13384   moveG(src4, dst2);
  13385   smallStringt * dst3;
  13386   moveG(src4, dst3);
  13387 }
  13388 {
  13389   smallArrayt * self0;
  13390   logG(self0);
  13391   smallDictt * self1;
  13392   logG(self1);
  13393   smallJsont * self2;
  13394   logG(self2);
  13395   char ** self3;
  13396   logG(self3);
  13397   const char ** self4;
  13398   logG(self4);
  13399 }
  13400 {
  13401   int8_t var0;
  13402   convertToUnsignedType(var0);
  13403   int16_t var1;
  13404   convertToUnsignedType(var1);
  13405   int32_t var2;
  13406   convertToUnsignedType(var2);
  13407   int64_t var3;
  13408   convertToUnsignedType(var3);
  13409   uint8_t var4;
  13410   convertToUnsignedType(var4);
  13411   uint16_t var5;
  13412   convertToUnsignedType(var5);
  13413   uint32_t var6;
  13414   convertToUnsignedType(var6);
  13415   uint64_t var7;
  13416   convertToUnsignedType(var7);
  13417   float var8;
  13418   convertToUnsignedType(var8);
  13419   double var9;
  13420   convertToUnsignedType(var9);
  13421 }
  13422 {
  13423   baset* obj0;
  13424   toStringG(obj0);
  13425   undefinedt* obj1;
  13426   toStringG(obj1);
  13427   bool obj2;
  13428   toStringG(obj2);
  13429   bool* obj3;
  13430   toStringG(obj3);
  13431   float obj4;
  13432   toStringG(obj4);
  13433   float* obj5;
  13434   toStringG(obj5);
  13435   double obj6;
  13436   toStringG(obj6);
  13437   double* obj7;
  13438   toStringG(obj7);
  13439   int64_t obj8;
  13440   toStringG(obj8);
  13441   int64_t* obj9;
  13442   toStringG(obj9);
  13443   int32_t obj10;
  13444   toStringG(obj10);
  13445   int32_t* obj11;
  13446   toStringG(obj11);
  13447   int16_t obj12;
  13448   toStringG(obj12);
  13449   int16_t* obj13;
  13450   toStringG(obj13);
  13451   uint64_t obj14;
  13452   toStringG(obj14);
  13453   uint64_t* obj15;
  13454   toStringG(obj15);
  13455   uint32_t obj16;
  13456   toStringG(obj16);
  13457   uint32_t* obj17;
  13458   toStringG(obj17);
  13459   uint16_t obj18;
  13460   toStringG(obj18);
  13461   uint16_t* obj19;
  13462   toStringG(obj19);
  13463   uint8_t obj20;
  13464   toStringG(obj20);
  13465   uint8_t* obj21;
  13466   toStringG(obj21);
  13467   char obj22;
  13468   toStringG(obj22);
  13469   char* obj23;
  13470   toStringG(obj23);
  13471   const char* obj24;
  13472   toStringG(obj24);
  13473   char** obj25;
  13474   toStringG(obj25);
  13475   const char** obj26;
  13476   toStringG(obj26);
  13477   smallDictt* obj27;
  13478   toStringG(obj27);
  13479   smallArrayt* obj28;
  13480   toStringG(obj28);
  13481   smallBoolt* obj29;
  13482   toStringG(obj29);
  13483   smallBytest* obj30;
  13484   toStringG(obj30);
  13485   smallDoublet* obj31;
  13486   toStringG(obj31);
  13487   smallIntt* obj32;
  13488   toStringG(obj32);
  13489   smallStringt* obj33;
  13490   toStringG(obj33);
  13491   void* obj34;
  13492   toStringG(obj34);
  13493   smallContainert* obj35;
  13494   toStringG(obj35);
  13495   smallJsont* obj36;
  13496   toStringG(obj36);
  13497   void* obj37;
  13498   toStringG(obj37);
  13499 }
  13500 {
  13501   baset* obj0;
  13502   putsG(obj0);
  13503   undefinedt* obj1;
  13504   putsG(obj1);
  13505   bool obj2;
  13506   putsG(obj2);
  13507   bool* obj3;
  13508   putsG(obj3);
  13509   double obj4;
  13510   putsG(obj4);
  13511   double* obj5;
  13512   putsG(obj5);
  13513   int64_t obj6;
  13514   putsG(obj6);
  13515   int64_t* obj7;
  13516   putsG(obj7);
  13517   int32_t obj8;
  13518   putsG(obj8);
  13519   int32_t* obj9;
  13520   putsG(obj9);
  13521   uint64_t obj10;
  13522   putsG(obj10);
  13523   uint64_t* obj11;
  13524   putsG(obj11);
  13525   uint32_t obj12;
  13526   putsG(obj12);
  13527   uint32_t* obj13;
  13528   putsG(obj13);
  13529   char* obj14;
  13530   putsG(obj14);
  13531   const char* obj15;
  13532   putsG(obj15);
  13533   char** obj16;
  13534   putsG(obj16);
  13535   const char** obj17;
  13536   putsG(obj17);
  13537   smallDictt* obj18;
  13538   putsG(obj18);
  13539   smallJsont* obj19;
  13540   putsG(obj19);
  13541   smallArrayt* obj20;
  13542   putsG(obj20);
  13543   smallBoolt* obj21;
  13544   putsG(obj21);
  13545   smallBytest* obj22;
  13546   putsG(obj22);
  13547   smallDoublet* obj23;
  13548   putsG(obj23);
  13549   smallIntt* obj24;
  13550   putsG(obj24);
  13551   smallStringt* obj25;
  13552   putsG(obj25);
  13553   void* obj26;
  13554   putsG(obj26);
  13555   smallContainert* obj27;
  13556   putsG(obj27);
  13557   void* obj28;
  13558   putsG(obj28);
  13559 }
  13560 }