libsheepy
libsheepyObject.h
Go to the documentation of this file.
1 // MIT License
2 //
3 // Copyright (c) 2023 Remy Noulin
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a copy
6 // of this software and associated documentation files (the "Software"), to deal
7 // in the Software without restriction, including without limitation the rights
8 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 // copies of the Software, and to permit persons to whom the Software is
10 // furnished to do so, subject to the following conditions:
11 //
12 // The above copyright notice and this permission notice shall be included in all
13 // copies or substantial portions of the Software.
14 //
15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 // SOFTWARE.
22 #pragma once
23 
48 // indicate that this is libsheepy object
49 #define __libsheepyObject 1
50 
51 #include "libsheepy.h"
52 #include "libsheepySmall.h"
53 #include "libsheepyBt.h"
54 #if (!__OpenBSD__) && ! defined(__TINYC__) && (__GNUC__ > 4)
55 #include "stdatomic.h"
56 #endif
57 
58 // Libsheepy configuration
59 // check smallObject types in parameters and returns values in the small Classe methods
60 static const bool checkObjectTypes = true;
61 
62 // recycleContainers stores the containers in a thread local list when finishO is called
63 // the containers are recycled when initiateAllocate is called after a finishO
64 //
65 // When debugging container leaks, disable recycleContainers to make to easier to the
66 // source of the leak by defining recycleContainers to 0
67 //
68 // 180814 the performance gain is about 14% for a program using the iter iterator
69 // (debian stretch kaby lake linux 4.9, gcc 6.3, glibc 2.24)
70 //
71 // In each class, the finalizeRecycle function frees the unused containers at program
72 // or thread exit
73 //
74 // The unused containers are stored in a list of size recycleContainersAmount in the
75 // thread local storage
76 //
77 // New classes have to register their finalizeRecycle functions with
78 // registerFinalizeRecycleContainersInThreadPool before the program exits
79 // to avoid memory leaks
80 #ifndef recycleContainers
81 #define recycleContainers 1
82 #endif
83 #define recycleContainersAmount 8
84 
85 // debug option: stack check in finish functions (for *NFree functions)
86 // adds a check in all *NFree function to figure out if the given object is on stack
87 // if so, the object is not recycled or freed and a warning message is printed
88 //
89 // NFreeStackCheck prevents freeing stack objects
90 //
91 // The check is done by comparing the stack pointer to the object address, when
92 // stack pointer < &object, the object is on stack
93 #if !(__sun__ || __FreeBSD__)
94 #if __amd64__
95 #define NFreeStackCheck 1
96 #endif
97 #if !__amd64__
98 #warning "NFreeStackCheck is available on x64/gcc/linux and BSD."
99 #endif
100 #endif
101 // End libsheepy configuration
102 
103 // Generics
104 
116 #define initiateG(self) _Generic((self), \
117  smallArrayt*: initiateSmallArray, \
118  smallBoolt*: initiateSmallBool, \
119  smallBytest*: initiateSmallBytes, \
120  smallContainert*: initiateSmallContainer, \
121  smallDictt*: initiateSmallDict, \
122  smallDoublet*: initiateSmallDouble, \
123  smallIntt*: initiateSmallInt, \
124  smallJsont*: initiateSmallJson, \
125  smallStringt*: initiateSmallString, \
126  undefinedt*: initiateUndefined, \
127  smallArrayt**: initiateAllocateSmallArray, \
128  smallBoolt**: initiateAllocateSmallBool, \
129  smallBytest**: initiateAllocateSmallBytes, \
130  smallContainert**: initiateAllocateSmallContainer, \
131  smallDictt**: initiateAllocateSmallDict, \
132  smallDoublet**: initiateAllocateSmallDouble, \
133  smallIntt**: initiateAllocateSmallInt, \
134  smallJsont**: initiateAllocateSmallJson, \
135  smallStringt**: initiateAllocateSmallString, \
136  undefinedt**: initiateAllocateUndefined \
137  )(self)
138 
146 #define allocG(value) _Generic((value), \
147  smallArrayt*: allocSmallArrayG, \
148  bool: allocSmallBool, \
149  void *: allocSmallContainer, \
150  smallDictt*: allocSmallDictG, \
151  double: allocSmallDouble, \
152  int64_t: allocSmallInt, \
153  int32_t: allocSmallInt, \
154  uint32_t: allocSmallInt, \
155  uint64_t: allocSmallInt, \
156  smallJsont*: allocSmallJsonG, \
157  char *: allocSmallString, \
158  const char *: allocSmallString, \
159  char **: allocArraySmallArray, \
160  const char **: allocCArraySmallArray, \
161  btt: allocB, \
162  const btt: allocB, \
163  btt*: allocPB, \
164  const btt*: allocPB \
165  )(value)
166 
167 
171 #define freeO(obj) MACRO(\
172  var p = obj;\
173  if (p) {\
174  p->f->free(p);\
175  })
176 
177 #define freeG(self) _Generic((self), \
178  smallArrayt*: freeSmallArrayG, \
179  smallBoolt*: freeSmallBoolG, \
180  smallBytest*: freeSmallBytesG, \
181  smallContainert*: freeSmallContainerG, \
182  smallDictt*: freeSmallDictG, \
183  smallDoublet*: freeSmallDoubleG, \
184  smallIntt*: freeSmallIntG, \
185  smallJsont*: freeSmallJsonG, \
186  smallStringt*: freeSmallStringG, \
187  undefinedt*: freeUndefinedG, \
188  char **: listFreeS,\
189  default: free\
190  )(self)
191 
195 void freeManyOF(void *paramType, ...);
196 #define freeManyO(paramType, ...) freeManyOF(paramType, __VA_ARGS__, NULL)
197 #define freeManyG freeManyO
198 
202 #define terminateO(obj) MACRO (\
203  var p = obj;\
204  if (p) {\
205  p->f->terminate(&(obj));\
206  })
207 #define terminateG terminateO
208 
212 void terminateManyOF(void *paramType, ...);
213 #define terminateManyO(paramType, ...) terminateManyOF(paramType, __VA_ARGS__, NULL)
214 #define terminateManyG terminateManyO
215 
221 #define isOType(obj, className) (obj ? eqS(((baset *) (obj))->type, className) : 0)
222 #define isOTypeG isOType
223 
227 #define isOSmallArray(obj) isOType(obj, "smallArray")
228 #define isOSmallArrayG isOSmallArray
229 
233 #define isOSmallBool(obj) isOType(obj, "smallBool")
234 #define isOSmallBoolG isOSmallBool
235 
239 #define isOSmallBytes(obj) isOType(obj, "smallBytes")
240 #define isOSmallBytesG isOSmallBytes
241 
245 #define isOSmallContainer(obj) isOType(obj, "smallContainer")
246 #define isOSmallContainerG isOSmallContainer
247 
251 #define isOSmallDict(obj) isOType(obj, "smallDict")
252 #define isOSmallDictG isOSmallDict
253 
257 #define isOSmallDouble(obj) isOType(obj, "smallDouble")
258 #define isOSmallDoubleG isOSmallDouble
259 
263 #define isOSmallInt(obj) isOType(obj, "smallInt")
264 #define isOSmallIntG isOSmallInt
265 
269 #define isOSmallJson(obj) isOType(obj, "smallJson")
270 #define isOSmallJsonG isOSmallJson
271 
275 #define isOSmallString(obj) isOType(obj, "smallString")
276 #define isOSmallStringG isOSmallString
277 
281 #define isOUndefined(obj) isOType(obj, "undefined")
282 #define isOUndefinedG isOUndefined
283 
284 
288 #define getOType(obj) ((baset *) (obj))->type
289 
294 #define getOTypeG(obj) _Generic(obj, \
295  baset*: "baset*",\
296  smallArrayt*: "smallArrayt*", \
297  smallBoolt*: "smallBoolt*", \
298  smallBytest*: "smallBytest*", \
299  smallDictt*: "smallDictt*", \
300  smallDoublet*: "smallDoublet*", \
301  smallIntt*: "smallIntt*", \
302  smallJsont*: "smallJsont*", \
303  smallStringt*: "smallStringt*", \
304  smallContainert*: "smallContainert*", \
305  undefinedt*: "undefinedt*", \
306  bool: "bool", \
307  bool*: "bool*", \
308  double: "double", \
309  double*: "double*", \
310  float: "float", \
311  float*: "float*", \
312  int64_t: "int64_t", \
313  int64_t*: "int64_t*", \
314  int32_t: "int32_t", \
315  int32_t*: "int32_t*", \
316  int16_t: "int16_t", \
317  int16_t*: "int16_t*", \
318  int8_t: "int8_t", \
319  int8_t*: "int8_t*", \
320  uint64_t: "uint64_t", \
321  uint64_t*: "uint64_t*", \
322  uint32_t: "uint32_t", \
323  uint32_t*: "uint32_t*", \
324  uint16_t: "uint16_t", \
325  uint16_t*: "uint16_t*", \
326  uint8_t: "uint8_t", \
327  uint8_t*: "uint8_t*", \
328  char: "char", \
329  char*: "char*", \
330  const char*: "const char*", \
331  char**: "char**", \
332  const char**: "const char**", \
333  char***: "char***", \
334  void*: "void*", \
335  FILE*: "FILE*", \
336  btt: "btt", \
337  btt*: "btt*", \
338  const btt: "const btt", \
339  const btt*: "const btt*", \
340  default: NULL \
341  )
342 
346 #define toStringO(obj) (obj)->f->toString(obj)
347 
351 #define duplicateO(obj) (obj)->f->duplicate(obj)
352 #define duplicateG duplicateO
353 
357 #define smashO(obj) MACRO(\
358  var p = obj;\
359  if (p) {\
360  p->f->smash(&obj);\
361  })
362 #define smashG smashO
363 
367 void smashManyOF(void *paramType, ...);
368 #define smashManyO(paramType, ...) smashManyOF(paramType, __VA_ARGS__, NULL)
369 
373 #define finishO(obj) MACRO(\
374  var p = obj;\
375  if (p) {\
376  p->f->finish(&(obj));\
377  })
378 #define finishG finishO
379 
383 void finishManyOF(void *paramType, ...);
384 #define finishManyO(paramType, ...) finishManyOF(paramType, __VA_ARGS__, NULL)
385 #define finishManyG finishManyO
386 
395 #define O(obj, method) (obj)->f->method(obj)
396 
408 #define o(obj, method, ...) (obj)->f->method(obj, ## __VA_ARGS__)
409 
424 #define iter(obj, element)\
425  for (baset *element = (obj)->f->iterStart(obj); element ; element = (obj)->f->iterNext(obj))
426 
427 #define iterLast(obj, element)\
428  for (baset *element = (obj)->f->iterStartLast(obj); element ; element = (obj)->f->iterNext(obj))
429 
430 #define iterFrom(obj, index, element)\
431  for (baset *element = (obj)->f->iterStartFrom(obj, index); element ; element = (obj)->f->iterNext(obj))
432 
433 #define iterFromStep(obj, index, step, element)\
434  for (baset *element = (obj)->f->iterStartFromStep(obj, index, step); element ; element = (obj)->f->iterNext(obj))
435 
440 #define iterType(type, obj, element)\
441  for (type element = (type)(obj)->f->iterStart(obj); element ; element = (type)(obj)->f->iterNext(obj))
442 
443 #define iterTypeLast(type, obj, element)\
444  for (type element = (type)(obj)->f->iterStartLast(obj); element ; element = (type)(obj)->f->iterNext(obj))
445 
446 #define iterTypeFrom(type, obj, index, element)\
447  for (type element = (type)(obj)->f->iterStartFrom(obj, index); element ; element = (type)(obj)->f->iterNext(obj))
448 
449 #define iterTypeFromStep(type, obj, index, step, element)\
450  for (type element = (type)(obj)->f->iterStartFromStep(obj, index, step); element ; element = (type)(obj)->f->iterNext(obj))
451 
457 #define iterK(obj, key)\
458  for (const char *key = (obj)->f->iterStartKey(obj); key ; key = (obj)->f->iterNextKey(obj))
459 
463 #define rallocG(obj, value) do {\
464  finishO(obj);\
465  (obj) = allocG(value);\
466 } while(0)
467 
468 
474 #define getValO(self) (self)->f->get(self)
475 #define getValG getValO
476 
477 #define setValO setFromO
478 #define setValG setFromG
479 
483 #define getPO(self) (self)->f->getP(self)
484 #define getPG getPO
485 
486 
487 #define setTopO(self, value) (self)->f->setTop(self, value)
488 #define setFromO(self, value) (self)->f->set(self, value)
489 #define setFromG setTopG
490 #define setTopG(self, value) _Generic((self), \
491  smallArrayt*: _Generic(value, \
492  char **: setFromSmallArrayG, \
493  const char **: setFromCSmallArrayG, \
494  default: setFromSmallArrayG), \
495  smallBoolt*: _Generic((value), \
496  bool: setSmallBoolG, \
497  double: setDoubleSmallBoolG, \
498  int64_t: setInt64SmallBoolG, \
499  int32_t: setInt32SmallBoolG, \
500  uint32_t: setUint32SmallBoolG, \
501  uint64_t: setUint64SmallBoolG, \
502  char*: setSSmallBoolG, \
503  const char*: setSSmallBoolG, \
504  smallBoolt*: setSmallBoolSmallBoolG, \
505  smallDoublet*: setSmallDoubleSmallBoolG, \
506  smallIntt*: setSmallIntSmallBoolG, \
507  smallJsont*: setSmallJsonSmallBoolG, \
508  smallStringt*: setSmallStringSmallBoolG, \
509  default: setSmallBoolG), \
510  smallContainert*: setSmallContainerG, \
511  smallDoublet*: _Generic((value), \
512  bool: setBoolSmallDoubleG, \
513  double: setSmallDoubleG, \
514  int64_t: setInt64SmallDoubleG, \
515  int32_t: setInt32SmallDoubleG, \
516  uint32_t: setUint32SmallDoubleG, \
517  uint64_t: setUint64SmallDoubleG, \
518  char*: setSSmallDoubleG, \
519  const char*: setSSmallDoubleG, \
520  smallBoolt*: setSmallBoolSmallDoubleG, \
521  smallDoublet*: setSmallDoubleSmallDoubleG, \
522  smallIntt*: setSmallIntSmallDoubleG, \
523  smallJsont*: setSmallJsonSmallDoubleG,\
524  smallStringt*: setSmallStringSmallDoubleG, \
525  default: setBoolSmallDoubleG), \
526  smallIntt*: _Generic((value), \
527  bool: setBoolSmallIntG, \
528  double: setDoubleSmallIntG, \
529  int64_t: setSmallIntG, \
530  int32_t: setInt32SmallIntG, \
531  uint32_t: setUint32SmallIntG, \
532  uint64_t: setUint64SmallIntG, \
533  char*: setSSmallIntG, \
534  const char*: setSSmallIntG, \
535  smallBoolt*: setSmallBoolSmallIntG, \
536  smallDoublet*: setSmallDoubleSmallIntG, \
537  smallIntt*: setSmallIntSmallIntG, \
538  smallJsont*: setSmallJsonSmallIntG, \
539  smallStringt*: setSmallStringSmallIntG, \
540  default: setBoolSmallIntG), \
541  smallStringt*: _Generic((value), \
542  bool: setBoolSmallStringG, \
543  double: setDoubleSmallStringG, \
544  int64_t: setInt64SmallStringG, \
545  int32_t: setInt32SmallStringG, \
546  uint32_t: setUint32SmallStringG, \
547  uint64_t: setUint64SmallStringG, \
548  char*: setSmallStringG, \
549  char: setCharSmallStringG, \
550  const char*: setSmallStringG, \
551  smallArrayt*: setSmallArraySmallStringG, \
552  smallBoolt*: setSmallBoolSmallStringG, \
553  smallDictt*: setFromSmallDictSmallStringG, \
554  smallDoublet*: setSmallDoubleSmallStringG, \
555  smallIntt*: setSmallIntSmallStringG, \
556  smallJsont*: setSmallJsonSmallStringG, \
557  smallStringt*: setSmallStringSmallStringG, \
558  default: setBoolSmallStringG), \
559  smallJsont*: _Generic((value), \
560  baset*: setTopSmallJsonG, \
561  bool: setTopBoolSmallJsonG, \
562  double: setTopDoubleSmallJsonG, \
563  int64_t: setTopIntSmallJsonG, \
564  int32_t: setTopIntSmallJsonG, \
565  uint64_t: setTopIntSmallJsonG, \
566  uint32_t: setTopIntSmallJsonG, \
567  char*: setTopStringSmallJsonG, \
568  char: setTopCharSmallJsonG, \
569  const char*: setTopStringSmallJsonG, \
570  char **: setTopArraycSmallJsonG, \
571  const char **: setTopCArraycSmallJsonG, \
572  smallArrayt*: setTopArraySmallJsonG, \
573  smallBoolt*: setTopSmallBoolSmallJsonG, \
574  smallDictt*: setTopDictSmallJsonG, \
575  smallDoublet*: setTopSmallDoubleSmallJsonG, \
576  smallIntt*: setTopSmallIntSmallJsonG, \
577  smallJsont*: setTopSmallJsonSmallJsonG, \
578  smallStringt*: setTopSmallStringSmallJsonG, \
579  default: setTopSmallJsonG) \
580  )(self, value)
581 
582 
583 #define setTopNFreeO(self, value) (self)->f->setTopNFree(self, value)
584 #define setTopNFreeG(self, value) _Generic((self), \
585  smallJsont*: _Generic((value), \
586  baset*: setTopNFreeSmallJsonG, \
587  bool: setTopNFreeBoolSmallJsonG, \
588  double: setTopNFreeDoubleSmallJsonG, \
589  int64_t: setTopNFreeIntSmallJsonG, \
590  char*: setTopNFreeStringSmallJsonG, \
591  smallDictt*: setTopNFreeDictSmallJsonG, \
592  smallArrayt*: setTopNFreeArraySmallJsonG, \
593  char **: setTopNFreeArraycSmallJsonG, \
594  smallBoolt*: setTopNFreeSmallBoolSmallJsonG, \
595  smallDoublet*: setTopNFreeSmallDoubleSmallJsonG, \
596  smallIntt*: setTopNFreeSmallIntSmallJsonG, \
597  smallJsont*: setTopNFreeSmallJsonSmallJsonG, \
598  smallStringt*: setTopNFreeSmallStringSmallJsonG) \
599  )(self, value)
600 
601 #define getTopO(self) (self)->f->getTop(self)
602 #define getTopG(self, returnType) _Generic((self), \
603  smallJsont*: _Generic((returnType), \
604  baset*: getTopSmallJsonG, \
605  undefinedt*: getTopUndefinedSmallJsonG, \
606  bool: getTopBoolSmallJsonG, \
607  bool*: getTopBoolPSmallJsonG, \
608  double: getTopDoubleSmallJsonG, \
609  double*: getTopDoublePSmallJsonG, \
610  int64_t: getTopIntSmallJsonG, \
611  int64_t*: getTopIntPSmallJsonG, \
612  int32_t: getTopInt32SmallJsonG, \
613  int32_t*: getTopInt32PSmallJsonG, \
614  uint64_t: getTopUintSmallJsonG, \
615  uint64_t*: getTopUintPSmallJsonG, \
616  uint32_t: getTopUint32SmallJsonG, \
617  uint32_t*: getTopUint32PSmallJsonG, \
618  char*: getTopSSmallJsonG, \
619  smallDictt*: getTopDictSmallJsonG, \
620  smallArrayt*: getTopArraySmallJsonG, \
621  smallBoolt*: getTopSmallBoolSmallJsonG, \
622  smallDoublet*: getTopSmallDoubleSmallJsonG, \
623  smallIntt*: getTopSmallIntSmallJsonG, \
624  smallStringt*: getTopSmallStringSmallJsonG) \
625  )(self, returnType)
626 
631 #define pushO(self, value) (self)->f->push(self, value)
632 #define pushG(self, value) _Generic((self), \
633  smallArrayt*: _Generic((value), \
634  baset*: pushSmallArrayG, \
635  bool: pushBoolSmallArrayG, \
636  double: pushDoubleSmallArrayG, \
637  int64_t: pushIntSmallArrayG, \
638  int32_t: pushIntSmallArrayG, \
639  uint32_t: pushIntSmallArrayG, \
640  uint64_t: pushIntSmallArrayG, \
641  char*: pushSSmallArrayG, \
642  char: pushCharSmallArrayG, \
643  const char*: pushSSmallArrayG, \
644  smallDictt*: pushDictSmallArrayG, \
645  smallArrayt*: pushArraySmallArrayG, \
646  char**: pushArraycSmallArrayG, \
647  const char**: pushCArraycSmallArrayG, \
648  smallBoolt*: pushSmallBoolSmallArrayG, \
649  smallBytest*: pushSmallBytesSmallArrayG, \
650  smallDoublet*: pushSmallDoubleSmallArrayG, \
651  smallIntt*: pushSmallIntSmallArrayG, \
652  smallJsont*: pushSmallJsonSmallArrayG, \
653  smallStringt*: pushSmallStringSmallArrayG, \
654  smallContainert*: pushSmallContainerSmallArrayG, \
655  undefinedt*: pushUndefinedSmallArrayG, \
656  default: pushVoidSmallArrayG), \
657  smallJsont*: _Generic((value), \
658  baset*: pushSmallJsonG, \
659  bool: pushBoolSmallJsonG, \
660  double: pushDoubleSmallJsonG, \
661  int64_t: pushIntSmallJsonG, \
662  int32_t: pushIntSmallJsonG, \
663  uint32_t: pushIntSmallJsonG, \
664  uint64_t: pushIntSmallJsonG, \
665  char*: pushSSmallJsonG, \
666  char: pushCharSmallJsonG, \
667  const char*: pushSSmallJsonG, \
668  smallDictt*: pushDictSmallJsonG, \
669  smallArrayt*: pushArraySmallJsonG, \
670  char **: pushArraycSmallJsonG, \
671  const char **: pushCArraycSmallJsonG, \
672  smallBoolt*: pushSmallBoolSmallJsonG, \
673  smallBytest*: pushSmallBytesSmallJsonG, \
674  smallDoublet*: pushSmallDoubleSmallJsonG, \
675  smallIntt*: pushSmallIntSmallJsonG, \
676  smallJsont*: pushSmallJsonSmallJsonG, \
677  smallStringt*: pushSmallStringSmallJsonG, \
678  smallContainert*: pushSmallContainerSmallJsonG, \
679  undefinedt*: pushUndefinedSmallJsonG, \
680  default: pushVoidSmallJsonG), \
681  smallBytest*: pushSmallBytesG, \
682  smallStringt*: _Generic((value), \
683  smallStringt*: appendSmallStringG, \
684  smallJsont*: appendSmallJsonSmallStringG, \
685  char *: appendSSmallStringG, \
686  const char *: appendSSmallStringG, \
687  char: appendCharSmallStringG, \
688  int: appendCharSmallStringG, \
689  default: appendSSmallStringG), \
690  char **: _Generic(value, \
691  char *: iAppendS, \
692  const char *: iAppendS, \
693  char: iAppendCharS, \
694  int: iAppendCharS, \
695  default: iAppendS \
696  ), \
697  char ***: _Generic(value, \
698  char *: listPushS, \
699  const char *: listPushS, \
700  char: listPushCharS, \
701  int: listPushCharS, \
702  default: listPushS \
703  ), \
704  btt: _Generic(value, \
705  const char *: pushB, \
706  char *: pushB, \
707  const btt: pushBB, \
708  btt: pushBB, \
709  const btt*: pushBPB, \
710  btt*: pushBPB, \
711  default: pushB \
712  ), \
713  btt*: _Generic(value, \
714  const char *: bPushB, \
715  char *: bPushB, \
716  const btt: bPushBB, \
717  btt: bPushBB, \
718  const btt*: bPushBPB, \
719  btt*: bPushBPB, \
720  default: bPushB \
721  ), \
722  const btt*: _Generic(value, \
723  const char *: pushPB, \
724  char *: pushPB, \
725  const btt: pushPBB, \
726  btt: pushPBB, \
727  const btt*: pushPBPB, \
728  btt*: pushPBPB, \
729  default: pushPB) \
730  )(self, value)
731 
732 #define pushNFreeO(self, value) (self)->f->pushNFree(self, value)
733 #define pushNFreeG(self, value) _Generic((self), \
734  smallArrayt*: _Generic((value), \
735  baset*: pushNFreeSmallArrayG, \
736  bool: pushBoolSmallArrayG, \
737  double: pushDoubleSmallArrayG, \
738  int64_t: pushIntSmallArrayG, \
739  int32_t: pushIntSmallArrayG, \
740  uint32_t: pushIntSmallArrayG, \
741  uint64_t: pushIntSmallArrayG, \
742  char*: pushNFreeSSmallArrayG, \
743  char: pushCharSmallArrayG, \
744  smallDictt*: pushNFreeDictSmallArrayG, \
745  smallArrayt*: pushNFreeArraySmallArrayG, \
746  char**: pushNFreeArraycSmallArrayG, \
747  smallBoolt*: pushNFreeSmallBoolSmallArrayG, \
748  smallBytest*: pushNFreeSmallBytesSmallArrayG, \
749  smallDoublet*: pushNFreeSmallDoubleSmallArrayG, \
750  smallIntt*: pushNFreeSmallIntSmallArrayG, \
751  smallJsont*: pushNFreeSmallJsonSmallArrayG, \
752  smallStringt*: pushNFreeSmallStringSmallArrayG, \
753  smallContainert*: pushNFreeSmallContainerSmallArrayG, \
754  undefinedt*: pushNFreeUndefinedSmallArrayG, \
755  default: pushVoidSmallArrayG), \
756  smallJsont*: _Generic((value), \
757  baset*: pushNFreeSmallJsonG, \
758  bool: pushBoolSmallJsonG, \
759  double: pushDoubleSmallJsonG, \
760  int64_t: pushIntSmallJsonG, \
761  int32_t: pushIntSmallJsonG, \
762  uint32_t: pushIntSmallJsonG, \
763  uint64_t: pushIntSmallJsonG, \
764  char*: pushNFreeSSmallJsonG, \
765  char: pushCharSmallJsonG, \
766  smallDictt*: pushNFreeDictSmallJsonG, \
767  smallArrayt*: pushNFreeArraySmallJsonG, \
768  char **: pushNFreeArraycSmallJsonG, \
769  smallBoolt*: pushNFreeSmallBoolSmallJsonG, \
770  smallBytest*: pushNFreeSmallBytesSmallJsonG, \
771  smallDoublet*: pushNFreeSmallDoubleSmallJsonG, \
772  smallIntt*: pushNFreeSmallIntSmallJsonG, \
773  smallJsont*: pushNFreeSmallJsonSmallJsonG, \
774  smallStringt*: pushNFreeSmallStringSmallJsonG, \
775  smallContainert*: pushNFreeSmallContainerSmallJsonG, \
776  undefinedt*: pushNFreeUndefinedSmallJsonG, \
777  default: pushVoidSmallJsonG), \
778  smallBytest*: pushSmallBytesG, \
779  smallStringt*: _Generic((value), \
780  smallStringt*: appendNSmashSmallStringG, \
781  smallJsont*: appendNSmashSmallJsonSmallStringG, \
782  char *: appendNSmashSSmallStringG, \
783  char: appendCharSmallStringG, \
784  int: appendCharSmallStringG, \
785  default: appendNSmashSSmallStringG), \
786  char **: _Generic(value, \
787  char *: iAppendNFreeS, \
788  char: iAppendCharS, \
789  int: iAppendCharS, \
790  default: iAppendNFreeS \
791  ), \
792  char ***: _Generic(value, \
793  char *: iListPushS, \
794  char: listPushCharS, \
795  int: listPushCharS, \
796  default: iListPushS \
797  ) \
798  )(self, value)
799 
800 #define setO(self, key, value) (self)->f->set(self, key, value)
801 #define setAtO(self, key, value) (self)->f->setAt(self, key, value)
802 #define setG(self, key, value) _Generic((self), \
803  smallDictt*: _Generic(key, \
804  char *: _Generic((value), \
805  baset*: setSmallDictG, \
806  bool: setBoolSmallDictG, \
807  double: setDoubleSmallDictG, \
808  int64_t: setIntSmallDictG, \
809  int32_t: setIntSmallDictG, \
810  uint32_t: setIntSmallDictG, \
811  uint64_t: setIntSmallDictG, \
812  char*: setSSmallDictG, \
813  const char*: setSSmallDictG, \
814  char: setCharSmallDictG, \
815  smallDictt*: setDictSmallDictG, \
816  smallArrayt*: setArraySmallDictG, \
817  char **: setArraycSmallDictG, \
818  const char **: setCArraycSmallDictG, \
819  smallBoolt*: setSmallBoolSmallDictG, \
820  smallBytest*: setSmallBytesSmallDictG, \
821  smallDoublet*: setSmallDoubleSmallDictG, \
822  smallIntt*: setSmallIntSmallDictG, \
823  smallJsont*: setSmallJsonSmallDictG, \
824  smallStringt*: setSmallStringSmallDictG, \
825  smallContainert*: setSmallContainerSmallDictG, \
826  undefinedt*: setUndefinedSmallDictG, \
827  default: setVoidSmallDictG), \
828  const char *: _Generic((value), \
829  baset*: setSmallDictG, \
830  bool: setBoolSmallDictG, \
831  double: setDoubleSmallDictG, \
832  int64_t: setIntSmallDictG, \
833  int32_t: setIntSmallDictG, \
834  uint32_t: setIntSmallDictG, \
835  uint64_t: setIntSmallDictG, \
836  char*: setSSmallDictG, \
837  const char*: setSSmallDictG, \
838  char: setCharSmallDictG, \
839  smallDictt*: setDictSmallDictG, \
840  smallArrayt*: setArraySmallDictG, \
841  char **: setArraycSmallDictG, \
842  const char **: setCArraycSmallDictG, \
843  smallBoolt*: setSmallBoolSmallDictG, \
844  smallBytest*: setSmallBytesSmallDictG, \
845  smallDoublet*: setSmallDoubleSmallDictG, \
846  smallIntt*: setSmallIntSmallDictG, \
847  smallJsont*: setSmallJsonSmallDictG, \
848  smallStringt*: setSmallStringSmallDictG, \
849  smallContainert*: setSmallContainerSmallDictG, \
850  undefinedt*: setUndefinedSmallDictG, \
851  default: setVoidSmallDictG), \
852  char: _Generic((value), \
853  baset*: setKCharSmallDictG, \
854  bool: setBoolKCharSmallDictG, \
855  double: setDoubleKCharSmallDictG, \
856  int64_t: setIntKCharSmallDictG, \
857  int32_t: setIntKCharSmallDictG, \
858  uint32_t: setIntKCharSmallDictG, \
859  uint64_t: setIntKCharSmallDictG, \
860  char*: setSKCharSmallDictG, \
861  const char*: setSKCharSmallDictG, \
862  char: setCharKCharSmallDictG, \
863  smallDictt*: setDictKCharSmallDictG, \
864  smallArrayt*: setArrayKCharSmallDictG, \
865  char **: setArraycKCharSmallDictG, \
866  const char **: setCArraycKCharSmallDictG, \
867  smallBoolt*: setSmallBoolKCharSmallDictG, \
868  smallBytest*: setSmallBytesKCharSmallDictG, \
869  smallDoublet*: setSmallDoubleKCharSmallDictG, \
870  smallIntt*: setSmallIntKCharSmallDictG, \
871  smallJsont*: setSmallJsonKCharSmallDictG, \
872  smallStringt*: setSmallStringKCharSmallDictG, \
873  smallContainert*: setSmallContainerKCharSmallDictG, \
874  undefinedt*: setUndefinedKCharSmallDictG, \
875  default: setVoidKCharSmallDictG), \
876  int: _Generic((value), \
877  baset*: setKCharSmallDictG, \
878  bool: setBoolKCharSmallDictG, \
879  double: setDoubleKCharSmallDictG, \
880  int64_t: setIntKCharSmallDictG, \
881  int32_t: setIntKCharSmallDictG, \
882  uint32_t: setIntKCharSmallDictG, \
883  uint64_t: setIntKCharSmallDictG, \
884  char*: setSKCharSmallDictG, \
885  const char*: setSKCharSmallDictG, \
886  char: setCharKCharSmallDictG, \
887  smallDictt*: setDictKCharSmallDictG, \
888  smallArrayt*: setArrayKCharSmallDictG, \
889  char **: setArraycKCharSmallDictG, \
890  const char **: setCArraycKCharSmallDictG, \
891  smallBoolt*: setSmallBoolKCharSmallDictG, \
892  smallBytest*: setSmallBytesKCharSmallDictG, \
893  smallDoublet*: setSmallDoubleKCharSmallDictG, \
894  smallIntt*: setSmallIntKCharSmallDictG, \
895  smallJsont*: setSmallJsonKCharSmallDictG, \
896  smallStringt*: setSmallStringKCharSmallDictG, \
897  smallContainert*: setSmallContainerKCharSmallDictG, \
898  undefinedt*: setUndefinedKCharSmallDictG, \
899  default: setVoidKCharSmallDictG), \
900  default: setVoidSmallDictG \
901  ), \
902  smallArrayt*: _Generic((value), \
903  baset*: setAtSmallArrayG, \
904  bool: setAtBoolSmallArrayG, \
905  double: setAtDoubleSmallArrayG, \
906  int64_t: setAtIntSmallArrayG, \
907  int32_t: setAtIntSmallArrayG, \
908  uint32_t: setAtIntSmallArrayG, \
909  uint64_t: setAtIntSmallArrayG, \
910  char*: setAtSSmallArrayG, \
911  char: setAtCharSmallArrayG, \
912  const char*: setAtSSmallArrayG, \
913  smallDictt*: setAtDictSmallArrayG, \
914  smallArrayt*: setAtArraySmallArrayG, \
915  char **: setAtArraycSmallArrayG, \
916  const char **: setAtCArraycSmallArrayG, \
917  smallBoolt*: setAtSmallBoolSmallArrayG, \
918  smallBytest*: setAtSmallBytesSmallArrayG, \
919  smallDoublet*: setAtSmallDoubleSmallArrayG, \
920  smallIntt*: setAtSmallIntSmallArrayG, \
921  smallJsont*: setAtSmallJsonSmallArrayG, \
922  smallStringt*: setAtSmallStringSmallArrayG, \
923  smallContainert*: setAtSmallContainerSmallArrayG, \
924  undefinedt*: setAtUndefinedSmallArrayG, \
925  default: setAtVoidSmallArrayG), \
926  smallBytest*: setSmallBytesG,\
927  smallJsont*: _Generic(key, \
928  char *: _Generic((value), \
929  baset*: setSmallJsonG, \
930  bool: setBoolSmallJsonG, \
931  double: setDoubleSmallJsonG, \
932  int64_t: setIntSmallJsonG, \
933  int32_t: setIntSmallJsonG, \
934  uint32_t: setIntSmallJsonG, \
935  uint64_t: setIntSmallJsonG, \
936  char*: setSSmallJsonG, \
937  const char*: setSSmallJsonG, \
938  char: setCharSmallJsonG, \
939  smallDictt*: setDictSmallJsonG, \
940  smallArrayt*: setArraySmallJsonG, \
941  char **: setArraycSmallJsonG, \
942  const char **: setCArraycSmallJsonG, \
943  smallBoolt*: setSmallBoolSmallJsonG, \
944  smallBytest*: setSmallBytesSmallJsonG, \
945  smallDoublet*: setSmallDoubleSmallJsonG, \
946  smallIntt*: setSmallIntSmallJsonG, \
947  smallJsont*: setSmallJsonSmallJsonG, \
948  smallStringt*: setSmallStringSmallJsonG, \
949  smallContainert*: setSmallContainerSmallJsonG, \
950  undefinedt*: setUndefinedSmallJsonG, \
951  default: setVoidSmallJsonG), \
952  const char *: _Generic((value), \
953  baset*: setSmallJsonG, \
954  bool: setBoolSmallJsonG, \
955  double: setDoubleSmallJsonG, \
956  int64_t: setIntSmallJsonG, \
957  int32_t: setIntSmallJsonG, \
958  uint32_t: setIntSmallJsonG, \
959  uint64_t: setIntSmallJsonG, \
960  char*: setSSmallJsonG, \
961  const char*: setSSmallJsonG, \
962  char: setCharSmallJsonG, \
963  smallDictt*: setDictSmallJsonG, \
964  smallArrayt*: setArraySmallJsonG, \
965  char **: setArraycSmallJsonG, \
966  const char **: setCArraycSmallJsonG, \
967  smallBoolt*: setSmallBoolSmallJsonG, \
968  smallBytest*: setSmallBytesSmallJsonG, \
969  smallDoublet*: setSmallDoubleSmallJsonG, \
970  smallIntt*: setSmallIntSmallJsonG, \
971  smallJsont*: setSmallJsonSmallJsonG, \
972  smallStringt*: setSmallStringSmallJsonG, \
973  smallContainert*: setSmallContainerSmallJsonG, \
974  undefinedt*: setUndefinedSmallJsonG, \
975  default: setVoidSmallJsonG), \
976  int64_t: _Generic((value), \
977  baset*: setAtSmallJsonG, \
978  bool: setAtBoolSmallJsonG, \
979  double: setAtDoubleSmallJsonG, \
980  int64_t: setAtIntSmallJsonG, \
981  int32_t: setAtIntSmallJsonG, \
982  uint32_t: setAtIntSmallJsonG, \
983  uint64_t: setAtIntSmallJsonG, \
984  char*: setAtSSmallJsonG, \
985  const char*: setAtSSmallJsonG, \
986  char: setAtCharSmallJsonG, \
987  smallDictt*: setAtDictSmallJsonG, \
988  smallArrayt*: setAtArraySmallJsonG, \
989  char **: setAtArraycSmallJsonG, \
990  const char **: setAtCArraycSmallJsonG, \
991  smallBoolt*: setAtSmallBoolSmallJsonG, \
992  smallBytest*: setAtSmallBytesSmallJsonG, \
993  smallDoublet*: setAtSmallDoubleSmallJsonG, \
994  smallIntt*: setAtSmallIntSmallJsonG, \
995  smallJsont*: setAtSmallJsonSmallJsonG, \
996  smallStringt*: setAtSmallStringSmallJsonG, \
997  smallContainert*: setAtSmallContainerSmallJsonG, \
998  undefinedt*: setAtUndefinedSmallJsonG, \
999  default: setAtVoidSmallJsonG), \
1000  int32_t: _Generic((value), \
1001  baset*: setAtSmallJsonG, \
1002  bool: setAtBoolSmallJsonG, \
1003  double: setAtDoubleSmallJsonG, \
1004  int64_t: setAtIntSmallJsonG, \
1005  int32_t: setAtIntSmallJsonG, \
1006  uint32_t: setAtIntSmallJsonG, \
1007  uint64_t: setAtIntSmallJsonG, \
1008  char*: setAtSSmallJsonG, \
1009  const char*: setAtSSmallJsonG, \
1010  char: setAtCharSmallJsonG, \
1011  smallDictt*: setAtDictSmallJsonG, \
1012  smallArrayt*: setAtArraySmallJsonG, \
1013  char **: setAtArraycSmallJsonG, \
1014  const char **: setAtCArraycSmallJsonG, \
1015  smallBoolt*: setAtSmallBoolSmallJsonG, \
1016  smallBytest*: setAtSmallBytesSmallJsonG, \
1017  smallDoublet*: setAtSmallDoubleSmallJsonG, \
1018  smallIntt*: setAtSmallIntSmallJsonG, \
1019  smallJsont*: setAtSmallJsonSmallJsonG, \
1020  smallStringt*: setAtSmallStringSmallJsonG, \
1021  smallContainert*: setAtSmallContainerSmallJsonG, \
1022  undefinedt*: setAtUndefinedSmallJsonG, \
1023  default: setAtVoidSmallJsonG), \
1024  int16_t: _Generic((value), \
1025  baset*: setAtSmallJsonG, \
1026  bool: setAtBoolSmallJsonG, \
1027  double: setAtDoubleSmallJsonG, \
1028  int64_t: setAtIntSmallJsonG, \
1029  int32_t: setAtIntSmallJsonG, \
1030  uint32_t: setAtIntSmallJsonG, \
1031  uint64_t: setAtIntSmallJsonG, \
1032  char*: setAtSSmallJsonG, \
1033  const char*: setAtSSmallJsonG, \
1034  char: setAtCharSmallJsonG, \
1035  smallDictt*: setAtDictSmallJsonG, \
1036  smallArrayt*: setAtArraySmallJsonG, \
1037  char **: setAtArraycSmallJsonG, \
1038  const char **: setAtCArraycSmallJsonG, \
1039  smallBoolt*: setAtSmallBoolSmallJsonG, \
1040  smallBytest*: setAtSmallBytesSmallJsonG, \
1041  smallDoublet*: setAtSmallDoubleSmallJsonG, \
1042  smallIntt*: setAtSmallIntSmallJsonG, \
1043  smallJsont*: setAtSmallJsonSmallJsonG, \
1044  smallStringt*: setAtSmallStringSmallJsonG, \
1045  smallContainert*: setAtSmallContainerSmallJsonG, \
1046  undefinedt*: setAtUndefinedSmallJsonG, \
1047  default: setAtVoidSmallJsonG), \
1048  int8_t: _Generic((value), \
1049  baset*: setAtSmallJsonG, \
1050  bool: setAtBoolSmallJsonG, \
1051  double: setAtDoubleSmallJsonG, \
1052  int64_t: setAtIntSmallJsonG, \
1053  int32_t: setAtIntSmallJsonG, \
1054  uint32_t: setAtIntSmallJsonG, \
1055  uint64_t: setAtIntSmallJsonG, \
1056  char*: setAtSSmallJsonG, \
1057  const char*: setAtSSmallJsonG, \
1058  char: setAtCharSmallJsonG, \
1059  smallDictt*: setAtDictSmallJsonG, \
1060  smallArrayt*: setAtArraySmallJsonG, \
1061  char **: setAtArraycSmallJsonG, \
1062  const char **: setAtCArraycSmallJsonG, \
1063  smallBoolt*: setAtSmallBoolSmallJsonG, \
1064  smallBytest*: setAtSmallBytesSmallJsonG, \
1065  smallDoublet*: setAtSmallDoubleSmallJsonG, \
1066  smallIntt*: setAtSmallIntSmallJsonG, \
1067  smallJsont*: setAtSmallJsonSmallJsonG, \
1068  smallStringt*: setAtSmallStringSmallJsonG, \
1069  smallContainert*: setAtSmallContainerSmallJsonG, \
1070  undefinedt*: setAtUndefinedSmallJsonG, \
1071  default: setAtVoidSmallJsonG), \
1072  char: _Generic((value), \
1073  baset*: setAtSmallJsonG, \
1074  bool: setAtBoolSmallJsonG, \
1075  double: setAtDoubleSmallJsonG, \
1076  int64_t: setAtIntSmallJsonG, \
1077  int32_t: setAtIntSmallJsonG, \
1078  uint32_t: setAtIntSmallJsonG, \
1079  uint64_t: setAtIntSmallJsonG, \
1080  char*: setAtSSmallJsonG, \
1081  const char*: setAtSSmallJsonG, \
1082  char: setAtCharSmallJsonG, \
1083  smallDictt*: setAtDictSmallJsonG, \
1084  smallArrayt*: setAtArraySmallJsonG, \
1085  char **: setAtArraycSmallJsonG, \
1086  const char **: setAtCArraycSmallJsonG, \
1087  smallBoolt*: setAtSmallBoolSmallJsonG, \
1088  smallBytest*: setAtSmallBytesSmallJsonG, \
1089  smallDoublet*: setAtSmallDoubleSmallJsonG, \
1090  smallIntt*: setAtSmallIntSmallJsonG, \
1091  smallJsont*: setAtSmallJsonSmallJsonG, \
1092  smallStringt*: setAtSmallStringSmallJsonG, \
1093  smallContainert*: setAtSmallContainerSmallJsonG, \
1094  undefinedt*: setAtUndefinedSmallJsonG, \
1095  default: setAtVoidSmallJsonG), \
1096  uint64_t: _Generic((value), \
1097  baset*: setAtSmallJsonG, \
1098  bool: setAtBoolSmallJsonG, \
1099  double: setAtDoubleSmallJsonG, \
1100  int64_t: setAtIntSmallJsonG, \
1101  int32_t: setAtIntSmallJsonG, \
1102  uint32_t: setAtIntSmallJsonG, \
1103  uint64_t: setAtIntSmallJsonG, \
1104  char*: setAtSSmallJsonG, \
1105  const char*: setAtSSmallJsonG, \
1106  char: setAtCharSmallJsonG, \
1107  smallDictt*: setAtDictSmallJsonG, \
1108  smallArrayt*: setAtArraySmallJsonG, \
1109  char **: setAtArraycSmallJsonG, \
1110  const char **: setAtCArraycSmallJsonG, \
1111  smallBoolt*: setAtSmallBoolSmallJsonG, \
1112  smallBytest*: setAtSmallBytesSmallJsonG, \
1113  smallDoublet*: setAtSmallDoubleSmallJsonG, \
1114  smallIntt*: setAtSmallIntSmallJsonG, \
1115  smallJsont*: setAtSmallJsonSmallJsonG, \
1116  smallStringt*: setAtSmallStringSmallJsonG, \
1117  smallContainert*: setAtSmallContainerSmallJsonG, \
1118  undefinedt*: setAtUndefinedSmallJsonG, \
1119  default: setAtVoidSmallJsonG), \
1120  uint32_t: _Generic((value), \
1121  baset*: setAtSmallJsonG, \
1122  bool: setAtBoolSmallJsonG, \
1123  double: setAtDoubleSmallJsonG, \
1124  int64_t: setAtIntSmallJsonG, \
1125  int32_t: setAtIntSmallJsonG, \
1126  uint32_t: setAtIntSmallJsonG, \
1127  uint64_t: setAtIntSmallJsonG, \
1128  char*: setAtSSmallJsonG, \
1129  const char*: setAtSSmallJsonG, \
1130  char: setAtCharSmallJsonG, \
1131  smallDictt*: setAtDictSmallJsonG, \
1132  smallArrayt*: setAtArraySmallJsonG, \
1133  char **: setAtArraycSmallJsonG, \
1134  const char **: setAtCArraycSmallJsonG, \
1135  smallBoolt*: setAtSmallBoolSmallJsonG, \
1136  smallBytest*: setAtSmallBytesSmallJsonG, \
1137  smallDoublet*: setAtSmallDoubleSmallJsonG, \
1138  smallIntt*: setAtSmallIntSmallJsonG, \
1139  smallJsont*: setAtSmallJsonSmallJsonG, \
1140  smallStringt*: setAtSmallStringSmallJsonG, \
1141  smallContainert*: setAtSmallContainerSmallJsonG, \
1142  undefinedt*: setAtUndefinedSmallJsonG, \
1143  default: setAtVoidSmallJsonG), \
1144  uint16_t: _Generic((value), \
1145  baset*: setAtSmallJsonG, \
1146  bool: setAtBoolSmallJsonG, \
1147  double: setAtDoubleSmallJsonG, \
1148  int64_t: setAtIntSmallJsonG, \
1149  int32_t: setAtIntSmallJsonG, \
1150  uint32_t: setAtIntSmallJsonG, \
1151  uint64_t: setAtIntSmallJsonG, \
1152  char*: setAtSSmallJsonG, \
1153  const char*: setAtSSmallJsonG, \
1154  char: setAtCharSmallJsonG, \
1155  smallDictt*: setAtDictSmallJsonG, \
1156  smallArrayt*: setAtArraySmallJsonG, \
1157  char **: setAtArraycSmallJsonG, \
1158  const char **: setAtCArraycSmallJsonG, \
1159  smallBoolt*: setAtSmallBoolSmallJsonG, \
1160  smallBytest*: setAtSmallBytesSmallJsonG, \
1161  smallDoublet*: setAtSmallDoubleSmallJsonG, \
1162  smallIntt*: setAtSmallIntSmallJsonG, \
1163  smallJsont*: setAtSmallJsonSmallJsonG, \
1164  smallStringt*: setAtSmallStringSmallJsonG, \
1165  smallContainert*: setAtSmallContainerSmallJsonG, \
1166  undefinedt*: setAtUndefinedSmallJsonG, \
1167  default: setAtVoidSmallJsonG), \
1168  uint8_t: _Generic((value), \
1169  baset*: setAtSmallJsonG, \
1170  bool: setAtBoolSmallJsonG, \
1171  double: setAtDoubleSmallJsonG, \
1172  int64_t: setAtIntSmallJsonG, \
1173  int32_t: setAtIntSmallJsonG, \
1174  uint32_t: setAtIntSmallJsonG, \
1175  uint64_t: setAtIntSmallJsonG, \
1176  char*: setAtSSmallJsonG, \
1177  const char*: setAtSSmallJsonG, \
1178  char: setAtCharSmallJsonG, \
1179  smallDictt*: setAtDictSmallJsonG, \
1180  smallArrayt*: setAtArraySmallJsonG, \
1181  char **: setAtArraycSmallJsonG, \
1182  const char **: setAtCArraycSmallJsonG, \
1183  smallBoolt*: setAtSmallBoolSmallJsonG, \
1184  smallBytest*: setAtSmallBytesSmallJsonG, \
1185  smallDoublet*: setAtSmallDoubleSmallJsonG, \
1186  smallIntt*: setAtSmallIntSmallJsonG, \
1187  smallJsont*: setAtSmallJsonSmallJsonG, \
1188  smallStringt*: setAtSmallStringSmallJsonG, \
1189  smallContainert*: setAtSmallContainerSmallJsonG, \
1190  undefinedt*: setAtUndefinedSmallJsonG, \
1191  default: setAtVoidSmallJsonG) \
1192  ), \
1193  smallStringt*: setAtSmallStringG, \
1194  char *: setS, \
1195  char **: _Generic(value, \
1196  char *: iListSetS,\
1197  char: listSetCharS,\
1198  int: listSetCharS,\
1199  default: iListSetS \
1200  ) \
1201  )(self, key, value)
1202 
1203 #define setIntO(self, key, value) (self)->f->setInt(self, key, value)
1204 
1205 #define setNFreeO(self, key, value) (self)->f->setNFree(self, key, value)
1206 #define setAtNFreeO(self, key, value) (self)->f->setAtNFree(self, key, value)
1207 #define setNFreeG(self, key, value) _Generic((self), \
1208  smallDictt*: _Generic(key, \
1209  char*: _Generic((value), \
1210  baset*: setNFreeSmallDictG, \
1211  bool: setBoolSmallDictG, \
1212  double: setDoubleSmallDictG, \
1213  int64_t: setIntSmallDictG, \
1214  int32_t: setIntSmallDictG, \
1215  uint32_t: setIntSmallDictG, \
1216  uint64_t: setIntSmallDictG, \
1217  char*: setNFreeSSmallDictG, \
1218  smallDictt*: setNFreeDictSmallDictG, \
1219  smallArrayt*: setNFreeArraySmallDictG, \
1220  char **: setNFreeArraycSmallDictG, \
1221  smallBoolt*: setNFreeSmallBoolSmallDictG, \
1222  smallBytest*: setNFreeSmallBytesSmallDictG, \
1223  smallDoublet*: setNFreeSmallDoubleSmallDictG, \
1224  smallIntt*: setNFreeSmallIntSmallDictG, \
1225  smallJsont*: setNFreeSmallJsonSmallDictG, \
1226  smallStringt*: setNFreeSmallStringSmallDictG, \
1227  smallContainert*: setNFreeSmallContainerSmallDictG, \
1228  undefinedt*: setNFreeUndefinedSmallDictG, \
1229  default: setVoidSmallDictG), \
1230  const char*: _Generic((value), \
1231  baset*: setNFreeSmallDictG, \
1232  bool: setBoolSmallDictG, \
1233  double: setDoubleSmallDictG, \
1234  int64_t: setIntSmallDictG, \
1235  int32_t: setIntSmallDictG, \
1236  uint32_t: setIntSmallDictG, \
1237  uint64_t: setIntSmallDictG, \
1238  char*: setNFreeSSmallDictG, \
1239  smallDictt*: setNFreeDictSmallDictG, \
1240  smallArrayt*: setNFreeArraySmallDictG, \
1241  char **: setNFreeArraycSmallDictG, \
1242  smallBoolt*: setNFreeSmallBoolSmallDictG, \
1243  smallBytest*: setNFreeSmallBytesSmallDictG, \
1244  smallDoublet*: setNFreeSmallDoubleSmallDictG, \
1245  smallIntt*: setNFreeSmallIntSmallDictG, \
1246  smallJsont*: setNFreeSmallJsonSmallDictG, \
1247  smallStringt*: setNFreeSmallStringSmallDictG, \
1248  smallContainert*: setNFreeSmallContainerSmallDictG, \
1249  undefinedt*: setNFreeUndefinedSmallDictG, \
1250  default: setVoidSmallDictG), \
1251  char: _Generic((value), \
1252  baset*: setNFreeKCharSmallDictG, \
1253  bool: setBoolKCharSmallDictG, \
1254  double: setDoubleKCharSmallDictG, \
1255  int64_t: setIntKCharSmallDictG, \
1256  int32_t: setIntKCharSmallDictG, \
1257  uint32_t: setIntKCharSmallDictG, \
1258  uint64_t: setIntKCharSmallDictG, \
1259  char*: setNFreeSKCharSmallDictG, \
1260  smallDictt*: setNFreeDictKCharSmallDictG, \
1261  smallArrayt*: setNFreeArrayKCharSmallDictG, \
1262  char **: setNFreeArraycKCharSmallDictG, \
1263  smallBoolt*: setNFreeSmallBoolKCharSmallDictG, \
1264  smallBytest*: setNFreeSmallBytesKCharSmallDictG, \
1265  smallDoublet*: setNFreeSmallDoubleKCharSmallDictG, \
1266  smallIntt*: setNFreeSmallIntKCharSmallDictG, \
1267  smallJsont*: setNFreeSmallJsonKCharSmallDictG, \
1268  smallStringt*: setNFreeSmallStringKCharSmallDictG, \
1269  smallContainert*: setNFreeSmallContainerKCharSmallDictG, \
1270  undefinedt*: setNFreeUndefinedKCharSmallDictG, \
1271  default: setVoidKCharSmallDictG), \
1272  int: _Generic((value), \
1273  baset*: setNFreeKCharSmallDictG, \
1274  bool: setBoolKCharSmallDictG, \
1275  double: setDoubleKCharSmallDictG, \
1276  int64_t: setIntKCharSmallDictG, \
1277  int32_t: setIntKCharSmallDictG, \
1278  uint32_t: setIntKCharSmallDictG, \
1279  uint64_t: setIntKCharSmallDictG, \
1280  char*: setNFreeSKCharSmallDictG, \
1281  smallDictt*: setNFreeDictKCharSmallDictG, \
1282  smallArrayt*: setNFreeArrayKCharSmallDictG, \
1283  char **: setNFreeArraycKCharSmallDictG, \
1284  smallBoolt*: setNFreeSmallBoolKCharSmallDictG, \
1285  smallBytest*: setNFreeSmallBytesKCharSmallDictG, \
1286  smallDoublet*: setNFreeSmallDoubleKCharSmallDictG, \
1287  smallIntt*: setNFreeSmallIntKCharSmallDictG, \
1288  smallJsont*: setNFreeSmallJsonKCharSmallDictG, \
1289  smallStringt*: setNFreeSmallStringKCharSmallDictG, \
1290  smallContainert*: setNFreeSmallContainerKCharSmallDictG, \
1291  undefinedt*: setNFreeUndefinedKCharSmallDictG, \
1292  default: setVoidKCharSmallDictG), \
1293  default: setVoidSmallDictG \
1294  ), \
1295  smallArrayt*: _Generic((value), \
1296  baset*: setAtNFreeSmallArrayG, \
1297  bool: setAtBoolSmallArrayG, \
1298  double: setAtDoubleSmallArrayG, \
1299  int64_t: setAtIntSmallArrayG, \
1300  int32_t: setAtIntSmallArrayG, \
1301  uint32_t: setAtIntSmallArrayG, \
1302  uint64_t: setAtIntSmallArrayG, \
1303  char*: setAtNFreeSSmallArrayG, \
1304  smallDictt*: setAtNFreeDictSmallArrayG, \
1305  smallArrayt*: setAtNFreeArraySmallArrayG, \
1306  char **: setAtNFreeArraycSmallArrayG, \
1307  smallBoolt*: setAtNFreeSmallBoolSmallArrayG, \
1308  smallBytest*: setAtNFreeSmallBytesSmallArrayG, \
1309  smallDoublet*: setAtNFreeSmallDoubleSmallArrayG, \
1310  smallIntt*: setAtNFreeSmallIntSmallArrayG, \
1311  smallJsont*: setAtNFreeSmallJsonSmallArrayG, \
1312  smallStringt*: setAtNFreeSmallStringSmallArrayG, \
1313  smallContainert*: setAtNFreeSmallContainerSmallArrayG, \
1314  undefinedt*: setAtNFreeUndefinedSmallArrayG, \
1315  default: setAtVoidSmallArrayG), \
1316  smallJsont*: _Generic(key, \
1317  char *: _Generic((value), \
1318  baset*: setNFreeSmallJsonG, \
1319  bool: setBoolSmallJsonG, \
1320  double: setDoubleSmallJsonG, \
1321  int64_t: setIntSmallJsonG, \
1322  int32_t: setIntSmallJsonG, \
1323  uint32_t: setIntSmallJsonG, \
1324  uint64_t: setIntSmallJsonG, \
1325  char*: setNFreeSSmallJsonG, \
1326  smallDictt*: setNFreeDictSmallJsonG, \
1327  smallArrayt*: setNFreeArraySmallJsonG, \
1328  char **: setNFreeArraycSmallJsonG, \
1329  smallBoolt*: setNFreeSmallBoolSmallJsonG, \
1330  smallBytest*: setNFreeSmallBytesSmallJsonG, \
1331  smallDoublet*: setNFreeSmallDoubleSmallJsonG, \
1332  smallIntt*: setNFreeSmallIntSmallJsonG, \
1333  smallJsont*: setNFreeSmallJsonSmallJsonG, \
1334  smallStringt*: setNFreeSmallStringSmallJsonG, \
1335  smallContainert*: setNFreeSmallContainerSmallJsonG, \
1336  undefinedt*: setNFreeUndefinedSmallJsonG, \
1337  default: setVoidSmallJsonG), \
1338  const char *: _Generic((value), \
1339  baset*: setNFreeSmallJsonG, \
1340  bool: setBoolSmallJsonG, \
1341  double: setDoubleSmallJsonG, \
1342  int64_t: setIntSmallJsonG, \
1343  int32_t: setIntSmallJsonG, \
1344  uint32_t: setIntSmallJsonG, \
1345  uint64_t: setIntSmallJsonG, \
1346  char*: setNFreeSSmallJsonG, \
1347  smallDictt*: setNFreeDictSmallJsonG, \
1348  smallArrayt*: setNFreeArraySmallJsonG, \
1349  char **: setNFreeArraycSmallJsonG, \
1350  smallBoolt*: setNFreeSmallBoolSmallJsonG, \
1351  smallBytest*: setNFreeSmallBytesSmallJsonG, \
1352  smallDoublet*: setNFreeSmallDoubleSmallJsonG, \
1353  smallIntt*: setNFreeSmallIntSmallJsonG, \
1354  smallJsont*: setNFreeSmallJsonSmallJsonG, \
1355  smallStringt*: setNFreeSmallStringSmallJsonG, \
1356  smallContainert*: setNFreeSmallContainerSmallJsonG, \
1357  undefinedt*: setNFreeUndefinedSmallJsonG, \
1358  default: setVoidSmallJsonG), \
1359  int64_t: _Generic((value), \
1360  baset*: setAtNFreeSmallJsonG, \
1361  bool: setAtBoolSmallJsonG, \
1362  double: setAtDoubleSmallJsonG, \
1363  int64_t: setAtIntSmallJsonG, \
1364  int32_t: setAtIntSmallJsonG, \
1365  uint32_t: setAtIntSmallJsonG, \
1366  uint64_t: setAtIntSmallJsonG, \
1367  char*: setAtNFreeSSmallJsonG, \
1368  smallDictt*: setAtNFreeDictSmallJsonG, \
1369  smallArrayt*: setAtNFreeArraySmallJsonG, \
1370  char **: setAtNFreeArraycSmallJsonG, \
1371  smallBoolt*: setAtNFreeSmallBoolSmallJsonG, \
1372  smallBytest*: setAtNFreeSmallBytesSmallJsonG, \
1373  smallDoublet*: setAtNFreeSmallDoubleSmallJsonG, \
1374  smallIntt*: setAtNFreeSmallIntSmallJsonG, \
1375  smallJsont*: setAtNFreeSmallJsonSmallJsonG, \
1376  smallStringt*: setAtNFreeSmallStringSmallJsonG, \
1377  smallContainert*: setAtNFreeSmallContainerSmallJsonG, \
1378  undefinedt*: setAtNFreeUndefinedSmallJsonG, \
1379  default: setAtVoidSmallJsonG), \
1380  int32_t: _Generic((value), \
1381  baset*: setAtNFreeSmallJsonG, \
1382  bool: setAtBoolSmallJsonG, \
1383  double: setAtDoubleSmallJsonG, \
1384  int64_t: setAtIntSmallJsonG, \
1385  int32_t: setAtIntSmallJsonG, \
1386  uint32_t: setAtIntSmallJsonG, \
1387  uint64_t: setAtIntSmallJsonG, \
1388  char*: setAtNFreeSSmallJsonG, \
1389  smallDictt*: setAtNFreeDictSmallJsonG, \
1390  smallArrayt*: setAtNFreeArraySmallJsonG, \
1391  char **: setAtNFreeArraycSmallJsonG, \
1392  smallBoolt*: setAtNFreeSmallBoolSmallJsonG, \
1393  smallBytest*: setAtNFreeSmallBytesSmallJsonG, \
1394  smallDoublet*: setAtNFreeSmallDoubleSmallJsonG, \
1395  smallIntt*: setAtNFreeSmallIntSmallJsonG, \
1396  smallJsont*: setAtNFreeSmallJsonSmallJsonG, \
1397  smallStringt*: setAtNFreeSmallStringSmallJsonG, \
1398  smallContainert*: setAtNFreeSmallContainerSmallJsonG, \
1399  undefinedt*: setAtNFreeUndefinedSmallJsonG, \
1400  default: setAtVoidSmallJsonG), \
1401  int16_t: _Generic((value), \
1402  baset*: setAtNFreeSmallJsonG, \
1403  bool: setAtBoolSmallJsonG, \
1404  double: setAtDoubleSmallJsonG, \
1405  int64_t: setAtIntSmallJsonG, \
1406  int32_t: setAtIntSmallJsonG, \
1407  uint32_t: setAtIntSmallJsonG, \
1408  uint64_t: setAtIntSmallJsonG, \
1409  char*: setAtNFreeSSmallJsonG, \
1410  smallDictt*: setAtNFreeDictSmallJsonG, \
1411  smallArrayt*: setAtNFreeArraySmallJsonG, \
1412  char **: setAtNFreeArraycSmallJsonG, \
1413  smallBoolt*: setAtNFreeSmallBoolSmallJsonG, \
1414  smallBytest*: setAtNFreeSmallBytesSmallJsonG, \
1415  smallDoublet*: setAtNFreeSmallDoubleSmallJsonG, \
1416  smallIntt*: setAtNFreeSmallIntSmallJsonG, \
1417  smallJsont*: setAtNFreeSmallJsonSmallJsonG, \
1418  smallStringt*: setAtNFreeSmallStringSmallJsonG, \
1419  smallContainert*: setAtNFreeSmallContainerSmallJsonG, \
1420  undefinedt*: setAtNFreeUndefinedSmallJsonG, \
1421  default: setAtVoidSmallJsonG), \
1422  int8_t: _Generic((value), \
1423  baset*: setAtNFreeSmallJsonG, \
1424  bool: setAtBoolSmallJsonG, \
1425  double: setAtDoubleSmallJsonG, \
1426  int64_t: setAtIntSmallJsonG, \
1427  int32_t: setAtIntSmallJsonG, \
1428  uint32_t: setAtIntSmallJsonG, \
1429  uint64_t: setAtIntSmallJsonG, \
1430  char*: setAtNFreeSSmallJsonG, \
1431  smallDictt*: setAtNFreeDictSmallJsonG, \
1432  smallArrayt*: setAtNFreeArraySmallJsonG, \
1433  char **: setAtNFreeArraycSmallJsonG, \
1434  smallBoolt*: setAtNFreeSmallBoolSmallJsonG, \
1435  smallBytest*: setAtNFreeSmallBytesSmallJsonG, \
1436  smallDoublet*: setAtNFreeSmallDoubleSmallJsonG, \
1437  smallIntt*: setAtNFreeSmallIntSmallJsonG, \
1438  smallJsont*: setAtNFreeSmallJsonSmallJsonG, \
1439  smallStringt*: setAtNFreeSmallStringSmallJsonG, \
1440  smallContainert*: setAtNFreeSmallContainerSmallJsonG, \
1441  undefinedt*: setAtNFreeUndefinedSmallJsonG, \
1442  default: setAtVoidSmallJsonG), \
1443  char: _Generic((value), \
1444  baset*: setAtNFreeSmallJsonG, \
1445  bool: setAtBoolSmallJsonG, \
1446  double: setAtDoubleSmallJsonG, \
1447  int64_t: setAtIntSmallJsonG, \
1448  int32_t: setAtIntSmallJsonG, \
1449  uint32_t: setAtIntSmallJsonG, \
1450  uint64_t: setAtIntSmallJsonG, \
1451  char*: setAtNFreeSSmallJsonG, \
1452  smallDictt*: setAtNFreeDictSmallJsonG, \
1453  smallArrayt*: setAtNFreeArraySmallJsonG, \
1454  char **: setAtNFreeArraycSmallJsonG, \
1455  smallBoolt*: setAtNFreeSmallBoolSmallJsonG, \
1456  smallBytest*: setAtNFreeSmallBytesSmallJsonG, \
1457  smallDoublet*: setAtNFreeSmallDoubleSmallJsonG, \
1458  smallIntt*: setAtNFreeSmallIntSmallJsonG, \
1459  smallJsont*: setAtNFreeSmallJsonSmallJsonG, \
1460  smallStringt*: setAtNFreeSmallStringSmallJsonG, \
1461  smallContainert*: setAtNFreeSmallContainerSmallJsonG, \
1462  undefinedt*: setAtNFreeUndefinedSmallJsonG, \
1463  default: setAtVoidSmallJsonG), \
1464  uint64_t: _Generic((value), \
1465  baset*: setAtNFreeSmallJsonG, \
1466  bool: setAtBoolSmallJsonG, \
1467  double: setAtDoubleSmallJsonG, \
1468  int64_t: setAtIntSmallJsonG, \
1469  int32_t: setAtIntSmallJsonG, \
1470  uint32_t: setAtIntSmallJsonG, \
1471  uint64_t: setAtIntSmallJsonG, \
1472  char*: setAtNFreeSSmallJsonG, \
1473  smallDictt*: setAtNFreeDictSmallJsonG, \
1474  smallArrayt*: setAtNFreeArraySmallJsonG, \
1475  char **: setAtNFreeArraycSmallJsonG, \
1476  smallBoolt*: setAtNFreeSmallBoolSmallJsonG, \
1477  smallBytest*: setAtNFreeSmallBytesSmallJsonG, \
1478  smallDoublet*: setAtNFreeSmallDoubleSmallJsonG, \
1479  smallIntt*: setAtNFreeSmallIntSmallJsonG, \
1480  smallJsont*: setAtNFreeSmallJsonSmallJsonG, \
1481  smallStringt*: setAtNFreeSmallStringSmallJsonG, \
1482  smallContainert*: setAtNFreeSmallContainerSmallJsonG, \
1483  undefinedt*: setAtNFreeUndefinedSmallJsonG, \
1484  default: setAtVoidSmallJsonG), \
1485  uint32_t: _Generic((value), \
1486  baset*: setAtNFreeSmallJsonG, \
1487  bool: setAtBoolSmallJsonG, \
1488  double: setAtDoubleSmallJsonG, \
1489  int64_t: setAtIntSmallJsonG, \
1490  int32_t: setAtIntSmallJsonG, \
1491  uint32_t: setAtIntSmallJsonG, \
1492  uint64_t: setAtIntSmallJsonG, \
1493  char*: setAtNFreeSSmallJsonG, \
1494  smallDictt*: setAtNFreeDictSmallJsonG, \
1495  smallArrayt*: setAtNFreeArraySmallJsonG, \
1496  char **: setAtNFreeArraycSmallJsonG, \
1497  smallBoolt*: setAtNFreeSmallBoolSmallJsonG, \
1498  smallBytest*: setAtNFreeSmallBytesSmallJsonG, \
1499  smallDoublet*: setAtNFreeSmallDoubleSmallJsonG, \
1500  smallIntt*: setAtNFreeSmallIntSmallJsonG, \
1501  smallJsont*: setAtNFreeSmallJsonSmallJsonG, \
1502  smallStringt*: setAtNFreeSmallStringSmallJsonG, \
1503  smallContainert*: setAtNFreeSmallContainerSmallJsonG, \
1504  undefinedt*: setAtNFreeUndefinedSmallJsonG, \
1505  default: setAtVoidSmallJsonG), \
1506  uint16_t: _Generic((value), \
1507  baset*: setAtNFreeSmallJsonG, \
1508  bool: setAtBoolSmallJsonG, \
1509  double: setAtDoubleSmallJsonG, \
1510  int64_t: setAtIntSmallJsonG, \
1511  int32_t: setAtIntSmallJsonG, \
1512  uint32_t: setAtIntSmallJsonG, \
1513  uint64_t: setAtIntSmallJsonG, \
1514  char*: setAtNFreeSSmallJsonG, \
1515  smallDictt*: setAtNFreeDictSmallJsonG, \
1516  smallArrayt*: setAtNFreeArraySmallJsonG, \
1517  char **: setAtNFreeArraycSmallJsonG, \
1518  smallBoolt*: setAtNFreeSmallBoolSmallJsonG, \
1519  smallBytest*: setAtNFreeSmallBytesSmallJsonG, \
1520  smallDoublet*: setAtNFreeSmallDoubleSmallJsonG, \
1521  smallIntt*: setAtNFreeSmallIntSmallJsonG, \
1522  smallJsont*: setAtNFreeSmallJsonSmallJsonG, \
1523  smallStringt*: setAtNFreeSmallStringSmallJsonG, \
1524  smallContainert*: setAtNFreeSmallContainerSmallJsonG, \
1525  undefinedt*: setAtNFreeUndefinedSmallJsonG, \
1526  default: setAtVoidSmallJsonG), \
1527  uint8_t: _Generic((value), \
1528  baset*: setAtNFreeSmallJsonG, \
1529  bool: setAtBoolSmallJsonG, \
1530  double: setAtDoubleSmallJsonG, \
1531  int64_t: setAtIntSmallJsonG, \
1532  int32_t: setAtIntSmallJsonG, \
1533  uint32_t: setAtIntSmallJsonG, \
1534  uint64_t: setAtIntSmallJsonG, \
1535  char*: setAtNFreeSSmallJsonG, \
1536  smallDictt*: setAtNFreeDictSmallJsonG, \
1537  smallArrayt*: setAtNFreeArraySmallJsonG, \
1538  char **: setAtNFreeArraycSmallJsonG, \
1539  smallBoolt*: setAtNFreeSmallBoolSmallJsonG, \
1540  smallBytest*: setAtNFreeSmallBytesSmallJsonG, \
1541  smallDoublet*: setAtNFreeSmallDoubleSmallJsonG, \
1542  smallIntt*: setAtNFreeSmallIntSmallJsonG, \
1543  smallJsont*: setAtNFreeSmallJsonSmallJsonG, \
1544  smallStringt*: setAtNFreeSmallStringSmallJsonG, \
1545  smallContainert*: setAtNFreeSmallContainerSmallJsonG, \
1546  undefinedt*: setAtNFreeUndefinedSmallJsonG, \
1547  default: setAtVoidSmallJsonG) \
1548  ), \
1549  smallStringt*: setAtSmallStringG, \
1550  char *: setS, \
1551  char **: _Generic(value, \
1552  char *: iListSetS,\
1553  char: listSetCharS,\
1554  int: listSetCharS,\
1555  default: iListSetS \
1556  ) \
1557  )(self, key, value)
1558 
1559 
1560 #define setPG(self, key, value) _Generic((self), \
1561  smallDictt*: _Generic(key, \
1562  char *: _Generic((value), \
1563  smallDictt*: setPDictSmallDictG, \
1564  smallArrayt*: setPArraySmallDictG, \
1565  smallJsont*: setPSmallJsonSmallDictG, \
1566  smallStringt*: setPSmallStringSmallDictG, \
1567  default: setPDictSmallDictG), \
1568  const char *: _Generic((value), \
1569  smallDictt*: setPDictSmallDictG, \
1570  smallArrayt*: setPArraySmallDictG, \
1571  smallJsont*: setPSmallJsonSmallDictG, \
1572  smallStringt*: setPSmallStringSmallDictG, \
1573  default: setPDictSmallDictG), \
1574  char: _Generic((value), \
1575  smallDictt*: setPDictKCharSmallDictG, \
1576  smallArrayt*: setPArrayKCharSmallDictG, \
1577  smallJsont*: setPSmallJsonKCharSmallDictG, \
1578  smallStringt*: setPSmallStringKCharSmallDictG, \
1579  default: setPDictKCharSmallDictG), \
1580  int: _Generic((value), \
1581  smallDictt*: setPDictKCharSmallDictG, \
1582  smallArrayt*: setPArrayKCharSmallDictG, \
1583  smallJsont*: setPSmallJsonKCharSmallDictG, \
1584  smallStringt*: setPSmallStringKCharSmallDictG, \
1585  default: setPDictKCharSmallDictG), \
1586  default: setPDictSmallDictG \
1587  ),\
1588  smallArrayt*: _Generic((value), \
1589  smallDictt*: setPAtDictSmallArrayG, \
1590  smallArrayt*: setPAtArraySmallArrayG, \
1591  smallJsont*: setPAtSmallJsonSmallArrayG, \
1592  smallStringt*: setPAtSmallStringSmallArrayG, \
1593  default: setPAtDictSmallArrayG), \
1594  smallJsont*: _Generic(key, \
1595  char *: _Generic((value), \
1596  smallDictt*: setPDictSmallJsonG, \
1597  smallArrayt*: setPArraySmallJsonG, \
1598  smallJsont*: setPSmallJsonSmallJsonG, \
1599  smallStringt*: setPSmallStringSmallJsonG, \
1600  default: setPDictSmallJsonG), \
1601  const char *: _Generic((value), \
1602  smallDictt*: setPDictSmallJsonG, \
1603  smallArrayt*: setPArraySmallJsonG, \
1604  smallJsont*: setPSmallJsonSmallJsonG, \
1605  smallStringt*: setPSmallStringSmallJsonG, \
1606  default: setPDictSmallJsonG), \
1607  int64_t: _Generic((value), \
1608  smallDictt*: setPAtDictSmallJsonG, \
1609  smallArrayt*: setPAtArraySmallJsonG, \
1610  smallJsont*: setPAtSmallJsonSmallJsonG, \
1611  smallStringt*: setPAtSmallStringSmallJsonG, \
1612  default: setPAtDictSmallJsonG), \
1613  int32_t: _Generic((value), \
1614  smallDictt*: setPAtDictSmallJsonG, \
1615  smallArrayt*: setPAtArraySmallJsonG, \
1616  smallJsont*: setPAtSmallJsonSmallJsonG, \
1617  smallStringt*: setPAtSmallStringSmallJsonG, \
1618  default: setPAtDictSmallJsonG), \
1619  int16_t: _Generic((value), \
1620  smallDictt*: setPAtDictSmallJsonG, \
1621  smallArrayt*: setPAtArraySmallJsonG, \
1622  smallJsont*: setPAtSmallJsonSmallJsonG, \
1623  smallStringt*: setPAtSmallStringSmallJsonG, \
1624  default: setPAtDictSmallJsonG), \
1625  int8_t: _Generic((value), \
1626  smallDictt*: setPAtDictSmallJsonG, \
1627  smallArrayt*: setPAtArraySmallJsonG, \
1628  smallJsont*: setPAtSmallJsonSmallJsonG, \
1629  smallStringt*: setPAtSmallStringSmallJsonG, \
1630  default: setPAtDictSmallJsonG), \
1631  uint64_t: _Generic((value), \
1632  smallDictt*: setPAtDictSmallJsonG, \
1633  smallArrayt*: setPAtArraySmallJsonG, \
1634  smallJsont*: setPAtSmallJsonSmallJsonG, \
1635  smallStringt*: setPAtSmallStringSmallJsonG, \
1636  default: setPAtDictSmallJsonG), \
1637  uint32_t: _Generic((value), \
1638  smallDictt*: setPAtDictSmallJsonG, \
1639  smallArrayt*: setPAtArraySmallJsonG, \
1640  smallJsont*: setPAtSmallJsonSmallJsonG, \
1641  smallStringt*: setPAtSmallStringSmallJsonG, \
1642  default: setPAtDictSmallJsonG), \
1643  uint16_t: _Generic((value), \
1644  smallDictt*: setPAtDictSmallJsonG, \
1645  smallArrayt*: setPAtArraySmallJsonG, \
1646  smallJsont*: setPAtSmallJsonSmallJsonG, \
1647  smallStringt*: setPAtSmallStringSmallJsonG, \
1648  default: setPAtDictSmallJsonG), \
1649  uint8_t: _Generic((value), \
1650  smallDictt*: setPAtDictSmallJsonG, \
1651  smallArrayt*: setPAtArraySmallJsonG, \
1652  smallJsont*: setPAtSmallJsonSmallJsonG, \
1653  smallStringt*: setPAtSmallStringSmallJsonG, \
1654  default: setPAtDictSmallJsonG), \
1655  default: setPDictSmallJsonG \
1656  ),\
1657  char **: _Generic(value, \
1658  char *: iListSetS,\
1659  char: listSetCharS,\
1660  int: listSetCharS,\
1661  default: iListSetS \
1662  ) \
1663  )(self, key, value)
1664 
1665 
1666 #define setNFreePG(self, key, value) _Generic((self), \
1667  smallDictt*: _Generic(key, \
1668  char *: _Generic((value), \
1669  smallDictt*: setNFreePDictSmallDictG, \
1670  smallArrayt*: setNFreePArraySmallDictG, \
1671  smallJsont*: setNFreePSmallJsonSmallDictG, \
1672  smallStringt*: setNFreePSmallStringSmallDictG, \
1673  default: setNFreePDictSmallDictG), \
1674  const char *: _Generic((value), \
1675  smallDictt*: setNFreePDictSmallDictG, \
1676  smallArrayt*: setNFreePArraySmallDictG, \
1677  smallJsont*: setNFreePSmallJsonSmallDictG, \
1678  smallStringt*: setNFreePSmallStringSmallDictG, \
1679  default: setNFreePDictSmallDictG), \
1680  char: _Generic((value), \
1681  smallDictt*: setNFreePDictKCharSmallDictG, \
1682  smallArrayt*: setNFreePArrayKCharSmallDictG, \
1683  smallJsont*: setNFreePSmallJsonKCharSmallDictG, \
1684  smallStringt*: setNFreePSmallStringKCharSmallDictG, \
1685  default: setNFreePDictSmallDictG), \
1686  int: _Generic((value), \
1687  smallDictt*: setNFreePDictKCharSmallDictG, \
1688  smallArrayt*: setNFreePArrayKCharSmallDictG, \
1689  smallJsont*: setNFreePSmallJsonKCharSmallDictG, \
1690  smallStringt*: setNFreePSmallStringKCharSmallDictG, \
1691  default: setNFreePDictSmallDictG), \
1692  default: setNFreePDictSmallDictG \
1693  ),\
1694  smallArrayt*: _Generic((value), \
1695  smallDictt*: setPAtNFreeDictSmallArrayG, \
1696  smallArrayt*: setPAtNFreeArraySmallArrayG, \
1697  smallJsont*: setPAtNFreeSmallJsonSmallArrayG, \
1698  smallStringt*: setPAtNFreeSmallStringSmallArrayG, \
1699  default: setPAtNFreeDictSmallArrayG), \
1700  smallJsont*: _Generic(key, \
1701  char *: _Generic((value), \
1702  smallDictt*: setNFreePDictSmallJsonG, \
1703  smallArrayt*: setNFreePArraySmallJsonG, \
1704  smallJsont*: setNFreePSmallJsonSmallJsonG, \
1705  smallStringt*: setNFreePSmallStringSmallJsonG, \
1706  default: setNFreePDictSmallJsonG), \
1707  const char *: _Generic((value), \
1708  smallDictt*: setNFreePDictSmallJsonG, \
1709  smallArrayt*: setNFreePArraySmallJsonG, \
1710  smallJsont*: setNFreePSmallJsonSmallJsonG, \
1711  smallStringt*: setNFreePSmallStringSmallJsonG, \
1712  default: setNFreePDictSmallJsonG), \
1713  int64_t: _Generic((value), \
1714  smallDictt*: setPAtNFreeDictSmallJsonG, \
1715  smallArrayt*: setPAtNFreeArraySmallJsonG, \
1716  smallJsont*: setPAtNFreeSmallJsonSmallJsonG, \
1717  smallStringt*: setPAtNFreeSmallStringSmallJsonG, \
1718  default: setPAtNFreeDictSmallJsonG), \
1719  int32_t: _Generic((value), \
1720  smallDictt*: setPAtNFreeDictSmallJsonG, \
1721  smallArrayt*: setPAtNFreeArraySmallJsonG, \
1722  smallJsont*: setPAtNFreeSmallJsonSmallJsonG, \
1723  smallStringt*: setPAtNFreeSmallStringSmallJsonG, \
1724  default: setPAtNFreeDictSmallJsonG), \
1725  int16_t: _Generic((value), \
1726  smallDictt*: setPAtNFreeDictSmallJsonG, \
1727  smallArrayt*: setPAtNFreeArraySmallJsonG, \
1728  smallJsont*: setPAtNFreeSmallJsonSmallJsonG, \
1729  smallStringt*: setPAtNFreeSmallStringSmallJsonG, \
1730  default: setPAtNFreeDictSmallJsonG), \
1731  int8_t: _Generic((value), \
1732  smallDictt*: setPAtNFreeDictSmallJsonG, \
1733  smallArrayt*: setPAtNFreeArraySmallJsonG, \
1734  smallJsont*: setPAtNFreeSmallJsonSmallJsonG, \
1735  smallStringt*: setPAtNFreeSmallStringSmallJsonG, \
1736  default: setPAtNFreeDictSmallJsonG), \
1737  uint64_t: _Generic((value), \
1738  smallDictt*: setPAtNFreeDictSmallJsonG, \
1739  smallArrayt*: setPAtNFreeArraySmallJsonG, \
1740  smallJsont*: setPAtNFreeSmallJsonSmallJsonG, \
1741  smallStringt*: setPAtNFreeSmallStringSmallJsonG, \
1742  default: setPAtNFreeDictSmallJsonG), \
1743  uint32_t: _Generic((value), \
1744  smallDictt*: setPAtNFreeDictSmallJsonG, \
1745  smallArrayt*: setPAtNFreeArraySmallJsonG, \
1746  smallJsont*: setPAtNFreeSmallJsonSmallJsonG, \
1747  smallStringt*: setPAtNFreeSmallStringSmallJsonG, \
1748  default: setPAtNFreeDictSmallJsonG), \
1749  uint16_t: _Generic((value), \
1750  smallDictt*: setPAtNFreeDictSmallJsonG, \
1751  smallArrayt*: setPAtNFreeArraySmallJsonG, \
1752  smallJsont*: setPAtNFreeSmallJsonSmallJsonG, \
1753  smallStringt*: setPAtNFreeSmallStringSmallJsonG, \
1754  default: setPAtNFreeDictSmallJsonG), \
1755  uint8_t: _Generic((value), \
1756  smallDictt*: setPAtNFreeDictSmallJsonG, \
1757  smallArrayt*: setPAtNFreeArraySmallJsonG, \
1758  smallJsont*: setPAtNFreeSmallJsonSmallJsonG, \
1759  smallStringt*: setPAtNFreeSmallStringSmallJsonG, \
1760  default: setPAtNFreeDictSmallJsonG), \
1761  default: setNFreePDictSmallJsonG \
1762  ),\
1763  char **: _Generic(value, \
1764  char *: iListSetS,\
1765  char: listSetCharS,\
1766  int: listSetCharS,\
1767  default: iListSetS \
1768  ) \
1769  )(self, key, value)
1770 
1771 
1772 #define getO(self, key) (self)->f->get(self, key)
1773 #define getAtO(self, index) (self)->f->getAt(self, index)
1774 #define getG(self, returnType, key) _Generic((self), \
1775  smallDictt*: _Generic(key, \
1776  char *: _Generic((returnType), \
1777  baset*: getSmallDictG, \
1778  undefinedt*: getUndefinedSmallDictG, \
1779  bool: getBoolSmallDictG, \
1780  bool*: getBoolPSmallDictG, \
1781  double: getDoubleSmallDictG, \
1782  double*: getDoublePSmallDictG, \
1783  int64_t: getIntSmallDictG, \
1784  int64_t*: getIntPSmallDictG, \
1785  int32_t: getInt32SmallDictG, \
1786  int32_t*: getInt32PSmallDictG, \
1787  uint64_t: getUintSmallDictG, \
1788  uint64_t*: getUintPSmallDictG, \
1789  uint32_t: getUint32SmallDictG, \
1790  uint32_t*: getUint32PSmallDictG, \
1791  char*: getSSmallDictG, \
1792  smallDictt*: getDictSmallDictG, \
1793  smallArrayt*: getArraySmallDictG, \
1794  smallBoolt*: getSmallBoolSmallDictG, \
1795  smallBytest*: getSmallBytesSmallDictG, \
1796  smallDoublet*: getSmallDoubleSmallDictG, \
1797  smallIntt*: getSmallIntSmallDictG, \
1798  smallJsont*: getSmallJsonSmallDictG, \
1799  smallStringt*: getSmallStringSmallDictG, \
1800  void*: getVoidSmallDictG, \
1801  smallContainert*: getSmallContainerSmallDictG, \
1802  default: getSmallDictG), \
1803  const char *: _Generic((returnType), \
1804  baset*: getSmallDictG, \
1805  undefinedt*: getUndefinedSmallDictG, \
1806  bool: getBoolSmallDictG, \
1807  bool*: getBoolPSmallDictG, \
1808  double: getDoubleSmallDictG, \
1809  double*: getDoublePSmallDictG, \
1810  int64_t: getIntSmallDictG, \
1811  int64_t*: getIntPSmallDictG, \
1812  int32_t: getInt32SmallDictG, \
1813  int32_t*: getInt32PSmallDictG, \
1814  uint64_t: getUintSmallDictG, \
1815  uint64_t*: getUintPSmallDictG, \
1816  uint32_t: getUint32SmallDictG, \
1817  uint32_t*: getUint32PSmallDictG, \
1818  char*: getSSmallDictG, \
1819  smallDictt*: getDictSmallDictG, \
1820  smallArrayt*: getArraySmallDictG, \
1821  smallBoolt*: getSmallBoolSmallDictG, \
1822  smallBytest*: getSmallBytesSmallDictG, \
1823  smallDoublet*: getSmallDoubleSmallDictG, \
1824  smallIntt*: getSmallIntSmallDictG, \
1825  smallJsont*: getSmallJsonSmallDictG, \
1826  smallStringt*: getSmallStringSmallDictG, \
1827  void*: getVoidSmallDictG, \
1828  smallContainert*: getSmallContainerSmallDictG, \
1829  default: getSmallDictG), \
1830  char: _Generic((returnType), \
1831  baset*: getKCharSmallDictG, \
1832  undefinedt*: getUndefinedKCharSmallDictG, \
1833  bool: getBoolKCharSmallDictG, \
1834  bool*: getBoolPKCharSmallDictG, \
1835  double: getDoubleKCharSmallDictG, \
1836  double*: getDoublePKCharSmallDictG, \
1837  int64_t: getIntKCharSmallDictG, \
1838  int64_t*: getIntPKCharSmallDictG, \
1839  int32_t: getInt32KCharSmallDictG, \
1840  int32_t*: getInt32PKCharSmallDictG, \
1841  uint64_t: getUintKCharSmallDictG, \
1842  uint64_t*: getUintPKCharSmallDictG, \
1843  uint32_t: getUint32KCharSmallDictG, \
1844  uint32_t*: getUint32PKCharSmallDictG, \
1845  char*: getSKCharSmallDictG, \
1846  smallDictt*: getDictKCharSmallDictG, \
1847  smallArrayt*: getArrayKCharSmallDictG, \
1848  smallBoolt*: getSmallBoolKCharSmallDictG, \
1849  smallBytest*: getSmallBytesKCharSmallDictG, \
1850  smallDoublet*: getSmallDoubleKCharSmallDictG, \
1851  smallIntt*: getSmallIntKCharSmallDictG, \
1852  smallJsont*: getSmallJsonKCharSmallDictG, \
1853  smallStringt*: getSmallStringKCharSmallDictG, \
1854  void*: getVoidKCharSmallDictG, \
1855  smallContainert*: getSmallContainerKCharSmallDictG, \
1856  default: getKCharSmallDictG), \
1857  int: _Generic((returnType), \
1858  baset*: getKCharSmallDictG, \
1859  undefinedt*: getUndefinedKCharSmallDictG, \
1860  bool: getBoolKCharSmallDictG, \
1861  bool*: getBoolPKCharSmallDictG, \
1862  double: getDoubleKCharSmallDictG, \
1863  double*: getDoublePKCharSmallDictG, \
1864  int64_t: getIntKCharSmallDictG, \
1865  int64_t*: getIntPKCharSmallDictG, \
1866  int32_t: getInt32KCharSmallDictG, \
1867  int32_t*: getInt32PKCharSmallDictG, \
1868  uint64_t: getUintKCharSmallDictG, \
1869  uint64_t*: getUintPKCharSmallDictG, \
1870  uint32_t: getUint32KCharSmallDictG, \
1871  uint32_t*: getUint32PKCharSmallDictG, \
1872  char*: getSKCharSmallDictG, \
1873  smallDictt*: getDictKCharSmallDictG, \
1874  smallArrayt*: getArrayKCharSmallDictG, \
1875  smallBoolt*: getSmallBoolKCharSmallDictG, \
1876  smallBytest*: getSmallBytesKCharSmallDictG, \
1877  smallDoublet*: getSmallDoubleKCharSmallDictG, \
1878  smallIntt*: getSmallIntKCharSmallDictG, \
1879  smallJsont*: getSmallJsonKCharSmallDictG, \
1880  smallStringt*: getSmallStringKCharSmallDictG, \
1881  void*: getVoidKCharSmallDictG, \
1882  smallContainert*: getSmallContainerKCharSmallDictG, \
1883  default: getKCharSmallDictG), \
1884  default: getSmallDictG \
1885  ), \
1886  smallArrayt*: _Generic((returnType), \
1887  baset*: getAtSmallArrayG, \
1888  undefinedt*: getAtUndefinedSmallArrayG, \
1889  bool: getAtBoolSmallArrayG, \
1890  bool*: getAtBoolPSmallArrayG, \
1891  double: getAtDoubleSmallArrayG, \
1892  double*: getAtDoublePSmallArrayG, \
1893  int64_t: getAtIntSmallArrayG, \
1894  int64_t*: getAtIntPSmallArrayG, \
1895  int32_t: getAtInt32SmallArrayG, \
1896  int32_t*: getAtInt32PSmallArrayG, \
1897  uint64_t: getAtUintSmallArrayG, \
1898  uint64_t*: getAtUintPSmallArrayG, \
1899  uint32_t: getAtUint32SmallArrayG, \
1900  uint32_t*: getAtUint32PSmallArrayG, \
1901  char*: getAtSSmallArrayG, \
1902  smallDictt*: getAtDictSmallArrayG, \
1903  smallArrayt*: getAtArraySmallArrayG, \
1904  smallBoolt*: getAtSmallBoolSmallArrayG, \
1905  smallBytest*: getAtSmallBytesSmallArrayG, \
1906  smallDoublet*: getAtSmallDoubleSmallArrayG, \
1907  smallIntt*: getAtSmallIntSmallArrayG, \
1908  smallJsont*: getAtSmallJsonSmallArrayG, \
1909  smallStringt*: getAtSmallStringSmallArrayG, \
1910  void*: getAtVoidSmallArrayG, \
1911  smallContainert*: getAtSmallContainerSmallArrayG, \
1912  default: getAtSmallArrayG), \
1913  smallJsont*: _Generic(key, \
1914  char *: _Generic((returnType), \
1915  baset*: getSmallJsonG, \
1916  undefinedt*: getUndefinedSmallJsonG, \
1917  bool: getBoolSmallJsonG, \
1918  bool*: getBoolPSmallJsonG, \
1919  double: getDoubleSmallJsonG, \
1920  double*: getDoublePSmallJsonG, \
1921  int64_t: getIntSmallJsonG, \
1922  int64_t*: getIntPSmallJsonG, \
1923  int32_t: getInt32SmallJsonG, \
1924  int32_t*: getInt32PSmallJsonG, \
1925  uint64_t: getUintSmallJsonG, \
1926  uint64_t*: getUintPSmallJsonG, \
1927  uint32_t: getUint32SmallJsonG, \
1928  uint32_t*: getUint32PSmallJsonG, \
1929  char*: getSSmallJsonG, \
1930  smallDictt*: getDictSmallJsonG, \
1931  smallArrayt*: getArraySmallJsonG, \
1932  smallBoolt*: getSmallBoolSmallJsonG, \
1933  smallBytest*: getSmallBytesSmallJsonG, \
1934  smallDoublet*: getSmallDoubleSmallJsonG, \
1935  smallIntt*: getSmallIntSmallJsonG, \
1936  smallJsont*: getSmallJsonSmallJsonG, \
1937  smallStringt*: getSmallStringSmallJsonG, \
1938  void*: getVoidSmallJsonG, \
1939  smallContainert*: getSmallContainerSmallJsonG, \
1940  default: getSmallJsonG), \
1941  const char *: _Generic((returnType), \
1942  baset*: getSmallJsonG, \
1943  undefinedt*: getUndefinedSmallJsonG, \
1944  bool: getBoolSmallJsonG, \
1945  bool*: getBoolPSmallJsonG, \
1946  double: getDoubleSmallJsonG, \
1947  double*: getDoublePSmallJsonG, \
1948  int64_t: getIntSmallJsonG, \
1949  int64_t*: getIntPSmallJsonG, \
1950  int32_t: getInt32SmallJsonG, \
1951  int32_t*: getInt32PSmallJsonG, \
1952  uint64_t: getUintSmallJsonG, \
1953  uint64_t*: getUintPSmallJsonG, \
1954  uint32_t: getUint32SmallJsonG, \
1955  uint32_t*: getUint32PSmallJsonG, \
1956  char*: getSSmallJsonG, \
1957  smallDictt*: getDictSmallJsonG, \
1958  smallArrayt*: getArraySmallJsonG, \
1959  smallBoolt*: getSmallBoolSmallJsonG, \
1960  smallBytest*: getSmallBytesSmallJsonG, \
1961  smallDoublet*: getSmallDoubleSmallJsonG, \
1962  smallIntt*: getSmallIntSmallJsonG, \
1963  smallJsont*: getSmallJsonSmallJsonG, \
1964  smallStringt*: getSmallStringSmallJsonG, \
1965  void*: getVoidSmallJsonG, \
1966  smallContainert*: getSmallContainerSmallJsonG, \
1967  default: getSmallJsonG), \
1968  int64_t: _Generic((returnType), \
1969  baset*: getAtSmallJsonG, \
1970  undefinedt*: getAtUndefinedSmallJsonG, \
1971  bool: getAtBoolSmallJsonG, \
1972  bool*: getAtBoolPSmallJsonG, \
1973  double: getAtDoubleSmallJsonG, \
1974  double*: getAtDoublePSmallJsonG, \
1975  int64_t: getAtIntSmallJsonG, \
1976  int64_t*: getAtIntPSmallJsonG, \
1977  int32_t: getAtInt32SmallJsonG, \
1978  int32_t*: getAtInt32PSmallJsonG, \
1979  uint64_t: getAtUintSmallJsonG, \
1980  uint64_t*: getAtUintPSmallJsonG, \
1981  uint32_t: getAtUint32SmallJsonG, \
1982  uint32_t*: getAtUint32PSmallJsonG, \
1983  char*: getAtSSmallJsonG, \
1984  smallDictt*: getAtDictSmallJsonG, \
1985  smallArrayt*: getAtArraySmallJsonG, \
1986  smallBoolt*: getAtSmallBoolSmallJsonG, \
1987  smallBytest*: getAtSmallBytesSmallJsonG, \
1988  smallDoublet*: getAtSmallDoubleSmallJsonG, \
1989  smallIntt*: getAtSmallIntSmallJsonG, \
1990  smallJsont*: getAtSmallJsonSmallJsonG, \
1991  smallStringt*: getAtSmallStringSmallJsonG, \
1992  void*: getAtVoidSmallJsonG, \
1993  smallContainert*: getAtSmallContainerSmallJsonG, \
1994  default: getAtSmallJsonG), \
1995  int32_t: _Generic((returnType), \
1996  baset*: getAtSmallJsonG, \
1997  undefinedt*: getAtUndefinedSmallJsonG, \
1998  bool: getAtBoolSmallJsonG, \
1999  bool*: getAtBoolPSmallJsonG, \
2000  double: getAtDoubleSmallJsonG, \
2001  double*: getAtDoublePSmallJsonG, \
2002  int64_t: getAtIntSmallJsonG, \
2003  int64_t*: getAtIntPSmallJsonG, \
2004  int32_t: getAtInt32SmallJsonG, \
2005  int32_t*: getAtInt32PSmallJsonG, \
2006  uint64_t: getAtUintSmallJsonG, \
2007  uint64_t*: getAtUintPSmallJsonG, \
2008  uint32_t: getAtUint32SmallJsonG, \
2009  uint32_t*: getAtUint32PSmallJsonG, \
2010  char*: getAtSSmallJsonG, \
2011  smallDictt*: getAtDictSmallJsonG, \
2012  smallArrayt*: getAtArraySmallJsonG, \
2013  smallBoolt*: getAtSmallBoolSmallJsonG, \
2014  smallBytest*: getAtSmallBytesSmallJsonG, \
2015  smallDoublet*: getAtSmallDoubleSmallJsonG, \
2016  smallIntt*: getAtSmallIntSmallJsonG, \
2017  smallJsont*: getAtSmallJsonSmallJsonG, \
2018  smallStringt*: getAtSmallStringSmallJsonG, \
2019  void*: getAtVoidSmallJsonG, \
2020  smallContainert*: getAtSmallContainerSmallJsonG, \
2021  default: getAtSmallJsonG), \
2022  int16_t: _Generic((returnType), \
2023  baset*: getAtSmallJsonG, \
2024  undefinedt*: getAtUndefinedSmallJsonG, \
2025  bool: getAtBoolSmallJsonG, \
2026  bool*: getAtBoolPSmallJsonG, \
2027  double: getAtDoubleSmallJsonG, \
2028  double*: getAtDoublePSmallJsonG, \
2029  int64_t: getAtIntSmallJsonG, \
2030  int64_t*: getAtIntPSmallJsonG, \
2031  int32_t: getAtInt32SmallJsonG, \
2032  int32_t*: getAtInt32PSmallJsonG, \
2033  uint64_t: getAtUintSmallJsonG, \
2034  uint64_t*: getAtUintPSmallJsonG, \
2035  uint32_t: getAtUint32SmallJsonG, \
2036  uint32_t*: getAtUint32PSmallJsonG, \
2037  char*: getAtSSmallJsonG, \
2038  smallDictt*: getAtDictSmallJsonG, \
2039  smallArrayt*: getAtArraySmallJsonG, \
2040  smallBoolt*: getAtSmallBoolSmallJsonG, \
2041  smallBytest*: getAtSmallBytesSmallJsonG, \
2042  smallDoublet*: getAtSmallDoubleSmallJsonG, \
2043  smallIntt*: getAtSmallIntSmallJsonG, \
2044  smallJsont*: getAtSmallJsonSmallJsonG, \
2045  smallStringt*: getAtSmallStringSmallJsonG, \
2046  void*: getAtVoidSmallJsonG, \
2047  smallContainert*: getAtSmallContainerSmallJsonG, \
2048  default: getAtSmallJsonG), \
2049  int8_t: _Generic((returnType), \
2050  baset*: getAtSmallJsonG, \
2051  undefinedt*: getAtUndefinedSmallJsonG, \
2052  bool: getAtBoolSmallJsonG, \
2053  bool*: getAtBoolPSmallJsonG, \
2054  double: getAtDoubleSmallJsonG, \
2055  double*: getAtDoublePSmallJsonG, \
2056  int64_t: getAtIntSmallJsonG, \
2057  int64_t*: getAtIntPSmallJsonG, \
2058  int32_t: getAtInt32SmallJsonG, \
2059  int32_t*: getAtInt32PSmallJsonG, \
2060  uint64_t: getAtUintSmallJsonG, \
2061  uint64_t*: getAtUintPSmallJsonG, \
2062  uint32_t: getAtUint32SmallJsonG, \
2063  uint32_t*: getAtUint32PSmallJsonG, \
2064  char*: getAtSSmallJsonG, \
2065  smallDictt*: getAtDictSmallJsonG, \
2066  smallArrayt*: getAtArraySmallJsonG, \
2067  smallBoolt*: getAtSmallBoolSmallJsonG, \
2068  smallBytest*: getAtSmallBytesSmallJsonG, \
2069  smallDoublet*: getAtSmallDoubleSmallJsonG, \
2070  smallIntt*: getAtSmallIntSmallJsonG, \
2071  smallJsont*: getAtSmallJsonSmallJsonG, \
2072  smallStringt*: getAtSmallStringSmallJsonG, \
2073  void*: getAtVoidSmallJsonG, \
2074  smallContainert*: getAtSmallContainerSmallJsonG, \
2075  default: getAtSmallJsonG), \
2076  uint64_t: _Generic((returnType), \
2077  baset*: getAtSmallJsonG, \
2078  undefinedt*: getAtUndefinedSmallJsonG, \
2079  bool: getAtBoolSmallJsonG, \
2080  bool*: getAtBoolPSmallJsonG, \
2081  double: getAtDoubleSmallJsonG, \
2082  double*: getAtDoublePSmallJsonG, \
2083  int64_t: getAtIntSmallJsonG, \
2084  int64_t*: getAtIntPSmallJsonG, \
2085  int32_t: getAtInt32SmallJsonG, \
2086  int32_t*: getAtInt32PSmallJsonG, \
2087  uint64_t: getAtUintSmallJsonG, \
2088  uint64_t*: getAtUintPSmallJsonG, \
2089  uint32_t: getAtUint32SmallJsonG, \
2090  uint32_t*: getAtUint32PSmallJsonG, \
2091  char*: getAtSSmallJsonG, \
2092  smallDictt*: getAtDictSmallJsonG, \
2093  smallArrayt*: getAtArraySmallJsonG, \
2094  smallBoolt*: getAtSmallBoolSmallJsonG, \
2095  smallBytest*: getAtSmallBytesSmallJsonG, \
2096  smallDoublet*: getAtSmallDoubleSmallJsonG, \
2097  smallIntt*: getAtSmallIntSmallJsonG, \
2098  smallJsont*: getAtSmallJsonSmallJsonG, \
2099  smallStringt*: getAtSmallStringSmallJsonG, \
2100  void*: getAtVoidSmallJsonG, \
2101  smallContainert*: getAtSmallContainerSmallJsonG, \
2102  default: getAtSmallJsonG), \
2103  uint32_t: _Generic((returnType), \
2104  baset*: getAtSmallJsonG, \
2105  undefinedt*: getAtUndefinedSmallJsonG, \
2106  bool: getAtBoolSmallJsonG, \
2107  bool*: getAtBoolPSmallJsonG, \
2108  double: getAtDoubleSmallJsonG, \
2109  double*: getAtDoublePSmallJsonG, \
2110  int64_t: getAtIntSmallJsonG, \
2111  int64_t*: getAtIntPSmallJsonG, \
2112  int32_t: getAtInt32SmallJsonG, \
2113  int32_t*: getAtInt32PSmallJsonG, \
2114  uint64_t: getAtUintSmallJsonG, \
2115  uint64_t*: getAtUintPSmallJsonG, \
2116  uint32_t: getAtUint32SmallJsonG, \
2117  uint32_t*: getAtUint32PSmallJsonG, \
2118  char*: getAtSSmallJsonG, \
2119  smallDictt*: getAtDictSmallJsonG, \
2120  smallArrayt*: getAtArraySmallJsonG, \
2121  smallBoolt*: getAtSmallBoolSmallJsonG, \
2122  smallBytest*: getAtSmallBytesSmallJsonG, \
2123  smallDoublet*: getAtSmallDoubleSmallJsonG, \
2124  smallIntt*: getAtSmallIntSmallJsonG, \
2125  smallJsont*: getAtSmallJsonSmallJsonG, \
2126  smallStringt*: getAtSmallStringSmallJsonG, \
2127  void*: getAtVoidSmallJsonG, \
2128  smallContainert*: getAtSmallContainerSmallJsonG, \
2129  default: getAtSmallJsonG), \
2130  uint16_t: _Generic((returnType), \
2131  baset*: getAtSmallJsonG, \
2132  undefinedt*: getAtUndefinedSmallJsonG, \
2133  bool: getAtBoolSmallJsonG, \
2134  bool*: getAtBoolPSmallJsonG, \
2135  double: getAtDoubleSmallJsonG, \
2136  double*: getAtDoublePSmallJsonG, \
2137  int64_t: getAtIntSmallJsonG, \
2138  int64_t*: getAtIntPSmallJsonG, \
2139  int32_t: getAtInt32SmallJsonG, \
2140  int32_t*: getAtInt32PSmallJsonG, \
2141  uint64_t: getAtUintSmallJsonG, \
2142  uint64_t*: getAtUintPSmallJsonG, \
2143  uint32_t: getAtUint32SmallJsonG, \
2144  uint32_t*: getAtUint32PSmallJsonG, \
2145  char*: getAtSSmallJsonG, \
2146  smallDictt*: getAtDictSmallJsonG, \
2147  smallArrayt*: getAtArraySmallJsonG, \
2148  smallBoolt*: getAtSmallBoolSmallJsonG, \
2149  smallBytest*: getAtSmallBytesSmallJsonG, \
2150  smallDoublet*: getAtSmallDoubleSmallJsonG, \
2151  smallIntt*: getAtSmallIntSmallJsonG, \
2152  smallJsont*: getAtSmallJsonSmallJsonG, \
2153  smallStringt*: getAtSmallStringSmallJsonG, \
2154  void*: getAtVoidSmallJsonG, \
2155  smallContainert*: getAtSmallContainerSmallJsonG, \
2156  default: getAtSmallJsonG), \
2157  uint8_t: _Generic((returnType), \
2158  baset*: getAtSmallJsonG, \
2159  undefinedt*: getAtUndefinedSmallJsonG, \
2160  bool: getAtBoolSmallJsonG, \
2161  bool*: getAtBoolPSmallJsonG, \
2162  double: getAtDoubleSmallJsonG, \
2163  double*: getAtDoublePSmallJsonG, \
2164  int64_t: getAtIntSmallJsonG, \
2165  int64_t*: getAtIntPSmallJsonG, \
2166  int32_t: getAtInt32SmallJsonG, \
2167  int32_t*: getAtInt32PSmallJsonG, \
2168  uint64_t: getAtUintSmallJsonG, \
2169  uint64_t*: getAtUintPSmallJsonG, \
2170  uint32_t: getAtUint32SmallJsonG, \
2171  uint32_t*: getAtUint32PSmallJsonG, \
2172  char*: getAtSSmallJsonG, \
2173  smallDictt*: getAtDictSmallJsonG, \
2174  smallArrayt*: getAtArraySmallJsonG, \
2175  smallBoolt*: getAtSmallBoolSmallJsonG, \
2176  smallBytest*: getAtSmallBytesSmallJsonG, \
2177  smallDoublet*: getAtSmallDoubleSmallJsonG, \
2178  smallIntt*: getAtSmallIntSmallJsonG, \
2179  smallJsont*: getAtSmallJsonSmallJsonG, \
2180  smallStringt*: getAtSmallStringSmallJsonG, \
2181  void*: getAtVoidSmallJsonG, \
2182  smallContainert*: getAtSmallContainerSmallJsonG, \
2183  default: getAtSmallJsonG), \
2184  default: getSmallJsonG), \
2185  smallBytest*: getAtSmallBytesG, \
2186  smallStringt*: getAtSmallStringG, \
2187  smallBoolt*: _Generic((returnType), \
2188  bool: getBoolSmallBoolG, \
2189  bool*: getBoolPSmallBoolG, \
2190  default: getBoolPSmallBoolG), \
2191  smallContainert*: getSmallContainerG, \
2192  smallDoublet*: _Generic((returnType), \
2193  double: getDoubleSmallDoubleG, \
2194  double*: getDoublePSmallDoubleG, \
2195  default: getDoublePSmallDoubleG), \
2196  smallIntt*: _Generic((returnType), \
2197  int64_t: getIntSmallIntG, \
2198  int64_t*: getIntPSmallIntG, \
2199  int32_t: getInt32SmallIntG, \
2200  int32_t*: getInt32PSmallIntG, \
2201  uint64_t: getUintSmallIntG, \
2202  uint64_t*: getUintPSmallIntG, \
2203  uint32_t: getUint32SmallIntG, \
2204  uint32_t*: getUint32PSmallIntG, \
2205  default: getIntPSmallIntG), \
2206  char *: getSG, \
2207  const char *: getSG, \
2208  char **: iListGetG, \
2209  const char **: iListGetCG \
2210  )(self, returnType, key)
2211 
2212 
2213 #define getNDupO(self, key) (self)->f->getNDup(self, key)
2214 #define getAtNDupO(self, index) (self)->f->getAtNDup(self, index)
2215 #define getNDupG(self, returnType, key) _Generic((self), \
2216  smallDictt*: _Generic(key, \
2217  char *: _Generic((returnType), \
2218  baset*: getNDupSmallDictG, \
2219  undefinedt*: getNDupUndefinedSmallDictG, \
2220  bool: getNDupBoolSmallDictG, \
2221  double: getNDupDoubleSmallDictG, \
2222  int64_t: getNDupIntSmallDictG, \
2223  int32_t: getNDupInt32SmallDictG, \
2224  uint64_t: getNDupUintSmallDictG, \
2225  uint32_t: getNDupUint32SmallDictG, \
2226  char*: getNDupSSmallDictG, \
2227  smallDictt*: getNDupDictSmallDictG, \
2228  smallArrayt*: getNDupArraySmallDictG, \
2229  smallBoolt*: getNDupSmallBoolSmallDictG, \
2230  smallBytest*: getNDupSmallBytesSmallDictG, \
2231  smallDoublet*: getNDupSmallDoubleSmallDictG, \
2232  smallIntt*: getNDupSmallIntSmallDictG, \
2233  smallJsont*: getNDupSmallJsonSmallDictG, \
2234  smallStringt*: getNDupSmallStringSmallDictG, \
2235  void*: getNDupVoidSmallDictG, \
2236  smallContainert*: getNDupSmallContainerSmallDictG, \
2237  default: getNDupSmallDictG), \
2238  const char *: _Generic((returnType), \
2239  baset*: getNDupSmallDictG, \
2240  undefinedt*: getNDupUndefinedSmallDictG, \
2241  bool: getNDupBoolSmallDictG, \
2242  double: getNDupDoubleSmallDictG, \
2243  int64_t: getNDupIntSmallDictG, \
2244  int32_t: getNDupInt32SmallDictG, \
2245  uint64_t: getNDupUintSmallDictG, \
2246  uint32_t: getNDupUint32SmallDictG, \
2247  char*: getNDupSSmallDictG, \
2248  smallDictt*: getNDupDictSmallDictG, \
2249  smallArrayt*: getNDupArraySmallDictG, \
2250  smallBoolt*: getNDupSmallBoolSmallDictG, \
2251  smallBytest*: getNDupSmallBytesSmallDictG, \
2252  smallDoublet*: getNDupSmallDoubleSmallDictG, \
2253  smallIntt*: getNDupSmallIntSmallDictG, \
2254  smallJsont*: getNDupSmallJsonSmallDictG, \
2255  smallStringt*: getNDupSmallStringSmallDictG, \
2256  void*: getNDupVoidSmallDictG, \
2257  smallContainert*: getNDupSmallContainerSmallDictG, \
2258  default: getNDupSmallDictG), \
2259  char: _Generic((returnType), \
2260  baset*: getNDupKCharSmallDictG, \
2261  undefinedt*: getNDupUndefinedKCharSmallDictG, \
2262  bool: getNDupBoolKCharSmallDictG, \
2263  double: getNDupDoubleKCharSmallDictG, \
2264  int64_t: getNDupIntKCharSmallDictG, \
2265  int32_t: getNDupInt32KCharSmallDictG, \
2266  uint64_t: getNDupUintKCharSmallDictG, \
2267  uint32_t: getNDupUint32KCharSmallDictG, \
2268  char*: getNDupSKCharSmallDictG, \
2269  smallDictt*: getNDupDictKCharSmallDictG, \
2270  smallArrayt*: getNDupArrayKCharSmallDictG, \
2271  smallBoolt*: getNDupSmallBoolKCharSmallDictG, \
2272  smallBytest*: getNDupSmallBytesKCharSmallDictG, \
2273  smallDoublet*: getNDupSmallDoubleKCharSmallDictG, \
2274  smallIntt*: getNDupSmallIntKCharSmallDictG, \
2275  smallJsont*: getNDupSmallJsonKCharSmallDictG, \
2276  smallStringt*: getNDupSmallStringKCharSmallDictG, \
2277  void*: getNDupVoidKCharSmallDictG, \
2278  smallContainert*: getNDupSmallContainerKCharSmallDictG, \
2279  default: getNDupKCharSmallDictG), \
2280  int: _Generic((returnType), \
2281  baset*: getNDupKCharSmallDictG, \
2282  undefinedt*: getNDupUndefinedKCharSmallDictG, \
2283  bool: getNDupBoolKCharSmallDictG, \
2284  double: getNDupDoubleKCharSmallDictG, \
2285  int64_t: getNDupIntKCharSmallDictG, \
2286  int32_t: getNDupInt32KCharSmallDictG, \
2287  uint64_t: getNDupUintKCharSmallDictG, \
2288  uint32_t: getNDupUint32KCharSmallDictG, \
2289  char*: getNDupSKCharSmallDictG, \
2290  smallDictt*: getNDupDictKCharSmallDictG, \
2291  smallArrayt*: getNDupArrayKCharSmallDictG, \
2292  smallBoolt*: getNDupSmallBoolKCharSmallDictG, \
2293  smallBytest*: getNDupSmallBytesKCharSmallDictG, \
2294  smallDoublet*: getNDupSmallDoubleKCharSmallDictG, \
2295  smallIntt*: getNDupSmallIntKCharSmallDictG, \
2296  smallJsont*: getNDupSmallJsonKCharSmallDictG, \
2297  smallStringt*: getNDupSmallStringKCharSmallDictG, \
2298  void*: getNDupVoidKCharSmallDictG, \
2299  smallContainert*: getNDupSmallContainerKCharSmallDictG, \
2300  default: getNDupKCharSmallDictG), \
2301  default: getNDupSmallDictG \
2302  ), \
2303  smallArrayt*: _Generic((returnType), \
2304  baset*: getAtNDupSmallArrayG, \
2305  undefinedt*: getAtNDupUndefinedSmallArrayG, \
2306  bool: getAtNDupBoolSmallArrayG, \
2307  double: getAtNDupDoubleSmallArrayG, \
2308  int64_t: getAtNDupIntSmallArrayG, \
2309  int32_t: getAtNDupInt32SmallArrayG, \
2310  uint64_t: getAtNDupUintSmallArrayG, \
2311  uint32_t: getAtNDupUint32SmallArrayG, \
2312  char*: getAtNDupSSmallArrayG, \
2313  smallDictt*: getAtNDupDictSmallArrayG, \
2314  smallArrayt*: getAtNDupArraySmallArrayG, \
2315  smallBoolt*: getAtNDupSmallBoolSmallArrayG, \
2316  smallBytest*: getAtNDupSmallBytesSmallArrayG, \
2317  smallDoublet*: getAtNDupSmallDoubleSmallArrayG, \
2318  smallIntt*: getAtNDupSmallIntSmallArrayG, \
2319  smallJsont*: getAtNDupSmallJsonSmallArrayG, \
2320  smallStringt*: getAtNDupSmallStringSmallArrayG, \
2321  void*: getAtNDupVoidSmallArrayG, \
2322  smallContainert*: getAtNDupSmallContainerSmallArrayG, \
2323  default: getAtNDupSmallArrayG), \
2324  smallJsont*: _Generic(key, \
2325  char *: _Generic((returnType), \
2326  baset*: getNDupSmallJsonG, \
2327  undefinedt*: getNDupUndefinedSmallJsonG, \
2328  bool: getNDupBoolSmallJsonG, \
2329  double: getNDupDoubleSmallJsonG, \
2330  int64_t: getNDupIntSmallJsonG, \
2331  int32_t: getNDupInt32SmallJsonG, \
2332  uint64_t: getNDupUintSmallJsonG, \
2333  uint32_t: getNDupUint32SmallJsonG, \
2334  char*: getNDupSSmallJsonG, \
2335  smallDictt*: getNDupDictSmallJsonG, \
2336  smallArrayt*: getNDupArraySmallJsonG, \
2337  smallBoolt*: getNDupSmallBoolSmallJsonG, \
2338  smallBytest*: getNDupSmallBytesSmallJsonG, \
2339  smallDoublet*: getNDupSmallDoubleSmallJsonG, \
2340  smallIntt*: getNDupSmallIntSmallJsonG, \
2341  smallJsont*: getNDupSmallJsonSmallJsonG, \
2342  smallStringt*: getNDupSmallStringSmallJsonG, \
2343  void*: getNDupVoidSmallJsonG, \
2344  smallContainert*: getNDupSmallContainerSmallJsonG, \
2345  default: getNDupSmallJsonG), \
2346  const char *: _Generic((returnType), \
2347  baset*: getNDupSmallJsonG, \
2348  undefinedt*: getNDupUndefinedSmallJsonG, \
2349  bool: getNDupBoolSmallJsonG, \
2350  double: getNDupDoubleSmallJsonG, \
2351  int64_t: getNDupIntSmallJsonG, \
2352  int32_t: getNDupInt32SmallJsonG, \
2353  uint64_t: getNDupUintSmallJsonG, \
2354  uint32_t: getNDupUint32SmallJsonG, \
2355  char*: getNDupSSmallJsonG, \
2356  smallDictt*: getNDupDictSmallJsonG, \
2357  smallArrayt*: getNDupArraySmallJsonG, \
2358  smallBoolt*: getNDupSmallBoolSmallJsonG, \
2359  smallBytest*: getNDupSmallBytesSmallJsonG, \
2360  smallDoublet*: getNDupSmallDoubleSmallJsonG, \
2361  smallIntt*: getNDupSmallIntSmallJsonG, \
2362  smallJsont*: getNDupSmallJsonSmallJsonG, \
2363  smallStringt*: getNDupSmallStringSmallJsonG, \
2364  void*: getNDupVoidSmallJsonG, \
2365  smallContainert*: getNDupSmallContainerSmallJsonG, \
2366  default: getNDupSmallJsonG), \
2367  int64_t: _Generic((returnType), \
2368  baset*: getAtNDupSmallJsonG, \
2369  undefinedt*: getAtNDupUndefinedSmallJsonG, \
2370  bool: getAtNDupBoolSmallJsonG, \
2371  double: getAtNDupDoubleSmallJsonG, \
2372  int64_t: getAtNDupIntSmallJsonG, \
2373  int32_t: getAtNDupInt32SmallJsonG, \
2374  uint64_t: getAtNDupUintSmallJsonG, \
2375  uint32_t: getAtNDupUint32SmallJsonG, \
2376  char*: getAtNDupSSmallJsonG, \
2377  smallDictt*: getAtNDupDictSmallJsonG, \
2378  smallArrayt*: getAtNDupArraySmallJsonG, \
2379  smallBoolt*: getAtNDupSmallBoolSmallJsonG, \
2380  smallBytest*: getAtNDupSmallBytesSmallJsonG, \
2381  smallDoublet*: getAtNDupSmallDoubleSmallJsonG, \
2382  smallIntt*: getAtNDupSmallIntSmallJsonG, \
2383  smallJsont*: getAtNDupSmallJsonSmallJsonG, \
2384  smallStringt*: getAtNDupSmallStringSmallJsonG, \
2385  void*: getAtNDupVoidSmallJsonG, \
2386  smallContainert*: getAtNDupSmallContainerSmallJsonG, \
2387  default: getAtNDupSmallJsonG), \
2388  int32_t: _Generic((returnType), \
2389  baset*: getAtNDupSmallJsonG, \
2390  undefinedt*: getAtNDupUndefinedSmallJsonG, \
2391  bool: getAtNDupBoolSmallJsonG, \
2392  double: getAtNDupDoubleSmallJsonG, \
2393  int64_t: getAtNDupIntSmallJsonG, \
2394  int32_t: getAtNDupInt32SmallJsonG, \
2395  uint64_t: getAtNDupUintSmallJsonG, \
2396  uint32_t: getAtNDupUint32SmallJsonG, \
2397  char*: getAtNDupSSmallJsonG, \
2398  smallDictt*: getAtNDupDictSmallJsonG, \
2399  smallArrayt*: getAtNDupArraySmallJsonG, \
2400  smallBoolt*: getAtNDupSmallBoolSmallJsonG, \
2401  smallBytest*: getAtNDupSmallBytesSmallJsonG, \
2402  smallDoublet*: getAtNDupSmallDoubleSmallJsonG, \
2403  smallIntt*: getAtNDupSmallIntSmallJsonG, \
2404  smallJsont*: getAtNDupSmallJsonSmallJsonG, \
2405  smallStringt*: getAtNDupSmallStringSmallJsonG, \
2406  void*: getAtNDupVoidSmallJsonG, \
2407  smallContainert*: getAtNDupSmallContainerSmallJsonG, \
2408  default: getAtNDupSmallJsonG), \
2409  int16_t: _Generic((returnType), \
2410  baset*: getAtNDupSmallJsonG, \
2411  undefinedt*: getAtNDupUndefinedSmallJsonG, \
2412  bool: getAtNDupBoolSmallJsonG, \
2413  double: getAtNDupDoubleSmallJsonG, \
2414  int64_t: getAtNDupIntSmallJsonG, \
2415  int32_t: getAtNDupInt32SmallJsonG, \
2416  uint64_t: getAtNDupUintSmallJsonG, \
2417  uint32_t: getAtNDupUint32SmallJsonG, \
2418  char*: getAtNDupSSmallJsonG, \
2419  smallDictt*: getAtNDupDictSmallJsonG, \
2420  smallArrayt*: getAtNDupArraySmallJsonG, \
2421  smallBoolt*: getAtNDupSmallBoolSmallJsonG, \
2422  smallBytest*: getAtNDupSmallBytesSmallJsonG, \
2423  smallDoublet*: getAtNDupSmallDoubleSmallJsonG, \
2424  smallIntt*: getAtNDupSmallIntSmallJsonG, \
2425  smallJsont*: getAtNDupSmallJsonSmallJsonG, \
2426  smallStringt*: getAtNDupSmallStringSmallJsonG, \
2427  void*: getAtNDupVoidSmallJsonG, \
2428  smallContainert*: getAtNDupSmallContainerSmallJsonG, \
2429  default: getAtNDupSmallJsonG), \
2430  int8_t: _Generic((returnType), \
2431  baset*: getAtNDupSmallJsonG, \
2432  undefinedt*: getAtNDupUndefinedSmallJsonG, \
2433  bool: getAtNDupBoolSmallJsonG, \
2434  double: getAtNDupDoubleSmallJsonG, \
2435  int64_t: getAtNDupIntSmallJsonG, \
2436  int32_t: getAtNDupInt32SmallJsonG, \
2437  uint64_t: getAtNDupUintSmallJsonG, \
2438  uint32_t: getAtNDupUint32SmallJsonG, \
2439  char*: getAtNDupSSmallJsonG, \
2440  smallDictt*: getAtNDupDictSmallJsonG, \
2441  smallArrayt*: getAtNDupArraySmallJsonG, \
2442  smallBoolt*: getAtNDupSmallBoolSmallJsonG, \
2443  smallBytest*: getAtNDupSmallBytesSmallJsonG, \
2444  smallDoublet*: getAtNDupSmallDoubleSmallJsonG, \
2445  smallIntt*: getAtNDupSmallIntSmallJsonG, \
2446  smallJsont*: getAtNDupSmallJsonSmallJsonG, \
2447  smallStringt*: getAtNDupSmallStringSmallJsonG, \
2448  void*: getAtNDupVoidSmallJsonG, \
2449  smallContainert*: getAtNDupSmallContainerSmallJsonG, \
2450  default: getAtNDupSmallJsonG), \
2451  uint64_t: _Generic((returnType), \
2452  baset*: getAtNDupSmallJsonG, \
2453  undefinedt*: getAtNDupUndefinedSmallJsonG, \
2454  bool: getAtNDupBoolSmallJsonG, \
2455  double: getAtNDupDoubleSmallJsonG, \
2456  int64_t: getAtNDupIntSmallJsonG, \
2457  int32_t: getAtNDupInt32SmallJsonG, \
2458  uint64_t: getAtNDupUintSmallJsonG, \
2459  uint32_t: getAtNDupUint32SmallJsonG, \
2460  char*: getAtNDupSSmallJsonG, \
2461  smallDictt*: getAtNDupDictSmallJsonG, \
2462  smallArrayt*: getAtNDupArraySmallJsonG, \
2463  smallBoolt*: getAtNDupSmallBoolSmallJsonG, \
2464  smallBytest*: getAtNDupSmallBytesSmallJsonG, \
2465  smallDoublet*: getAtNDupSmallDoubleSmallJsonG, \
2466  smallIntt*: getAtNDupSmallIntSmallJsonG, \
2467  smallJsont*: getAtNDupSmallJsonSmallJsonG, \
2468  smallStringt*: getAtNDupSmallStringSmallJsonG, \
2469  void*: getAtNDupVoidSmallJsonG, \
2470  smallContainert*: getAtNDupSmallContainerSmallJsonG, \
2471  default: getAtNDupSmallJsonG), \
2472  uint32_t: _Generic((returnType), \
2473  baset*: getAtNDupSmallJsonG, \
2474  undefinedt*: getAtNDupUndefinedSmallJsonG, \
2475  bool: getAtNDupBoolSmallJsonG, \
2476  double: getAtNDupDoubleSmallJsonG, \
2477  int64_t: getAtNDupIntSmallJsonG, \
2478  int32_t: getAtNDupInt32SmallJsonG, \
2479  uint64_t: getAtNDupUintSmallJsonG, \
2480  uint32_t: getAtNDupUint32SmallJsonG, \
2481  char*: getAtNDupSSmallJsonG, \
2482  smallDictt*: getAtNDupDictSmallJsonG, \
2483  smallArrayt*: getAtNDupArraySmallJsonG, \
2484  smallBoolt*: getAtNDupSmallBoolSmallJsonG, \
2485  smallBytest*: getAtNDupSmallBytesSmallJsonG, \
2486  smallDoublet*: getAtNDupSmallDoubleSmallJsonG, \
2487  smallIntt*: getAtNDupSmallIntSmallJsonG, \
2488  smallJsont*: getAtNDupSmallJsonSmallJsonG, \
2489  smallStringt*: getAtNDupSmallStringSmallJsonG, \
2490  void*: getAtNDupVoidSmallJsonG, \
2491  smallContainert*: getAtNDupSmallContainerSmallJsonG, \
2492  default: getAtNDupSmallJsonG), \
2493  uint16_t: _Generic((returnType), \
2494  baset*: getAtNDupSmallJsonG, \
2495  undefinedt*: getAtNDupUndefinedSmallJsonG, \
2496  bool: getAtNDupBoolSmallJsonG, \
2497  double: getAtNDupDoubleSmallJsonG, \
2498  int64_t: getAtNDupIntSmallJsonG, \
2499  int32_t: getAtNDupInt32SmallJsonG, \
2500  uint64_t: getAtNDupUintSmallJsonG, \
2501  uint32_t: getAtNDupUint32SmallJsonG, \
2502  char*: getAtNDupSSmallJsonG, \
2503  smallDictt*: getAtNDupDictSmallJsonG, \
2504  smallArrayt*: getAtNDupArraySmallJsonG, \
2505  smallBoolt*: getAtNDupSmallBoolSmallJsonG, \
2506  smallBytest*: getAtNDupSmallBytesSmallJsonG, \
2507  smallDoublet*: getAtNDupSmallDoubleSmallJsonG, \
2508  smallIntt*: getAtNDupSmallIntSmallJsonG, \
2509  smallJsont*: getAtNDupSmallJsonSmallJsonG, \
2510  smallStringt*: getAtNDupSmallStringSmallJsonG, \
2511  void*: getAtNDupVoidSmallJsonG, \
2512  smallContainert*: getAtNDupSmallContainerSmallJsonG, \
2513  default: getAtNDupSmallJsonG), \
2514  uint8_t: _Generic((returnType), \
2515  baset*: getAtNDupSmallJsonG, \
2516  undefinedt*: getAtNDupUndefinedSmallJsonG, \
2517  bool: getAtNDupBoolSmallJsonG, \
2518  double: getAtNDupDoubleSmallJsonG, \
2519  int64_t: getAtNDupIntSmallJsonG, \
2520  int32_t: getAtNDupInt32SmallJsonG, \
2521  uint64_t: getAtNDupUintSmallJsonG, \
2522  uint32_t: getAtNDupUint32SmallJsonG, \
2523  char*: getAtNDupSSmallJsonG, \
2524  smallDictt*: getAtNDupDictSmallJsonG, \
2525  smallArrayt*: getAtNDupArraySmallJsonG, \
2526  smallBoolt*: getAtNDupSmallBoolSmallJsonG, \
2527  smallBytest*: getAtNDupSmallBytesSmallJsonG, \
2528  smallDoublet*: getAtNDupSmallDoubleSmallJsonG, \
2529  smallIntt*: getAtNDupSmallIntSmallJsonG, \
2530  smallJsont*: getAtNDupSmallJsonSmallJsonG, \
2531  smallStringt*: getAtNDupSmallStringSmallJsonG, \
2532  void*: getAtNDupVoidSmallJsonG, \
2533  smallContainert*: getAtNDupSmallContainerSmallJsonG, \
2534  default: getAtNDupSmallJsonG), \
2535  default: getNDupSmallJsonG), \
2536  smallBytest*: getAtSmallBytesG, \
2537  smallStringt*: getAtSmallStringG, \
2538  smallBoolt*: getBoolSmallBoolG, \
2539  smallContainert*: getSmallContainerG, \
2540  smallDoublet*: getDoubleSmallDoubleG, \
2541  smallIntt*: _Generic((returnType), \
2542  int64_t: getIntSmallIntG, \
2543  int32_t: getInt32SmallIntG, \
2544  uint64_t: getUintSmallIntG, \
2545  uint32_t: getUint32SmallIntG, \
2546  default: getIntSmallIntG), \
2547  char *: getSG, \
2548  const char *: getSG, \
2549  char **: listGetG, \
2550  const char **: listGetCG \
2551  )(self, returnType, key)
2552 
2553 #define getNumO(self, key) (self)->f->getNum(self, key)
2554 #define getNumG(self, key) _Generic((self), \
2555  smallDictt*: getNumSmallDictG, \
2556  smallArrayt*: getNumSmallArrayG, \
2557  smallJsont*: _Generic(key, \
2558  char*: getNumSmallJsonG, \
2559  const char*: getNumSmallJsonG, \
2560  int64_t: getNumAtSmallJsonG, \
2561  int32_t: getNumAtSmallJsonG, \
2562  int16_t: getNumAtSmallJsonG, \
2563  int8_t: getNumAtSmallJsonG, \
2564  uint64_t: getNumAtSmallJsonG, \
2565  uint32_t: getNumAtSmallJsonG, \
2566  uint16_t: getNumAtSmallJsonG, \
2567  uint8_t: getNumAtSmallJsonG) \
2568  )(self, key)
2569 
2570 #define appendO(self, obj) (self)->f->append(self, obj)
2571 #define mergeO(self, obj) (self)->f->merge(self, obj)
2572 #define mergeG appendG
2573 #define appendG(self, obj) _Generic((self), \
2574  smallDictt*: _Generic(obj, \
2575  smallDictt*: mergeSmallDictG, \
2576  smallJsont*: mergeSmallJsonSmallDictG, \
2577  default: mergeSmallDictG), \
2578  smallArrayt*: _Generic(obj, \
2579  smallArrayt *: appendSmallArrayG, \
2580  smallJsont *: appendSmallJsonSmallArrayG, \
2581  char **: appendArraySmallArrayG, \
2582  const char **: appendCArraySmallArrayG, \
2583  default: appendSmallArrayG), \
2584  smallJsont*: _Generic(obj, \
2585  smallArrayt *: appendSmallJsonG, \
2586  char **: appendArraySmallJsonG, \
2587  const char **: appendCArraySmallJsonG, \
2588  smallDictt *: mergeDictSmallJsonG, \
2589  smallJsont *: mergeSmallJsonG, \
2590  default: mergeSmallJsonG), \
2591  smallStringt*: _Generic((obj), \
2592  smallStringt*: appendSmallStringG, \
2593  smallJsont*: appendSmallJsonSmallStringG, \
2594  char *: appendSSmallStringG, \
2595  char: appendCharSmallStringG, \
2596  int: appendCharSmallStringG, \
2597  default: appendSSmallStringG), \
2598  char: appendSChar, \
2599  int: appendSChar, \
2600  char *: _Generic(obj, \
2601  char *: appendS, \
2602  const char *: appendS, \
2603  char: appendCharS, \
2604  int: appendCharS, \
2605  default: appendS \
2606  ), \
2607  const char *: _Generic(obj, \
2608  char *: appendS, \
2609  const char *: appendS, \
2610  char: appendCharS, \
2611  int: appendCharS, \
2612  default: appendS \
2613  ), \
2614  char **: _Generic(obj, \
2615  char *: iAppendS, \
2616  const char *: iAppendS, \
2617  char: iAppendCharS, \
2618  int: iAppendCharS, \
2619  default: iAppendS \
2620  ), \
2621  char ***: iListAppendS \
2622  )(self, obj)
2623 
2624 #define appendNSmashO(self, obj) (self)->f->appendNSmash(self, obj)
2625 #define mergeNSmashO(self, obj) (self)->f->mergeNSmash(self, obj)
2626 #define mergeNSmashG appendNSmashG
2627 #define appendNFreeG appendNSmashG
2628 #define mergeNFreeG appendNSmashG
2629 #define appendNSmashG(self, obj) _Generic((self), \
2630  smallDictt*: _Generic(obj, \
2631  smallDictt*: mergeNSmashSmallDictG, \
2632  smallJsont*: mergeNSmashSmallJsonSmallDictG, \
2633  default: mergeNSmashSmallDictG), \
2634  smallArrayt*: _Generic(obj, \
2635  smallArrayt *: appendNSmashSmallArrayG, \
2636  smallJsont *: appendNSmashSmallJsonSmallArrayG, \
2637  char **: appendNSmashArraySmallArrayG, \
2638  default: appendNSmashSmallArrayG), \
2639  smallJsont*: _Generic(obj, \
2640  smallArrayt *: appendNSmashSmallJsonG, \
2641  char **: appendNSmashArraySmallJsonG, \
2642  smallDictt *: mergeDictNSmashSmallJsonG, \
2643  smallJsont *: mergeNSmashSmallJsonG, \
2644  default: mergeNSmashSmallJsonG), \
2645  smallStringt*: _Generic((obj), \
2646  smallStringt*: appendNSmashSmallStringG, \
2647  smallJsont*: appendNSmashSmallJsonSmallStringG, \
2648  char *: appendNSmashSSmallStringG, \
2649  char: appendCharSmallStringG, \
2650  int: appendCharSmallStringG, \
2651  default: appendSSmallStringG), \
2652  char **: _Generic(obj, \
2653  char *: iAppendNFreeS, \
2654  char: iAppendCharS, \
2655  int: iAppendCharS, \
2656  default: iAppendNFreeS \
2657  ), \
2658  char ***: iListAppendNSmashS \
2659  )(self, obj)
2660 
2661 #define prependO(self, value) (self)->f->prepend(self, value)
2662 #define prependG(self, value) _Generic((self), \
2663  smallArrayt*: _Generic((value), \
2664  baset*: prependSmallArrayG, \
2665  bool: prependBoolSmallArrayG, \
2666  double: prependDoubleSmallArrayG, \
2667  int64_t: prependIntSmallArrayG, \
2668  int32_t: prependIntSmallArrayG, \
2669  uint32_t: prependIntSmallArrayG, \
2670  uint64_t: prependIntSmallArrayG, \
2671  char*: prependSSmallArrayG, \
2672  char: prependCharSmallArrayG, \
2673  const char*: prependSSmallArrayG, \
2674  smallDictt*: prependDictSmallArrayG, \
2675  smallArrayt*: prependArraySmallArrayG, \
2676  char **: prependArraycSmallArrayG, \
2677  const char **: prependCArraycSmallArrayG, \
2678  smallBoolt*: prependSmallBoolSmallArrayG, \
2679  smallBytest*: prependSmallBytesSmallArrayG, \
2680  smallDoublet*: prependSmallDoubleSmallArrayG, \
2681  smallIntt*: prependSmallIntSmallArrayG, \
2682  smallJsont*: prependSmallJsonSmallArrayG, \
2683  smallStringt*: prependSmallStringSmallArrayG, \
2684  smallContainert*: prependSmallContainerSmallArrayG, \
2685  undefinedt*: prependUndefinedSmallArrayG, \
2686  default: prependVoidSmallArrayG), \
2687  smallJsont*: _Generic((value), \
2688  baset*: prependSmallJsonG, \
2689  bool: prependBoolSmallJsonG, \
2690  double: prependDoubleSmallJsonG, \
2691  int64_t: prependIntSmallJsonG, \
2692  int32_t: prependIntSmallJsonG, \
2693  uint32_t: prependIntSmallJsonG, \
2694  uint64_t: prependIntSmallJsonG, \
2695  char*: prependSSmallJsonG, \
2696  char: prependCharSmallJsonG, \
2697  const char*: prependSSmallJsonG, \
2698  smallDictt*: prependDictSmallJsonG, \
2699  smallArrayt*: prependArraySmallJsonG, \
2700  char **: prependArraycSmallJsonG, \
2701  const char **: prependCArraycSmallJsonG, \
2702  smallBoolt*: prependSmallBoolSmallJsonG, \
2703  smallBytest*: prependSmallBytesSmallJsonG, \
2704  smallDoublet*: prependSmallDoubleSmallJsonG, \
2705  smallIntt*: prependSmallIntSmallJsonG, \
2706  smallJsont*: prependSmallJsonSmallJsonG, \
2707  smallStringt*: prependSmallStringSmallJsonG, \
2708  smallContainert*: prependSmallContainerSmallJsonG, \
2709  undefinedt*: prependUndefinedSmallJsonG, \
2710  default: prependVoidSmallJsonG), \
2711  smallStringt*: _Generic((value), \
2712  smallStringt*: prependSmallStringG, \
2713  smallJsont*: prependSmallJsonSmallStringG, \
2714  char *: prependSSmallStringG, \
2715  char: prependCharSmallStringG, \
2716  int: prependCharSmallStringG, \
2717  default: prependSSmallStringG), \
2718  char: prependSChar, \
2719  int: prependSChar, \
2720  char *: _Generic(value, \
2721  char *: prependS, \
2722  const char *: prependS, \
2723  char: prependCharS, \
2724  int: prependCharS, \
2725  default: prependS \
2726  ), \
2727  const char *: _Generic(value, \
2728  char *: prependS, \
2729  const char *: prependS, \
2730  char: prependCharS, \
2731  int: prependCharS, \
2732  default: prependS \
2733  ), \
2734  char **: _Generic(value, \
2735  char *: iPrependS, \
2736  const char *: iPrependS, \
2737  char: iPrependCharS, \
2738  int: iPrependCharS, \
2739  default: iPrependS \
2740  ), \
2741  char ***: _Generic(value, \
2742  char *: listPrependS, \
2743  const char *: listPrependS, \
2744  char: listPrependCharS, \
2745  int: listPrependCharS, \
2746  default: listPrependS \
2747  ) \
2748  )(self, value)
2749 
2750 #define prependNFreeO(self, value) (self)->f->prependNFree(self, value)
2751 #define prependNSmashO(self, string) (self)->f->prependNSmash(self, string)
2752 #define prependNFreeG(self, obj) _Generic((self), \
2753  smallArrayt*: _Generic((obj), \
2754  baset*: prependNFreeSmallArrayG, \
2755  bool: prependBoolSmallArrayG, \
2756  double: prependDoubleSmallArrayG, \
2757  int64_t: prependIntSmallArrayG, \
2758  int32_t: prependIntSmallArrayG, \
2759  uint32_t: prependIntSmallArrayG, \
2760  uint64_t: prependIntSmallArrayG, \
2761  char*: prependNFreeSSmallArrayG, \
2762  char: prependCharSmallArrayG, \
2763  smallDictt*: prependNFreeDictSmallArrayG, \
2764  smallArrayt*: prependNFreeArraySmallArrayG, \
2765  char **: prependNFreeArraycSmallArrayG, \
2766  smallBoolt*: prependNFreeSmallBoolSmallArrayG, \
2767  smallBytest*: prependNFreeSmallBytesSmallArrayG, \
2768  smallDoublet*: prependNFreeSmallDoubleSmallArrayG, \
2769  smallIntt*: prependNFreeSmallIntSmallArrayG, \
2770  smallJsont*: prependNFreeSmallJsonSmallArrayG, \
2771  smallStringt*: prependNFreeSmallStringSmallArrayG, \
2772  smallContainert*: prependNFreeSmallContainerSmallArrayG, \
2773  undefinedt*: prependNFreeUndefinedSmallArrayG, \
2774  default: prependVoidSmallArrayG), \
2775  smallJsont*: _Generic((obj), \
2776  baset*: prependNFreeSmallJsonG, \
2777  bool: prependBoolSmallJsonG, \
2778  double: prependDoubleSmallJsonG, \
2779  int64_t: prependIntSmallJsonG, \
2780  int32_t: prependIntSmallJsonG, \
2781  uint32_t: prependIntSmallJsonG, \
2782  uint64_t: prependIntSmallJsonG, \
2783  char*: prependNFreeSSmallJsonG, \
2784  char: prependCharSmallJsonG, \
2785  smallDictt*: prependNFreeDictSmallJsonG, \
2786  smallArrayt*: prependNFreeArraySmallJsonG, \
2787  char **: prependNFreeArraycSmallJsonG, \
2788  smallBoolt*: prependNFreeSmallBoolSmallJsonG, \
2789  smallBytest*: prependNFreeSmallBytesSmallJsonG, \
2790  smallDoublet*: prependNFreeSmallDoubleSmallJsonG, \
2791  smallIntt*: prependNFreeSmallIntSmallJsonG, \
2792  smallJsont*: prependNFreeSmallJsonSmallJsonG, \
2793  smallStringt*: prependNFreeSmallStringSmallJsonG, \
2794  smallContainert*: prependNFreeSmallContainerSmallJsonG, \
2795  undefinedt*: prependNFreeUndefinedSmallJsonG, \
2796  default: prependVoidSmallJsonG), \
2797  smallStringt*: _Generic((obj), \
2798  smallStringt*: prependNSmashSmallStringG, \
2799  smallJsont*: prependNSmashSmallJsonSmallStringG, \
2800  char *: prependNSmashSSmallStringG, \
2801  char: prependCharSmallStringG, \
2802  int: prependCharSmallStringG, \
2803  default: prependSSmallStringG), \
2804  char **: _Generic(obj, \
2805  char *: iPrependNFreeS, \
2806  char: iPrependCharS, \
2807  int: iPrependCharS, \
2808  default: iPrependNFreeS \
2809  ), \
2810  char ***: _Generic(obj, \
2811  char *: iListPrependS, \
2812  char: listPrependCharS, \
2813  int: listPrependCharS, \
2814  default: iListPrependS \
2815  ) \
2816  )(self, obj)
2817 
2818 #define shiftO(self, obj) (self)->f->shift(self, obj)
2819 #define shiftG(self, obj) _Generic((self), \
2820  smallDictt*: _Generic(obj, \
2821  smallDictt*: mergeSmallDictG, \
2822  smallJsont*: mergeSmallJsonSmallDictG, \
2823  default: mergeSmallDictG), \
2824  smallArrayt*: _Generic(obj, \
2825  smallArrayt *: shiftSmallArrayG, \
2826  smallJsont *: shiftSmallJsonSmallArrayG, \
2827  default: shiftSmallArrayG), \
2828  smallJsont*: _Generic(obj, \
2829  smallArrayt *: shiftSmallJsonG, \
2830  smallDictt *: mergeDictSmallJsonG, \
2831  smallJsont *: shiftSmallJsonSmallJsonG, \
2832  default: mergeSmallJsonG), \
2833  smallStringt*: _Generic((obj), \
2834  smallStringt*: prependSmallStringG, \
2835  smallJsont*: prependSmallJsonSmallStringG, \
2836  char *: prependSSmallStringG, \
2837  char: prependCharSmallStringG, \
2838  int: prependCharSmallStringG, \
2839  default: prependSSmallStringG), \
2840  char: prependSChar, \
2841  int: prependSChar, \
2842  char *: _Generic(obj, \
2843  char *: prependS, \
2844  const char *: prependS, \
2845  char: prependCharS, \
2846  int: prependCharS, \
2847  default: prependS \
2848  ), \
2849  const char *: _Generic(obj, \
2850  char *: prependS, \
2851  const char *: prependS, \
2852  char: prependCharS, \
2853  int: prependCharS, \
2854  default: prependS \
2855  ), \
2856  char **: _Generic(obj, \
2857  char *: iPrependS, \
2858  const char *: iPrependS, \
2859  char: iPrependCharS, \
2860  int: iPrependCharS, \
2861  default: iPrependS \
2862  ), \
2863  char ***: iListShiftS \
2864  )(self, obj)
2865 
2866 #define shiftNSmashO(self, obj) (self)->f->shiftNSmash(self, obj)
2867 #define shiftNFreeG shiftNSmashG
2868 #define shiftNSmashG(self, obj) _Generic((self), \
2869  smallDictt*: _Generic(obj, \
2870  smallDictt*: mergeNSmashSmallDictG, \
2871  smallJsont*: mergeNSmashSmallJsonSmallDictG, \
2872  default: mergeNSmashSmallDictG), \
2873  smallArrayt*: _Generic(obj, \
2874  smallArrayt *: shiftNSmashSmallArrayG, \
2875  smallJsont *: shiftNSmashSmallJsonSmallArrayG, \
2876  default: appendNSmashSmallArrayG), \
2877  smallJsont*: _Generic(obj, \
2878  smallArrayt *: shiftNSmashSmallJsonG, \
2879  smallDictt *: mergeDictNSmashSmallJsonG, \
2880  smallJsont *: shiftNSmashSmallJsonSmallJsonG, \
2881  default: mergeNSmashSmallJsonG), \
2882  smallStringt*: _Generic((obj), \
2883  smallStringt*: prependNSmashSmallStringG, \
2884  smallJsont*: prependNSmashSmallJsonSmallStringG, \
2885  char *: prependNSmashSSmallStringG, \
2886  char: prependCharSmallStringG, \
2887  int: prependCharSmallStringG, \
2888  default: prependSSmallStringG), \
2889  char **: _Generic(obj, \
2890  char *: iPrependNFreeS, \
2891  char: iPrependCharS, \
2892  int: iPrependCharS, \
2893  default: iPrependNFreeS \
2894  ), \
2895  char ***: iListShiftNSmashS \
2896  )(self, obj)
2897 
2898 #define delO(self, start, end) (self)->f->del(self, start, end)
2899 #define delG(self, start, end) _Generic((self), \
2900  smallDictt*: _Generic(start, \
2901  char *: delSmallDictG, \
2902  const char *: delSmallDictG, \
2903  char: delKCharSmallDictG, \
2904  int: delKCharSmallDictG, \
2905  default: delSmallDictG \
2906  ), \
2907  smallJsont*: _Generic(start, \
2908  char *: delKeySmallJsonG, \
2909  const char *: delKeySmallJsonG, \
2910  int64_t: delSmallJsonG, \
2911  int32_t: delSmallJsonG, \
2912  int16_t: delSmallJsonG, \
2913  int8_t: delSmallJsonG, \
2914  uint64_t: delSmallJsonG, \
2915  uint32_t: delSmallJsonG, \
2916  uint16_t: delSmallJsonG, \
2917  uint8_t: delSmallJsonG, \
2918  default: delSmallJsonG \
2919  ), \
2920  smallArrayt*: delSmallArrayG, \
2921  smallStringt*: delSmallStringG, \
2922  char **: iDelS, \
2923  char ***: iListDelS \
2924  )(self, start, end)
2925 
2926 #define delElemO(self, index) (self)->f->delElem(self, index)
2927 #define delElemG(self, index) _Generic((self), \
2928  smallDictt*: _Generic(index, \
2929  char *: delElemSmallDictG, \
2930  const char *: delElemSmallDictG, \
2931  char: delElemKCharSmallDictG, \
2932  int: delElemKCharSmallDictG, \
2933  default: delElemSmallDictG \
2934  ), \
2935  smallJsont*: _Generic(index, \
2936  char *: delElemSmallJsonG, \
2937  const char *: delElemSmallJsonG, \
2938  int64_t: delElemIndexSmallJsonG, \
2939  int32_t: delElemIndexSmallJsonG, \
2940  int16_t: delElemIndexSmallJsonG, \
2941  int8_t: delElemIndexSmallJsonG, \
2942  uint64_t: delElemIndexSmallJsonG, \
2943  uint32_t: delElemIndexSmallJsonG, \
2944  uint16_t: delElemIndexSmallJsonG, \
2945  uint8_t: delElemIndexSmallJsonG, \
2946  default: delElemSmallJsonG \
2947  ), \
2948  smallArrayt*: delElemSmallArrayG, \
2949  smallStringt*: delElemSmallStringG, \
2950  char **: iDelElemS, \
2951  char ***: iListDelElemS \
2952  )(self, index)
2953 
2954 #define removeO(self, start, end) (self)->f->remove(self, start, end)
2955 #define removeG(self, start, end) _Generic((self), \
2956  smallDictt*: _Generic(start, \
2957  char *: removeSmallDictG, \
2958  const char *: removeSmallDictG, \
2959  char: removeKCharSmallDictG, \
2960  int: removeKCharSmallDictG, \
2961  default: removeSmallDictG \
2962  ), \
2963  smallJsont*: _Generic(start, \
2964  char *: removeKeySmallJsonG, \
2965  const char *: removeKeySmallJsonG, \
2966  int64_t: removeSmallJsonG, \
2967  int32_t: removeSmallJsonG, \
2968  int16_t: removeSmallJsonG, \
2969  int8_t: removeSmallJsonG, \
2970  uint64_t: removeSmallJsonG, \
2971  uint32_t: removeSmallJsonG, \
2972  uint16_t: removeSmallJsonG, \
2973  uint8_t: removeSmallJsonG, \
2974  default: removeSmallJsonG \
2975  ), \
2976  smallArrayt*: removeSmallArrayG, \
2977  smallStringt*: delSmallStringG, \
2978  char **: iDelS, \
2979  char ***: iListRemoveS \
2980  )(self, start, end)
2981 
2982 #define removeElemO(self, index) (self)->f->removeElem(self, index)
2983 #define removeElemG(self, index) _Generic((self), \
2984  smallDictt*: _Generic(index, \
2985  char *: removeElemSmallDictG, \
2986  const char *: removeElemSmallDictG, \
2987  char: removeElemKCharSmallDictG, \
2988  int: removeElemKCharSmallDictG, \
2989  default: removeElemSmallDictG \
2990  ), \
2991  smallJsont*: _Generic(index, \
2992  char *: removeElemSmallJsonG, \
2993  const char *: removeElemSmallJsonG, \
2994  int64_t: removeElemIndexSmallJsonG, \
2995  int32_t: removeElemIndexSmallJsonG, \
2996  int16_t: removeElemIndexSmallJsonG, \
2997  int8_t: removeElemIndexSmallJsonG, \
2998  uint64_t: removeElemIndexSmallJsonG, \
2999  uint32_t: removeElemIndexSmallJsonG, \
3000  uint16_t: removeElemIndexSmallJsonG, \
3001  uint8_t: removeElemIndexSmallJsonG, \
3002  default: removeElemSmallJsonG \
3003  ), \
3004  smallArrayt*: removeElemSmallArrayG, \
3005  smallStringt*: delElemSmallStringG, \
3006  char **: iDelElemS, \
3007  char ***: iListRemoveElemS \
3008  )(self, index)
3009 
3010 #define popO(self) (self)->f->pop(self)
3011 #define popG(self, returnType) _Generic((self), \
3012  smallArrayt*: _Generic((returnType), \
3013  baset*: popSmallArrayG, \
3014  undefinedt*: popUndefinedSmallArrayG, \
3015  bool: popBoolSmallArrayG, \
3016  double: popDoubleSmallArrayG, \
3017  int64_t: popIntSmallArrayG, \
3018  int32_t: popInt32SmallArrayG, \
3019  uint64_t: popUintSmallArrayG, \
3020  uint32_t: popUint32SmallArrayG, \
3021  char*: popSSmallArrayG, \
3022  smallDictt*: popDictSmallArrayG, \
3023  smallArrayt*: popArraySmallArrayG, \
3024  smallBoolt*: popSmallBoolSmallArrayG, \
3025  smallBytest*: popSmallBytesSmallArrayG, \
3026  smallDoublet*: popSmallDoubleSmallArrayG, \
3027  smallIntt*: popSmallIntSmallArrayG, \
3028  smallJsont*: popSmallJsonSmallArrayG, \
3029  smallStringt*: popSmallStringSmallArrayG, \
3030  void*: popVoidSmallArrayG, \
3031  smallContainert*: popSmallContainerSmallArrayG, \
3032  default: popSmallArrayG), \
3033  smallJsont*: _Generic((returnType), \
3034  baset*: popSmallJsonG, \
3035  undefinedt*: popUndefinedSmallJsonG, \
3036  bool: popBoolSmallJsonG, \
3037  double: popDoubleSmallJsonG, \
3038  int64_t: popIntSmallJsonG, \
3039  int32_t: popInt32SmallJsonG, \
3040  uint64_t: popUintSmallJsonG, \
3041  uint32_t: popUint32SmallJsonG, \
3042  char*: popSSmallJsonG, \
3043  smallDictt*: popDictSmallJsonG, \
3044  smallArrayt*: popArraySmallJsonG, \
3045  smallBoolt*: popSmallBoolSmallJsonG, \
3046  smallBytest*: popSmallBytesSmallJsonG, \
3047  smallDoublet*: popSmallDoubleSmallJsonG, \
3048  smallIntt*: popSmallIntSmallJsonG, \
3049  smallJsont*: popSmallJsonSmallJsonG, \
3050  smallStringt*: popSmallStringSmallJsonG, \
3051  void*: popVoidSmallJsonG, \
3052  smallContainert*: popSmallContainerSmallJsonG, \
3053  default: popSmallJsonG), \
3054  char ***: listPopG \
3055  )(self, returnType)
3056 
3057 #define dequeueO(self) (self)->f->dequeue(self)
3058 #define dequeueG(self, returnType) _Generic((self), \
3059  smallArrayt*: _Generic((returnType), \
3060  baset*: dequeueSmallArrayG, \
3061  undefinedt*: dequeueUndefinedSmallArrayG, \
3062  bool: dequeueBoolSmallArrayG, \
3063  double: dequeueDoubleSmallArrayG, \
3064  int64_t: dequeueIntSmallArrayG, \
3065  int32_t: dequeueInt32SmallArrayG, \
3066  uint64_t: dequeueUintSmallArrayG, \
3067  uint32_t: dequeueUint32SmallArrayG, \
3068  char*: dequeueSSmallArrayG, \
3069  smallDictt*: dequeueDictSmallArrayG, \
3070  smallArrayt*: dequeueArraySmallArrayG, \
3071  smallBoolt*: dequeueSmallBoolSmallArrayG, \
3072  smallBytest*: dequeueSmallBytesSmallArrayG, \
3073  smallDoublet*: dequeueSmallDoubleSmallArrayG, \
3074  smallIntt*: dequeueSmallIntSmallArrayG, \
3075  smallJsont*: dequeueSmallJsonSmallArrayG, \
3076  smallStringt*: dequeueSmallStringSmallArrayG, \
3077  void*: dequeueVoidSmallArrayG, \
3078  smallContainert*: dequeueSmallContainerSmallArrayG, \
3079  default: dequeueSmallArrayG), \
3080  smallJsont*: _Generic((returnType), \
3081  baset*: dequeueSmallJsonG, \
3082  undefinedt*: dequeueUndefinedSmallJsonG, \
3083  bool: dequeueBoolSmallJsonG, \
3084  double: dequeueDoubleSmallJsonG, \
3085  int64_t: dequeueIntSmallJsonG, \
3086  int32_t: dequeueInt32SmallJsonG, \
3087  uint64_t: dequeueUintSmallJsonG, \
3088  uint32_t: dequeueUint32SmallJsonG, \
3089  char*: dequeueSSmallJsonG, \
3090  smallDictt*: dequeueDictSmallJsonG, \
3091  smallArrayt*: dequeueArraySmallJsonG, \
3092  smallBoolt*: dequeueSmallBoolSmallJsonG, \
3093  smallBytest*: dequeueSmallBytesSmallJsonG, \
3094  smallDoublet*: dequeueSmallDoubleSmallJsonG, \
3095  smallIntt*: dequeueSmallIntSmallJsonG, \
3096  smallJsont*: dequeueSmallJsonSmallJsonG, \
3097  smallStringt*: dequeueSmallStringSmallJsonG, \
3098  void*: dequeueVoidSmallJsonG, \
3099  smallContainert*: dequeueSmallContainerSmallJsonG, \
3100  default: dequeueSmallJsonG), \
3101  char ***: listDequeueG \
3102  )(self, returnType)
3103 
3104 
3105 
3106 #define getProgPathG(returnType) _Generic((returnType), \
3107  char *: getProgPath, \
3108  const char *: getProgPath, \
3109  smallJsont *: getProgPathJO, \
3110  smallStringt *: getProgPathO \
3111  )()
3112 
3113 #define getRealProgPathG(returnType) _Generic((returnType), \
3114  char *: getRealProgPath, \
3115  const char *: getRealProgPath, \
3116  smallJsont *: getRealProgPathJO, \
3117  smallStringt *: getRealProgPathO \
3118  )()
3119 
3120 #define systemG(cmd) _Generic((cmd), \
3121  char *: system, \
3122  const char *: system, \
3123  smallJsont *: systemJO, \
3124  smallStringt *: systemO \
3125  )(cmd)
3126 
3127 #define systemNFreeG(cmd) _Generic((cmd), \
3128  char *: systemNFreeF, \
3129  smallJsont *: systemNFreeJOF, \
3130  smallStringt *: systemNFreeOF \
3131  )(cmd, __LINE__, __func__, __FILE__)
3132 
3133 #define getModificationTimeG(path) _Generic(path, \
3134  char *: getModificationTime, \
3135  const char *: getModificationTime, \
3136  smallJsont *: getModificationTimeJO, \
3137  smallStringt *: getModificationTimeO \
3138  )(path)
3139 
3140 #define setModificationTimeG(path, mtime) _Generic(path, \
3141  char *: setModificationTime, \
3142  const char *: setModificationTime, \
3143  smallJsont *: setModificationTimeJO, \
3144  smallStringt *: setModificationTimeO \
3145  )(path, mtime)
3146 
3147 #define equalModificationTimesG(path1, path2) _Generic(path1, \
3148  char *: _Generic(path2, \
3149  char *: equalModificationTimes, \
3150  const char *: equalModificationTimes, \
3151  smallJsont *: equalModificationTimesSJO, \
3152  smallStringt *: equalModificationTimesSO \
3153  ), \
3154  const char *: _Generic(path2, \
3155  char *: equalModificationTimes, \
3156  const char *: equalModificationTimes, \
3157  smallJsont *: equalModificationTimesSJO, \
3158  smallStringt *: equalModificationTimesSO \
3159  ),\
3160  smallJsont *: _Generic(path2, \
3161  char *: equalModificationTimesJOS, \
3162  const char *: equalModificationTimesJOS, \
3163  smallJsont *: equalModificationTimesJO, \
3164  smallStringt *: equalModificationTimesJOO \
3165  ),\
3166  smallStringt *: _Generic(path2, \
3167  char *: equalModificationTimesOS, \
3168  const char *: equalModificationTimesOS, \
3169  smallJsont *: equalModificationTimesOJO, \
3170  smallStringt *: equalModificationTimesO \
3171  )\
3172  )(path1, path2)
3173 
3174 #define timeToSG(returnType, t) _Generic((returnType), \
3175  char *: timeToS, \
3176  smallJsont *: timeToJO, \
3177  smallStringt *: timeToSO \
3178  )(t)
3179 
3180 #define shDirnameG(path) _Generic((path), \
3181  char *: shDirname, \
3182  const char *: shDirname, \
3183  smallJsont *: shDirnameJO, \
3184  smallStringt *: shDirnameO \
3185  )(path)
3186 
3187 #define expandHomeG(path) _Generic((path), \
3188  char *: expandHome, \
3189  const char *: expandHome, \
3190  char **: iExpandHome, \
3191  smallJsont *: expandHomeJO, \
3192  smallStringt *: expandHomeO \
3193  )(path)
3194 
3195 #define normalizePathG(path) _Generic((path), \
3196  char *: normalizePath, \
3197  const char *: normalizePath, \
3198  char **: iNormalizePath, \
3199  smallJsont *: normalizePathJO, \
3200  smallStringt *: normalizePathO \
3201  )(path)
3202 
3203 #define getCwdG(returnType) _Generic((returnType), \
3204  char *: getCwd, \
3205  const char *: getCwd, \
3206  smallJsont *: getCwdJO, \
3207  smallStringt *: getCwdO \
3208  )()
3209 
3210 #define chDirG(path) _Generic((path), \
3211  char *: chDir, \
3212  const char *: chDir, \
3213  smallJsont *: chDirJO, \
3214  smallStringt *: chDirO \
3215  )(path)
3216 
3217 #define isDirG(path) _Generic((path), \
3218  char *: isDir, \
3219  const char *: isDir, \
3220  smallJsont *: isDirJO, \
3221  smallStringt *: isDirO \
3222  )(path)
3223 
3224 #define isLinkG(path) _Generic((path), \
3225  char *: isLink, \
3226  const char *: isLink, \
3227  smallJsont *: isLinkJO, \
3228  smallStringt *: isLinkO \
3229  )(path)
3230 
3231 #define fileExistsG(path) _Generic((path), \
3232  char *: fileExists, \
3233  const char *: fileExists, \
3234  smallJsont *: fileExistsJO, \
3235  smallStringt *: fileExistsO \
3236  )(path)
3237 
3238 #define fileChmodG(path, mode) _Generic((path), \
3239  char *: fileChmod, \
3240  const char *: fileChmod, \
3241  smallJsont *: fileChmodJO, \
3242  smallStringt *: fileChmodO \
3243  )(path, mode)
3244 
3245 #define fileSizeG(path) _Generic((path), \
3246  char *: fileSize, \
3247  const char *: fileSize, \
3248  smallJsont *: fileSizeJO, \
3249  smallStringt *: fileSizeO, \
3250  FILE *: fileSizeFP \
3251  )(path)
3252 
3253 #define readFileO(self, filePath) (self)->f->readFile(self, filePath)
3254 #define readTextO(self, filePath) (self)->f->readText(self, filePath)
3255 #define readFileG(self, path) _Generic((self), \
3256  smallArrayt *: _Generic(path, \
3257  char *: readTextSmallArrayG, \
3258  const char*: readTextSmallArrayG, \
3259  FILE *: readStreamSmallArrayG, \
3260  smallJsont *: readTextSmallJsonSmallArrayG, \
3261  smallStringt *: readTextSmallStringSmallArrayG \
3262  ), \
3263  smallBoolt *: _Generic(path, \
3264  char *: readFileSmallBoolG, \
3265  const char*: readFileSmallBoolG, \
3266  FILE *: readStreamSmallBoolG, \
3267  smallJsont *: readFileSmallJsonSmallBoolG, \
3268  smallStringt *: readFileSmallStringSmallBoolG \
3269  ), \
3270  smallDoublet *: _Generic(path, \
3271  char *: readFileSmallDoubleG, \
3272  const char*: readFileSmallDoubleG, \
3273  FILE *: readStreamSmallDoubleG, \
3274  smallJsont *: readFileSmallJsonSmallDoubleG, \
3275  smallStringt *: readFileSmallStringSmallDoubleG \
3276  ), \
3277  smallIntt *: _Generic(path, \
3278  char *: readFileSmallIntG, \
3279  const char*: readFileSmallIntG, \
3280  FILE *: readStreamSmallIntG, \
3281  smallJsont *: readFileSmallJsonSmallIntG, \
3282  smallStringt *: readFileSmallStringSmallIntG \
3283  ), \
3284  smallStringt *: _Generic(path, \
3285  char *: readFileSmallStringG, \
3286  const char*: readFileSmallStringG, \
3287  FILE *: readStreamSmallStringG, \
3288  smallJsont *: readFileSmallJsonSmallStringG, \
3289  smallStringt *: readFileSmallStringSmallStringG \
3290  ), \
3291  smallBytest *: _Generic(path, \
3292  char *: readFileSmallBytesG, \
3293  const char*: readFileSmallBytesG, \
3294  FILE *: readStreamSmallBytesG, \
3295  smallJsont *: readFileSmallJsonSmallBytesG, \
3296  smallStringt *: readFileSmallStringSmallBytesG \
3297  ), \
3298  smallJsont *: _Generic(path, \
3299  char *: readFileSmallJsonG, \
3300  const char*: readFileSmallJsonG, \
3301  FILE *: readStreamSmallJsonG, \
3302  smallJsont *: readFileJsonSmallJsonG, \
3303  smallStringt *: readFileSmallStringSmallJsonG \
3304  ), \
3305  char **: _Generic(path, \
3306  char *: readFileToG, \
3307  const char *: readFileToG, \
3308  FILE *: readStreamToG, \
3309  smallJsont *: readToFileSmallJsonNotSupported, \
3310  smallStringt *: readToFileSmallStringNotSupported \
3311  ), \
3312  char ***: _Generic(path, \
3313  char *: readTextSG, \
3314  const char *: readTextSG, \
3315  FILE *: readTextStreamG, \
3316  smallJsont *: readTextSmallJsonNotSupported, \
3317  smallStringt *: readTextSmallStringNotSupported \
3318  ), \
3319  char *: _Generic(path, \
3320  char *: readFileToNewG, \
3321  const char *: readFileToNewG, \
3322  FILE *: readStreamToNewG, \
3323  smallJsont *: readToFileSmallJsonNotSupported, \
3324  smallStringt *: readToFileSmallStringNotSupported \
3325  ), \
3326  default: _Generic(path, \
3327  char *: readFileToNewG, \
3328  const char *: readFileToNewG, \
3329  FILE *: readStreamToNewG, \
3330  smallJsont *: readToFileSmallJsonNotSupported, \
3331  smallStringt *: readToFileSmallStringNotSupported \
3332  ) \
3333  )(self, path)
3334 
3335 #define readTextG(self, path) _Generic((self), \
3336  smallArrayt *: _Generic(path, \
3337  char *: readTextSmallArrayG, \
3338  const char*: readTextSmallArrayG, \
3339  FILE *: readStreamSmallArrayG, \
3340  smallJsont *: readTextSmallJsonSmallArrayG, \
3341  smallStringt *: readTextSmallStringSmallArrayG \
3342  ), \
3343  smallStringt *: _Generic(path, \
3344  char *: readFileSmallStringG, \
3345  const char*: readFileSmallStringG, \
3346  FILE *: readStreamSmallStringG, \
3347  smallJsont *: readFileSmallJsonSmallStringG, \
3348  smallStringt *: readFileSmallStringSmallStringG \
3349  ), \
3350  smallJsont *: _Generic(path, \
3351  char *: readTextSmallJsonG, \
3352  const char*: readTextSmallJsonG, \
3353  FILE *: readTextStreamSmallJsonG, \
3354  smallJsont *: readTextJsonSmallJsonG, \
3355  smallStringt *: readTextSmallStringSmallJsonG \
3356  ), \
3357  char **: _Generic(path, \
3358  char *: readFileToG, \
3359  const char *: readFileToG, \
3360  FILE *: readStreamToG, \
3361  smallJsont *: readToFileSmallJsonNotSupported, \
3362  smallStringt *: readToFileSmallStringNotSupported \
3363  ), \
3364  char ***: _Generic(path, \
3365  char *: readTextSG, \
3366  const char *: readTextSG, \
3367  FILE *: readTextStreamG, \
3368  smallJsont *: readTextSmallJsonNotSupported, \
3369  smallStringt *: readTextSmallStringNotSupported \
3370  ), \
3371  char *: _Generic(path, \
3372  char *: readFileToNewG, \
3373  const char *: readFileToNewG, \
3374  FILE *: readStreamToNewG, \
3375  smallJsont *: readToFileSmallJsonNotSupported, \
3376  smallStringt *: readToFileSmallStringNotSupported \
3377  ), \
3378  default: _Generic(path, \
3379  char *: readFileToNewG, \
3380  const char *: readFileToNewG, \
3381  FILE *: readStreamToNewG, \
3382  smallJsont *: readToFileSmallJsonNotSupported, \
3383  smallStringt *: readToFileSmallStringNotSupported \
3384  ) \
3385  )(self, path)
3386 
3387 #define writeFileO(self, filePath) (self)->f->writeFile(self, filePath)
3388 #define writeTextO(self, filePath) (self)->f->writeText(self, filePath)
3389 #define writeFileG(self, path) _Generic((self), \
3390  smallArrayt *: _Generic(path, \
3391  char *: writeTextSmallArrayG, \
3392  const char *: writeTextSmallArrayG, \
3393  FILE *: writeStreamSmallArrayG, \
3394  smallJsont *: writeTextSmallJsonSmallArrayG, \
3395  smallStringt *: writeTextSmallStringSmallArrayG \
3396  ), \
3397  smallBoolt *: _Generic(path, \
3398  char *: writeFileSmallBoolG, \
3399  const char *: writeFileSmallBoolG, \
3400  FILE *: writeStreamSmallBoolG, \
3401  smallJsont *: writeFileSmallJsonSmallBoolG, \
3402  smallStringt *: writeFileSmallStringSmallBoolG \
3403  ), \
3404  smallDoublet *: _Generic(path, \
3405  char *: writeFileSmallDoubleG, \
3406  const char *: writeFileSmallDoubleG, \
3407  FILE *: writeStreamSmallDoubleG, \
3408  smallJsont *: writeFileSmallJsonSmallDoubleG, \
3409  smallStringt *: writeFileSmallStringSmallDoubleG \
3410  ), \
3411  smallIntt *: _Generic(path, \
3412  char *: writeFileSmallIntG, \
3413  const char *: writeFileSmallIntG, \
3414  FILE *: writeStreamSmallIntG, \
3415  smallJsont *: writeFileSmallJsonSmallIntG, \
3416  smallStringt *: writeFileSmallStringSmallIntG \
3417  ), \
3418  smallStringt *: _Generic(path, \
3419  char *: writeFileSmallStringG, \
3420  const char *: writeFileSmallStringG, \
3421  FILE *: writeStreamSmallStringG, \
3422  smallJsont *: writeFileSmallJsonSmallStringG, \
3423  smallStringt *: writeFileSmallStringSmallStringG \
3424  ), \
3425  smallBytest *: _Generic(path, \
3426  char *: writeFileSmallBytesG, \
3427  const char *: writeFileSmallBytesG, \
3428  FILE *: writeStreamSmallBytesG, \
3429  smallJsont *: writeFileSmallJsonSmallBytesG, \
3430  smallStringt *: writeFileSmallStringSmallBytesG \
3431  ), \
3432  smallDictt *: _Generic(path, \
3433  char *: writeFileSmallDictG, \
3434  const char *: writeFileSmallDictG, \
3435  FILE *: writeStreamSmallDictG, \
3436  smallJsont *: writeFileSmallJsonSmallDictG, \
3437  smallStringt *: writeFileSmallStringSmallDictG \
3438  ), \
3439  smallJsont *: _Generic(path, \
3440  char *: writeFileSmallJsonG, \
3441  const char *: writeFileSmallJsonG, \
3442  FILE *: writeStreamSmallJsonG, \
3443  smallJsont *: writeFileJsonSmallJsonG, \
3444  smallStringt *: writeFileSmallStringSmallJsonG \
3445  ), \
3446  char **: _Generic(path, \
3447  char *: writeTextSG, \
3448  const char *: writeTextSG, \
3449  FILE *: writeTextStreamG, \
3450  smallJsont *: writeTextSmallJsonNotSupported, \
3451  smallStringt *: writeTextSmallStringNotSupported \
3452  ), \
3453  const char **: _Generic(path, \
3454  char *: writeTextCG, \
3455  const char *: writeTextCG, \
3456  FILE *: writeTextStreamCG, \
3457  smallJsont *: writeTextCCSmallJsonNotSupported, \
3458  smallStringt *: writeTextCCSmallStringNotSupported \
3459  ), \
3460  const char *: _Generic(path, \
3461  char *: writeFileFromG, \
3462  const char *: writeFileFromG, \
3463  FILE *: writeStreamFromG, \
3464  default: writeFileFromG \
3465  ), \
3466  char *: _Generic(path, \
3467  char *: writeFileFromG, \
3468  const char *: writeFileFromG, \
3469  FILE *: writeStreamFromG, \
3470  default: writeFileFromG \
3471  ) \
3472  )(self, path)
3473 
3474 #define writeTextG(self, path) _Generic((self), \
3475  smallArrayt *: _Generic(path, \
3476  char *: writeTextSmallArrayG, \
3477  const char *: writeTextSmallArrayG, \
3478  FILE *: writeStreamSmallArrayG, \
3479  smallJsont *: writeTextSmallJsonSmallArrayG, \
3480  smallStringt *: writeTextSmallStringSmallArrayG \
3481  ), \
3482  smallStringt *: _Generic(path, \
3483  char *: writeFileSmallStringG, \
3484  const char *: writeFileSmallStringG, \
3485  FILE *: writeStreamSmallStringG, \
3486  smallJsont *: writeFileSmallJsonSmallStringG, \
3487  smallStringt *: writeFileSmallStringSmallStringG \
3488  ), \
3489  smallJsont *: _Generic(path, \
3490  char *: writeTextSmallJsonG, \
3491  const char *: writeTextSmallJsonG, \
3492  FILE *: writeTextStreamSmallJsonG, \
3493  smallJsont *: writeTextJsonSmallJsonG, \
3494  smallStringt *: writeTextSmallStringSmallJsonG \
3495  ), \
3496  char **: _Generic(path, \
3497  char *: writeTextSG, \
3498  const char *: writeTextSG, \
3499  FILE *: writeTextStreamG, \
3500  smallJsont *: writeTextSmallJsonNotSupported, \
3501  smallStringt *: writeTextSmallStringNotSupported \
3502  ), \
3503  const char **: _Generic(path, \
3504  char *: writeTextCG, \
3505  const char *: writeTextCG, \
3506  FILE *: writeTextStreamCG, \
3507  smallJsont *: writeTextCCSmallJsonNotSupported, \
3508  smallStringt *: writeTextCCSmallStringNotSupported \
3509  ), \
3510  const char *: _Generic(path, \
3511  char *: writeFileFromG, \
3512  const char *: writeFileFromG, \
3513  FILE *: writeStreamFromG, \
3514  default: writeFileFromG \
3515  ), \
3516  char *: _Generic(path, \
3517  char *: writeFileFromG, \
3518  const char *: writeFileFromG, \
3519  FILE *: writeStreamFromG, \
3520  default: writeFileFromG \
3521  ) \
3522  )(self, path)
3523 
3524 #define appendFileO(self, filePath) (self)->f->appendFile(self, filePath)
3525 #define appendFileG(self, path) _Generic((self), \
3526  smallArrayt *: _Generic(path, \
3527  char *: appendTextSmallArrayG, \
3528  const char *: appendTextSmallArrayG, \
3529  smallStringt *: appendTextSmallStringSmallArrayG, \
3530  default: appendTextSmallArrayG), \
3531  smallBytest *: _Generic(path, \
3532  char *: appendFileSmallBytesG, \
3533  const char *: appendFileSmallBytesG, \
3534  smallStringt *: appendFileSmallStringSmallBytesG, \
3535  default: appendFileSmallBytesG), \
3536  smallDictt *: _Generic(path, \
3537  char *: appendFileSmallDictG, \
3538  const char *: appendFileSmallDictG, \
3539  smallStringt *: appendFileSmallStringSmallDictG, \
3540  default: appendFileSmallDictG), \
3541  smallJsont *: _Generic(path, \
3542  char *: appendFileSmallJsonG, \
3543  const char *: appendFileSmallJsonG, \
3544  smallStringt *: appendFileSmallStringSmallJsonG, \
3545  smallJsont *: appendFileJsonSmallJsonG), \
3546  char *: appendFileSG, \
3547  const char *: appendFileSG, \
3548  char **: appendTextSG, \
3549  const char **: appendTextCG \
3550  )(self, path)
3551 
3552 //TODO typeStringSmallArray rtChar rtSmallStringt
3553 //TODO typeStringsSmallArray
3554 
3555 //TODO keys rtChar rtSmallArrayt
3556 
3557 #define zipO(self, keys, values) (self)->f->zip(self, keys, values)
3558 #define zipG(self, keys, values) _Generic(self, \
3559  smallJsont *: _Generic(keys, \
3560  smallArrayt *: _Generic(values, \
3561  smallArrayt *: zipSmallJsonG, \
3562  smallJsont *: zipSmallArrayJsonSmallJsonG, \
3563  char **: zipCharSmallJsonG, \
3564  const char **: zipCCharSmallJsonG \
3565  ), \
3566  smallJsont *: _Generic(values, \
3567  smallArrayt *: zipJsonSmallArraySmallJsonG, \
3568  smallJsont *: zipJsonSmallJsonG, \
3569  char **: zipJsonArraySmallJsonG, \
3570  const char **: zipJsonCArraySmallJsonG \
3571  ), \
3572  char **: _Generic(values, \
3573  smallArrayt *: zipArraySmallJsonG, \
3574  smallJsont *: zipArrayJsonSmallJsonG, \
3575  char **: zipArrayCharSmallJsonG, \
3576  const char **: zipArrayCCharSmallJsonG \
3577  ), \
3578  const char **: _Generic(values, \
3579  smallArrayt *: zipCArraySmallJsonG, \
3580  smallJsont *: zipCArrayJsonSmallJsonG, \
3581  char **: zipCArrayCharSmallJsonG, \
3582  const char **: zipCArrayCCharSmallJsonG \
3583  ) \
3584  ), \
3585  smallDictt *: _Generic(keys, \
3586  smallArrayt *: _Generic(values, \
3587  smallArrayt *: zipSmallDictG, \
3588  smallJsont *: zipSmallJsonSmallDictG, \
3589  char **: zipVArraySmallDictG, \
3590  const char **: zipVCArraySmallDictG \
3591  ), \
3592  smallJsont *: _Generic(values, \
3593  smallArrayt *: zipSmallJsonSmallArraySmallDictG, \
3594  smallJsont *: zipSmallJsonSmallJsonSmallDictG, \
3595  char **: zipSmallJsonVArraySmallDictG, \
3596  const char **: zipSmallJsonVCArraySmallDictG \
3597  ), \
3598  char **: _Generic(values, \
3599  smallArrayt *: zipArraySmallDictG, \
3600  smallJsont *: zipArraySmallJsonSmallDictG, \
3601  char **: zipArrayArraySmallDictG, \
3602  const char **: zipArrayCArraySmallDictG \
3603  ), \
3604  const char **: _Generic(values, \
3605  smallArrayt *: zipCArraySmallDictG, \
3606  smallJsont *: zipCArraySmallJsonSmallDictG, \
3607  char **: zipCArrayArraySmallDictG, \
3608  const char **: zipCArrayCArraySmallDictG \
3609  ) \
3610  ), \
3611  smallArrayt *: _Generic(keys, \
3612  smallArrayt *: _Generic(values, \
3613  smallArrayt *: zipSmallArrayG, \
3614  smallJsont *: zipSmallJsonSmallArrayG, \
3615  char **: zipCharSmallArrayG, \
3616  const char **: zipCCharSmallArrayG \
3617  ), \
3618  smallJsont *: _Generic(values, \
3619  smallArrayt *: zipSmallJsonSmallArraySmallArrayG, \
3620  smallJsont *: zipSmallJsonSmallJsonSmallArrayG, \
3621  char **: zipSmallJsonCharSmallArrayG, \
3622  const char **: zipSmallJsonCCharSmallArrayG \
3623  ), \
3624  char **: _Generic(values, \
3625  smallArrayt *: zipArraySmallArrayG, \
3626  smallJsont *: zipArraySmallJsonSmallArrayG, \
3627  char **: zipArrayCharSmallArrayG, \
3628  const char **: zipArrayCCharSmallArrayG \
3629  ), \
3630  const char **: _Generic(values, \
3631  smallArrayt *: zipCArraySmallArrayG, \
3632  smallJsont *: zipCArraySmallJsonSmallArrayG, \
3633  char **: zipCArrayCharSmallArrayG, \
3634  const char **: zipCArrayCCharSmallArrayG \
3635  ) \
3636  ) \
3637  )(self, keys, values)
3638 
3639 #define walkDirG(returnType, path) _Generic((returnType), \
3640  char **: walkDir, \
3641  smallArrayt *: _Generic(path, \
3642  char *: walkDirO, \
3643  const char *: walkDirO, \
3644  smallJsont *: walkDirSmallJsonO, \
3645  smallStringt *: walkDirSmallStringO \
3646  ) \
3647  )(path)
3648 
3649 #define walkDirDirG(returnType, path) _Generic((returnType), \
3650  char **: walkDirDir, \
3651  smallArrayt *: _Generic(path, \
3652  char *: walkDirDirO, \
3653  const char *: walkDirDirO, \
3654  smallJsont *: walkDirDirSmallJsonO, \
3655  smallStringt *: walkDirDirSmallStringO \
3656  )\
3657  )(path)
3658 
3659 #define readDirG(returnType, path) _Generic((returnType), \
3660  char **: readDir, \
3661  smallArrayt *: _Generic(path, \
3662  char *: readDirO, \
3663  const char *: readDirO, \
3664  smallJsont *: readDirSmallJsonO, \
3665  smallStringt *: readDirSmallStringO \
3666  )\
3667  )(path)
3668 
3669 #define readDirDirG(returnType, path) _Generic((returnType), \
3670  char **: readDirDir, \
3671  smallArrayt *: _Generic(path, \
3672  char *: readDirDirO, \
3673  const char *: readDirDirO, \
3674  smallJsont *: readDirDirSmallJsonO, \
3675  smallStringt *: readDirDirSmallStringO \
3676  )\
3677  )(path)
3678 
3679 #define walkDirAllG(returnType, path) _Generic((returnType), \
3680  char **: walkDirAll, \
3681  smallArrayt *: _Generic(path, \
3682  char *: walkDirAllO, \
3683  const char *: walkDirAllO, \
3684  smallJsont *: walkDirAllSmallJsonO, \
3685  smallStringt *: walkDirAllSmallStringO \
3686  ) \
3687  )(path)
3688 
3689 #define readDirAllG(returnType, path) _Generic((returnType), \
3690  char **: readDirAll, \
3691  smallArrayt *: _Generic(path, \
3692  char *: readDirAllO, \
3693  const char *: readDirAllO, \
3694  smallJsont *: readDirAllSmallJsonO, \
3695  smallStringt *: readDirAllSmallStringO \
3696  )\
3697  )(path)
3698 
3699 #define mkdirParentsG(path) _Generic((path), \
3700  char *: mkdirParents, \
3701  const char *: mkdirParents, \
3702  smallJsont *: mkdirParentsSmallJsonO, \
3703  smallStringt *: mkdirParentsO \
3704  )(path)
3705 
3706 #define rmAllG(path) _Generic((path), \
3707  char *: rmAll, \
3708  const char *: rmAll, \
3709  smallJsont *: rmAllSmallJsonO, \
3710  smallStringt *: rmAllO \
3711  )(path)
3712 
3713 #define copyG(path1, path2) _Generic((path1), \
3714  char *: _Generic((path2), \
3715  char *: copy, \
3716  const char *: copy, \
3717  smallJsont *: copySSmallJsonO, \
3718  smallStringt *: copySO), \
3719  const char *: _Generic((path2), \
3720  char *: copy, \
3721  const char *: copy, \
3722  smallJsont *: copySSmallJsonO, \
3723  smallStringt *: copySO), \
3724  smallJsont *: _Generic((path2), \
3725  char *: copySmallJsonOS, \
3726  const char*: copySmallJsonOS, \
3727  smallJsont *: copySmallJsonSmallJson, \
3728  smallStringt *: copySmallJsonO), \
3729  smallStringt *: _Generic((path2), \
3730  char *: copyOS, \
3731  const char*: copyOS, \
3732  smallJsont *: copyOSmallJson, \
3733  smallStringt *: copyO) \
3734  )(path1, path2)
3735 
3736 #define randomSG(returnType, length) _Generic((returnType), \
3737  char *: randomS, \
3738  smallJsont *: randomSmallJsonO, \
3739  smallStringt *: randomSO \
3740  )(length)
3741 
3742 #define randomAlphaNumSG(returnType, length) _Generic((returnType), \
3743  char *: randomAlphaNumS, \
3744  smallJsont *: randomAlphaNumSmallJsonO, \
3745  smallStringt *: randomAlphaNumSO \
3746  )(length)
3747 
3748 #define readG(returnType) _Generic((returnType), \
3749  char *: readS, \
3750  smallJsont *: readSmallJsonO, \
3751  smallStringt *: readO \
3752  )()
3753 
3754 #define readLineG(returnType, fp) _Generic((returnType), \
3755  char *: readLine, \
3756  smallJsont *: readLineSmallJsonO, \
3757  smallStringt *: readLineO \
3758  )(fp)
3759 
3760 #define dupG(self) _Generic((self), \
3761  smallArrayt*: duplicateSmallArrayG, \
3762  smallBoolt*: duplicateSmallBoolG, \
3763  smallBytest*: duplicateSmallBytesG, \
3764  smallContainert*: duplicateSmallContainerG, \
3765  smallDictt*: duplicateSmallDictG, \
3766  smallDoublet*: duplicateSmallDoubleG, \
3767  smallIntt*: duplicateSmallIntG, \
3768  smallJsont*: duplicateSmallJsonG, \
3769  smallStringt*: duplicateSmallStringG, \
3770  undefinedt*: duplicateUndefinedG, \
3771  baset*: duplicateBaseG, \
3772  char *: dupS,\
3773  const char *: dupS,\
3774  char **: listDupS, \
3775  const char **: listDupCG, \
3776  btt: dupB, \
3777  btt*: dupPB \
3778  )(self)
3779 
3780 #define replaceO(self, olds, news, max) (self)->f->replace(self, olds, news, max)
3781 #define replaceG(self, olds, news, max) _Generic((self), \
3782  char *: _Generic(olds, \
3783  char *: _Generic(news, \
3784  char *: replaceS, \
3785  const char *: replaceS, \
3786  char: replaceSCharS, \
3787  int: replaceSCharS, \
3788  default: replaceS \
3789  ) , \
3790  const char *: _Generic(news, \
3791  char *: replaceS, \
3792  const char *: replaceS, \
3793  char: replaceSCharS, \
3794  int: replaceSCharS, \
3795  default: replaceS \
3796  ), \
3797  char: _Generic(news, \
3798  char *: replaceCharSS, \
3799  const char *: replaceCharSS, \
3800  char: replaceCharCharS, \
3801  int: replaceCharCharS, \
3802  default: replaceCharSS \
3803  ), \
3804  int: _Generic(news, \
3805  char *: replaceCharSS, \
3806  const char *: replaceCharSS, \
3807  char: replaceCharCharS, \
3808  int: replaceCharCharS, \
3809  default: replaceCharSS \
3810  ), \
3811  default: replaceS \
3812  ), \
3813  char **: _Generic(olds, \
3814  char *: _Generic(news, \
3815  char *: iReplaceS, \
3816  const char *: iReplaceS, \
3817  char: iReplaceSCharS, \
3818  int: iReplaceSCharS, \
3819  default: iReplaceS \
3820  ) , \
3821  const char *: _Generic(news, \
3822  char *: iReplaceS, \
3823  const char *: iReplaceS, \
3824  char: iReplaceSCharS, \
3825  int: iReplaceSCharS, \
3826  default: iReplaceS \
3827  ), \
3828  char: _Generic(news, \
3829  char *: iReplaceCharSS, \
3830  const char *: iReplaceCharSS, \
3831  char: iReplaceCharCharS, \
3832  int: iReplaceCharCharS, \
3833  default: iReplaceCharSS \
3834  ) , \
3835  int: _Generic(news, \
3836  char *: iReplaceCharSS, \
3837  const char *: iReplaceCharSS, \
3838  char: iReplaceCharCharS, \
3839  int: iReplaceCharCharS, \
3840  default: iReplaceCharSS \
3841  ), \
3842  default: iReplaceS \
3843  ), \
3844  smallJsont *: _Generic(olds, \
3845  char *: _Generic(news, \
3846  char *: replaceSmallJsonG,\
3847  const char *: replaceSmallJsonG,\
3848  char: replaceSCharSmallJsonG,\
3849  int: replaceSCharSmallJsonG,\
3850  smallJsont *: replaceSJsonSmallJsonG, \
3851  smallStringt *: replaceSSmallStringSmallJsonG \
3852  ), \
3853  const char *: _Generic(news, \
3854  char *: replaceSmallJsonG,\
3855  const char *: replaceSmallJsonG,\
3856  char: replaceSCharSmallJsonG,\
3857  int: replaceSCharSmallJsonG,\
3858  smallJsont *: replaceSJsonSmallJsonG, \
3859  smallStringt *: replaceSSmallStringSmallJsonG \
3860  ), \
3861  char: _Generic(news, \
3862  char *: replaceCharSSmallJsonG, \
3863  const char *: replaceCharSSmallJsonG, \
3864  char: replaceCharCharSmallJsonG, \
3865  int: replaceCharCharSmallJsonG, \
3866  smallJsont *: replaceCharJsonSmallJsonG, \
3867  smallStringt *: replaceCharSmallStringSmallJsonG \
3868  ), \
3869  int: _Generic(news, \
3870  char *: replaceCharSSmallJsonG, \
3871  const char *: replaceCharSSmallJsonG, \
3872  char: replaceCharCharSmallJsonG, \
3873  int: replaceCharCharSmallJsonG, \
3874  smallJsont *: replaceCharJsonSmallJsonG, \
3875  smallStringt *: replaceCharSmallStringSmallJsonG \
3876  ), \
3877  smallJsont *: _Generic(news, \
3878  char *: replaceJsonSSmallJsonG, \
3879  const char *: replaceJsonSSmallJsonG, \
3880  char: replaceJsonCharSmallJsonG, \
3881  int: replaceJsonCharSmallJsonG, \
3882  smallJsont *: replaceJsonJsonSmallJsonG, \
3883  smallStringt *: replaceJsonSmallStringSmallJsonG \
3884  ), \
3885  smallStringt *: _Generic(news, \
3886  char *: replaceSmallStringSSmallJsonG, \
3887  const char *: replaceSmallStringSSmallJsonG, \
3888  char: replaceSmallStringCharSmallJsonG, \
3889  int: replaceSmallStringCharSmallJsonG, \
3890  smallJsont *: replaceSmallStringJsonSmallJsonG, \
3891  smallStringt *: replaceSmallStringSmallStringSmallJsonG \
3892  ) \
3893  ), \
3894  smallStringt *: _Generic(olds, \
3895  char *: _Generic(news, \
3896  char *: replaceSmallStringG,\
3897  const char *: replaceSmallStringG,\
3898  char: replaceSCharSmallStringG,\
3899  int: replaceSCharSmallStringG,\
3900  smallJsont *: replaceSSmallJsonSmallStringG, \
3901  smallStringt *: replaceSSmallStringSmallStringG \
3902  ), \
3903  const char *: _Generic(news, \
3904  char *: replaceSmallStringG,\
3905  const char *: replaceSmallStringG,\
3906  char: replaceSCharSmallStringG,\
3907  int: replaceSCharSmallStringG,\
3908  smallJsont *: replaceSSmallJsonSmallStringG, \
3909  smallStringt *: replaceSSmallStringSmallStringG \
3910  ), \
3911  char: _Generic(news, \
3912  char *: replaceCharSSmallStringG, \
3913  const char *: replaceCharSSmallStringG, \
3914  char: replaceCharCharSmallStringG, \
3915  int: replaceCharCharSmallStringG, \
3916  smallJsont *: replaceCharSmallJsonSmallStringG, \
3917  smallStringt *: replaceCharSmallStringSmallStringG \
3918  ), \
3919  int: _Generic(news, \
3920  char *: replaceCharSSmallStringG, \
3921  const char *: replaceCharSSmallStringG, \
3922  char: replaceCharCharSmallStringG, \
3923  int: replaceCharCharSmallStringG, \
3924  smallJsont *: replaceCharSmallJsonSmallStringG, \
3925  smallStringt *: replaceCharSmallStringSmallStringG \
3926  ), \
3927  smallJsont *: _Generic(news, \
3928  char *: replaceSmallJsonSSmallStringG, \
3929  const char *: replaceSmallJsonSSmallStringG, \
3930  char: replaceSmallJsonCharSmallStringG, \
3931  int: replaceSmallJsonCharSmallStringG, \
3932  smallJsont *: replaceSmallJsonSmallJsonSmallStringG, \
3933  smallStringt *: replaceSmallJsonSmallStringSmallStringG \
3934  ), \
3935  smallStringt *: _Generic(news, \
3936  char *: replaceSmallStringSSmallStringG, \
3937  const char *: replaceSmallStringSSmallStringG, \
3938  char: replaceSmallStringCharSmallStringG, \
3939  int: replaceSmallStringCharSmallStringG, \
3940  smallJsont *: replaceSmallStringSmallJsonSmallStringG, \
3941  smallStringt *: replaceSmallStringSmallStringSmallStringG \
3942  ) \
3943  ) \
3944  )(self, olds, news, max)
3945 
3946 #define icReplaceO(self, olds, news, max) (self)->f->icReplace(self, olds, news, max)
3947 #define icReplaceG(self, olds, news, max) _Generic((self), \
3948  char *: _Generic(olds, \
3949  char *: _Generic(news, \
3950  char *: icReplaceS, \
3951  const char *: icReplaceS, \
3952  char: icReplaceSCharS, \
3953  int: icReplaceSCharS, \
3954  default: icReplaceS \
3955  ) , \
3956  const char *: _Generic(news, \
3957  char *: icReplaceS, \
3958  const char *: icReplaceS, \
3959  char: icReplaceSCharS, \
3960  int: icReplaceSCharS, \
3961  default: icReplaceS \
3962  ), \
3963  char: _Generic(news, \
3964  char *: icReplaceCharSS, \
3965  const char *: icReplaceCharSS, \
3966  char: icReplaceCharCharS, \
3967  int: icReplaceCharCharS, \
3968  default: icReplaceCharSS \
3969  ), \
3970  int: _Generic(news, \
3971  char *: icReplaceCharSS, \
3972  const char *: icReplaceCharSS, \
3973  char: icReplaceCharCharS, \
3974  int: icReplaceCharCharS, \
3975  default: icReplaceCharSS \
3976  ), \
3977  default: icReplaceS \
3978  ), \
3979  char **: _Generic(olds, \
3980  char *: _Generic(news, \
3981  char *: iicReplaceS, \
3982  const char *: iicReplaceS, \
3983  char: iicReplaceSCharS, \
3984  int: iicReplaceSCharS, \
3985  default: iicReplaceS \
3986  ) , \
3987  const char *: _Generic(news, \
3988  char *: iicReplaceS, \
3989  const char *: iicReplaceS, \
3990  char: iicReplaceSCharS, \
3991  int: iicReplaceSCharS, \
3992  default: iicReplaceS \
3993  ), \
3994  char: _Generic(news, \
3995  char *: iicReplaceCharSS, \
3996  const char *: iicReplaceCharSS, \
3997  char: iicReplaceCharCharS, \
3998  int: iicReplaceCharCharS, \
3999  default: iicReplaceCharSS \
4000  ) , \
4001  int: _Generic(news, \
4002  char *: iicReplaceCharSS, \
4003  const char *: iicReplaceCharSS, \
4004  char: iicReplaceCharCharS, \
4005  int: iicReplaceCharCharS, \
4006  default: iicReplaceCharSS \
4007  ), \
4008  default: iicReplaceS \
4009  ), \
4010  smallJsont *: _Generic(olds, \
4011  char *: _Generic(news, \
4012  char *: icReplaceSmallJsonG,\
4013  const char *: icReplaceSmallJsonG,\
4014  char: icReplaceSCharSmallJsonG,\
4015  int: icReplaceSCharSmallJsonG,\
4016  smallJsont *: icReplaceSJsonSmallJsonG, \
4017  smallStringt *: icReplaceSSmallStringSmallJsonG, \
4018  default: icReplaceSmallJsonG \
4019  ), \
4020  const char *: _Generic(news, \
4021  char *: icReplaceSmallJsonG,\
4022  const char *: icReplaceSmallJsonG,\
4023  char: icReplaceSCharSmallJsonG,\
4024  int: icReplaceSCharSmallJsonG,\
4025  smallJsont *: icReplaceSJsonSmallJsonG, \
4026  smallStringt *: icReplaceSSmallStringSmallJsonG, \
4027  default: icReplaceSmallJsonG \
4028  ), \
4029  char: _Generic(news, \
4030  char *: icReplaceCharSSmallJsonG, \
4031  const char *: icReplaceCharSSmallJsonG, \
4032  char: icReplaceCharCharSmallJsonG, \
4033  int: icReplaceCharCharSmallJsonG, \
4034  smallJsont *: icReplaceCharJsonSmallJsonG, \
4035  smallStringt *: icReplaceCharSmallStringSmallJsonG, \
4036  default: icReplaceCharSSmallJsonG \
4037  ), \
4038  int: _Generic(news, \
4039  char *: icReplaceCharSSmallJsonG, \
4040  const char *: icReplaceCharSSmallJsonG, \
4041  char: icReplaceCharCharSmallJsonG, \
4042  int: icReplaceCharCharSmallJsonG, \
4043  smallJsont *: icReplaceCharJsonSmallJsonG, \
4044  smallStringt *: icReplaceCharSmallStringSmallJsonG, \
4045  default: icReplaceCharSSmallJsonG \
4046  ), \
4047  smallJsont *: _Generic(news, \
4048  char *: icReplaceJsonSSmallJsonG, \
4049  const char *: icReplaceJsonSSmallJsonG, \
4050  char: icReplaceJsonCharSmallJsonG, \
4051  smallJsont *: icReplaceJsonJsonSmallJsonG, \
4052  smallStringt *: icReplaceJsonSmallStringSmallJsonG, \
4053  default: icReplaceCharSSmallJsonG \
4054  ), \
4055  smallStringt *: _Generic(news, \
4056  char *: icReplaceSmallStringSSmallJsonG, \
4057  const char *: icReplaceSmallStringSSmallJsonG, \
4058  char: icReplaceSmallStringCharSmallJsonG, \
4059  smallJsont *: icReplaceSmallStringJsonSmallJsonG, \
4060  smallStringt *: icReplaceSmallStringSmallStringSmallJsonG, \
4061  default: icReplaceSmallStringSSmallJsonG \
4062  ) \
4063  ), \
4064  smallStringt *: _Generic(olds, \
4065  char *: _Generic(news, \
4066  char *: icReplaceSmallStringG,\
4067  const char *: icReplaceSmallStringG,\
4068  char: icReplaceSCharSmallStringG,\
4069  int: icReplaceSCharSmallStringG,\
4070  smallJsont *: icReplaceSSmallJsonSmallStringG, \
4071  smallStringt *: icReplaceSSmallStringSmallStringG, \
4072  default: icReplaceSmallStringG \
4073  ), \
4074  const char *: _Generic(news, \
4075  char *: icReplaceSmallStringG,\
4076  const char *: icReplaceSmallStringG,\
4077  char: icReplaceSCharSmallStringG,\
4078  int: icReplaceSCharSmallStringG,\
4079  smallJsont *: icReplaceSSmallJsonSmallStringG, \
4080  smallStringt *: icReplaceSSmallStringSmallStringG, \
4081  default: icReplaceSmallStringG \
4082  ), \
4083  char: _Generic(news, \
4084  char *: icReplaceCharSSmallStringG, \
4085  const char *: icReplaceCharSSmallStringG, \
4086  char: icReplaceCharCharSmallStringG, \
4087  int: icReplaceCharCharSmallStringG, \
4088  smallJsont *: icReplaceCharSmallJsonSmallStringG, \
4089  smallStringt *: icReplaceCharSmallStringSmallStringG, \
4090  default: icReplaceCharSSmallStringG \
4091  ), \
4092  int: _Generic(news, \
4093  char *: icReplaceCharSSmallStringG, \
4094  const char *: icReplaceCharSSmallStringG, \
4095  char: icReplaceCharCharSmallStringG, \
4096  int: icReplaceCharCharSmallStringG, \
4097  smallJsont *: icReplaceCharSmallJsonSmallStringG, \
4098  smallStringt *: icReplaceCharSmallStringSmallStringG, \
4099  default: icReplaceCharSSmallStringG \
4100  ), \
4101  smallJsont *: _Generic(news, \
4102  char *: icReplaceSmallJsonSSmallStringG, \
4103  const char *: icReplaceSmallJsonSSmallStringG, \
4104  char: icReplaceSmallJsonCharSmallStringG, \
4105  smallJsont *: icReplaceSmallJsonSmallJsonSmallStringG, \
4106  smallStringt *: icReplaceSmallJsonSmallStringSmallStringG, \
4107  default: icReplaceSmallJsonSSmallStringG \
4108  ), \
4109  smallStringt *: _Generic(news, \
4110  char *: icReplaceSmallStringSSmallStringG, \
4111  const char *: icReplaceSmallStringSSmallStringG, \
4112  char: icReplaceSmallStringCharSmallStringG, \
4113  smallJsont *: icReplaceSmallStringSmallJsonSmallStringG, \
4114  smallStringt *: icReplaceSmallStringSmallStringSmallStringG, \
4115  default: icReplaceSmallStringSSmallStringG \
4116  ) \
4117  ) \
4118  )(self, olds, news, max)
4119 
4123 #define isLSheepyObject(self) _Generic((self), default: 0,\
4124  baset *: 1,\
4125  smallArrayt*: 1,\
4126  smallBoolt*: 1,\
4127  smallBytest*: 1,\
4128  smallDictt *: 1,\
4129  smallDoublet *: 1,\
4130  smallIntt *: 1,\
4131  smallJsont *: 1,\
4132  smallStringt *: 1,\
4133  smallContainert *: 1,\
4134  undefinedt *: 1\
4135  )
4136 
4141 #define eqG(self, obj) FUNC(\
4142  bool UNIQVAR(r);\
4143  /* if self is NULL and sheepy object, return false */\
4144  if (isLSheepyObject(self) and !(self)) UNIQVAR(r) = false;\
4145  else UNIQVAR(r) = eqDirectG(self, obj);\
4146  /*return*/UNIQVAR(r);\
4147  )
4148 
4153 #define eqDirectG(self, obj) _Generic((self), \
4154  char: _Generic(obj, \
4155  char *: eqCharS, \
4156  const char *: eqCharS, \
4157  char: eqCharChar, \
4158  baset*: equalChaOG, \
4159  bool: equalChaBoolG, \
4160  double: equalChaDoubleG, \
4161  int64_t: equalChaInt64G, \
4162  int32_t: equalChaInt32G, \
4163  uint32_t: equalChaUint32G, \
4164  uint64_t: equalChaUint64G, \
4165  smallBytest*: equalChaSmallBytesG, \
4166  smallDoublet*: equalChaSmallDoubleG, \
4167  smallIntt*: equalChaSmallIntG, \
4168  smallJsont*: equalChaSmallJsonG, \
4169  smallStringt*: equalChaSmallStringG, \
4170  default: notEqualCharG \
4171  ) , \
4172  char *: _Generic((obj), \
4173  char *: eqS, \
4174  const char *: eqS, \
4175  char: eqSChar, \
4176  baset*: equalCharOG, \
4177  bool: equalCharBoolG, \
4178  double: equalCharDoubleG, \
4179  int64_t: equalCharInt64G, \
4180  int32_t: equalCharInt32G, \
4181  uint32_t: equalCharUint32G, \
4182  uint64_t: equalCharUint64G, \
4183  smallBoolt*: equalCharSmallBoolG, \
4184  smallBytest*: equalCharSmallBytesG, \
4185  smallDoublet*: equalCharSmallDoubleG, \
4186  smallIntt*: equalCharSmallIntG, \
4187  smallJsont*: equalCharPSmallJsonG, \
4188  smallStringt*: equalCharPSmallStringG, \
4189  default: notEqualOG), \
4190  const char *: _Generic((obj), \
4191  char *: eqS, \
4192  const char *: eqS, \
4193  char: eqSChar, \
4194  baset*: equalCharOG, \
4195  bool: equalCharBoolG, \
4196  double: equalCharDoubleG, \
4197  int64_t: equalCharInt64G, \
4198  int32_t: equalCharInt32G, \
4199  uint32_t: equalCharUint32G, \
4200  uint64_t: equalCharUint64G, \
4201  smallBoolt*: equalCharSmallBoolG, \
4202  smallBytest*: equalCharSmallBytesG, \
4203  smallDoublet*: equalCharSmallDoubleG, \
4204  smallIntt*: equalCharSmallIntG, \
4205  smallJsont*: equalCharPSmallJsonG, \
4206  smallStringt*: equalCharPSmallStringG, \
4207  default: notEqualCCOG), \
4208  char **: _Generic((obj) , \
4209  char: notEqualOCharG, \
4210  char **: listEqS, \
4211  const char **: listEqCG, \
4212  baset*: equalArrayOG, \
4213  bool: notEqualOBoolG, \
4214  double: notEqualDoubleG, \
4215  int64_t: notEqualOInt64G, \
4216  int32_t: notEqualOInt32G, \
4217  uint32_t: notEqualOUint32G, \
4218  uint64_t: notEqualOUint64G, \
4219  smallJsont*: equalArraySmallJsonG, \
4220  smallArrayt*: equalArraySmallArrayG, \
4221  default: notEqualOG), \
4222  const char **: _Generic((obj) , \
4223  char: notEqualOCharG, \
4224  char **: listEqC1G, \
4225  const char **: listEqCCG, \
4226  baset*: equalCArrayOG, \
4227  bool: notEqualOBoolG, \
4228  double: notEqualDoubleG, \
4229  int64_t: notEqualOInt64G, \
4230  int32_t: notEqualOInt32G, \
4231  uint32_t: notEqualOUint32G, \
4232  uint64_t: notEqualOUint64G, \
4233  smallJsont*: equalCArraySmallJsonG, \
4234  smallArrayt*: equalCArraySmallArrayG, \
4235  default: notEqualOG), \
4236  baset*: _Generic((obj), \
4237  char: equalOChaG, \
4238  char *: equalOCharG, \
4239  const char *: equalOCharG, \
4240  char **: equalOArrayG, \
4241  const char **: equalOCArrayG, \
4242  baset*: equalOOG, \
4243  bool: equalOBoolG, \
4244  double: equalODoubleG, \
4245  int64_t: equalOInt64G, \
4246  int32_t: equalOInt32G, \
4247  uint32_t: equalOUint32G, \
4248  uint64_t: equalOUint64G, \
4249  smallArrayt*: equalOSmallArrayG, \
4250  smallBoolt*: equalOSmallBoolG, \
4251  smallBytest*: equalOSmallBytesG, \
4252  smallDoublet*: equalOSmallDoubleG, \
4253  smallDictt*: equalOSmallDictG, \
4254  smallIntt*: equalOSmallIntG, \
4255  smallJsont*: equalOSmallJsonG, \
4256  smallStringt*: equalOSmallStringG, \
4257  default: notEqualOG), \
4258  bool: _Generic((obj), \
4259  char: equalBoolChaG, \
4260  char *: equalBoolCharG, \
4261  const char *: equalBoolCharG, \
4262  baset*: equalBoolOG, \
4263  bool: equalBoolFG, \
4264  double: equalBoolDoubleG, \
4265  int64_t: equalBoolInt64G, \
4266  int32_t: equalBoolInt32G, \
4267  uint32_t: equalBoolUint32G, \
4268  uint64_t: equalBoolUint64G, \
4269  smallBoolt*: equalBoolSmallBoolG, \
4270  smallBytest*: equalBoolSmallBytesG, \
4271  smallDoublet*: equalBoolSmallDoubleG, \
4272  smallIntt*: equalBoolSmallIntG, \
4273  smallJsont*: equalBoolSmallJsonG, \
4274  smallStringt*: equalBoolSmallStringG, \
4275  default: notEqualBoolOG), \
4276  double: _Generic((obj), \
4277  char: equalDoubleChaG, \
4278  char *: equalDoubleCharG, \
4279  const char *: equalDoubleCharG, \
4280  baset*: equalDoubleBaseG, \
4281  bool: equalDoubleBoolG, \
4282  double: equalDoubleFG, \
4283  int64_t: equalDoubleInt64G, \
4284  int32_t: equalDoubleInt32G, \
4285  uint32_t: equalDoubleUint32G, \
4286  uint64_t: equalDoubleUint64G, \
4287  smallBoolt*: equalDoubleSmallBoolG, \
4288  smallBytest*: equalDoubleSmallBytesG, \
4289  smallDoublet*: equalDoubleSmallDoubleG, \
4290  smallIntt*: equalDoubleSmallIntG, \
4291  smallJsont*: equalDoubleSmallJsonG, \
4292  smallStringt*: equalDoubleSmallStringG, \
4293  default: notEqualDoubleOG), \
4294  int64_t: _Generic((obj), \
4295  char: equalInt64ChaG, \
4296  char *: equalInt64CharG, \
4297  const char *: equalInt64CharG, \
4298  baset*: equalInt64BaseG, \
4299  bool: equalInt64BoolG, \
4300  double: equalInt64DoubleG, \
4301  int64_t: equalInt64FG, \
4302  int32_t: equalInt64Int32G, \
4303  uint32_t: equalInt64Uint32G, \
4304  uint64_t: equalInt64Uint64G, \
4305  smallBoolt*: equalInt64SmallBoolG, \
4306  smallBytest*: equalInt64SmallBytesG, \
4307  smallDoublet*: equalInt64SmallDoubleG, \
4308  smallIntt*: equalInt64SmallIntG, \
4309  smallJsont*: equalInt64SmallJsonG, \
4310  smallStringt*: equalInt64SmallStringG, \
4311  default: notEqualInt64OG), \
4312  int32_t: _Generic((obj), \
4313  char: equalInt32ChaG, \
4314  char *: equalInt32CharG, \
4315  const char *: equalInt32CharG, \
4316  baset*: equalInt32BaseG, \
4317  bool: equalInt32BoolG, \
4318  double: equalInt32DoubleG, \
4319  int64_t: equalInt32Int64G, \
4320  int32_t: equalInt32FG, \
4321  uint32_t: equalInt32Uint32G, \
4322  uint64_t: equalInt32Uint64G, \
4323  smallBoolt*: equalInt32SmallBoolG, \
4324  smallBytest*: equalInt32SmallBytesG, \
4325  smallDoublet*: equalInt32SmallDoubleG, \
4326  smallIntt*: equalInt32SmallIntG, \
4327  smallJsont*: equalInt32SmallJsonG, \
4328  smallStringt*: equalInt32SmallStringG, \
4329  default: notEqualInt32OG), \
4330  uint32_t: _Generic((obj), \
4331  char: equalUint32ChaG, \
4332  char *: equalUint32CharG, \
4333  const char *: equalUint32CharG, \
4334  baset*: equalUint32BaseG, \
4335  bool: equalUint32BoolG, \
4336  double: equalUint32DoubleG, \
4337  int64_t: equalUint32Int64G, \
4338  int32_t: equalUint32Int32G, \
4339  uint32_t: equalUint32FG, \
4340  uint64_t: equalUint32Uint64G, \
4341  smallBoolt*: equalUint32SmallBoolG, \
4342  smallBytest*: equalUint32SmallBytesG, \
4343  smallDoublet*: equalUint32SmallDoubleG, \
4344  smallIntt*: equalUint32SmallIntG, \
4345  smallJsont*: equalUint32SmallJsonG, \
4346  smallStringt*: equalUint32SmallStringG, \
4347  default: notEqualUint32OG), \
4348  uint64_t: _Generic((obj), \
4349  char: equalUint64ChaG, \
4350  char *: equalUint64CharG, \
4351  const char *: equalUint64CharG, \
4352  baset*: equalUint64BaseG, \
4353  bool: equalUint64BoolG, \
4354  double: equalUint64DoubleG, \
4355  int64_t: equalUint64Int64G, \
4356  int32_t: equalUint64Int32G, \
4357  uint32_t: equalUint64Uint32G, \
4358  uint64_t: equalUint64FG, \
4359  smallBoolt*: equalUint64SmallBoolG, \
4360  smallBytest*: equalUint64SmallBytesG, \
4361  smallDoublet*: equalUint64SmallDoubleG, \
4362  smallIntt*: equalUint64SmallIntG, \
4363  smallJsont*: equalUint64SmallJsonG, \
4364  smallStringt*: equalUint64SmallStringG, \
4365  default: notEqualUint64OG), \
4366  smallArrayt*: _Generic((obj), \
4367  char: notEqualOCharG, \
4368  char **: equalSmallArrayArrayG, \
4369  const char **: equalSmallArrayCArrayG, \
4370  baset*: equalSmallArrayBaseG, \
4371  bool: notEqualOBoolG, \
4372  double: notEqualDoubleG, \
4373  int64_t: notEqualOInt64G, \
4374  int32_t: notEqualOInt32G, \
4375  uint32_t: notEqualOUint32G, \
4376  uint64_t: notEqualOUint32G, \
4377  smallJsont*: equalSmallArraySmallJsonG, \
4378  smallArrayt*: equalSmallArrayG, \
4379  default: notEqualOG), \
4380  smallBoolt*: _Generic((obj), \
4381  char: notEqualOCharG, \
4382  char *: equalSmallBoolCharG, \
4383  const char *: equalSmallBoolCharG, \
4384  baset*: equalSmallBoolBaseG, \
4385  bool: equalSmallBoolBoolG, \
4386  double: equalSmallBoolDoubleG, \
4387  int64_t: equalSmallBoolInt64G, \
4388  int32_t: equalSmallBoolInt32G, \
4389  uint32_t: equalSmallBoolUint32G, \
4390  uint64_t: equalSmallBoolUint64G, \
4391  smallBoolt*: equalSmallBoolFG, \
4392  smallBytest*: equalSmallBoolSmallBytesG, \
4393  smallDoublet*: equalSmallBoolSmallDoubleG, \
4394  smallIntt*: equalSmallBoolSmallIntG, \
4395  smallJsont*: equalSmallBoolSmallJsonG, \
4396  smallStringt*: equalSmallBoolSmallStringG, \
4397  default: notEqualOG), \
4398  smallBytest*: _Generic((obj), \
4399  char: notEqualOCharG, \
4400  char *: equalSmallBytesCharG, \
4401  const char *: equalSmallBytesCharG, \
4402  baset*: equalSmallBytesBaseG, \
4403  bool: equalSmallBytesBoolG, \
4404  double: equalSmallBytesDoubleG, \
4405  int64_t: equalSmallBytesInt64G, \
4406  int32_t: equalSmallBytesInt32G, \
4407  uint32_t: equalSmallBytesUint32G, \
4408  uint64_t: equalSmallBytesUint64G, \
4409  smallBoolt*: equalSmallBytesSmallBoolG, \
4410  smallBytest*: equalSmallBytesG, \
4411  smallDoublet*: equalSmallBytesSmallDoubleG, \
4412  smallIntt*: equalSmallBytesSmallIntG, \
4413  smallStringt*: equalSmallBytesSmallStringG, \
4414  default: notEqualOG), \
4415  smallDoublet*: _Generic((obj), \
4416  char: equalSmallDoubleChaG, \
4417  char *: equalSmallDoubleCharG, \
4418  const char *: equalSmallDoubleCharG, \
4419  baset*: equalSmallDoubleBaseG, \
4420  bool: equalSmallDoubleBoolG, \
4421  double: equalSmallDoubleDoubleG, \
4422  int64_t: equalSmallDoubleInt64G, \
4423  int32_t: equalSmallDoubleInt32G, \
4424  uint32_t: equalSmallDoubleUint32G, \
4425  uint64_t: equalSmallDoubleUint64G, \
4426  smallBoolt*: equalSmallDoubleSmallBoolG, \
4427  smallBytest*: equalSmallDoubleSmallBytesG, \
4428  smallDoublet*: equalSmallDoubleFG, \
4429  smallIntt*: equalSmallDoubleSmallIntG, \
4430  smallJsont*: equalSmallDoubleSmallJsonG, \
4431  smallStringt*: equalSmallDoubleSmallStringG, \
4432  default: notEqualOG), \
4433  smallDictt*: _Generic((obj), \
4434  char: notEqualOCharG, \
4435  baset*: equalSmallDictBaseG, \
4436  bool: notEqualOBoolG, \
4437  double: notEqualDoubleG, \
4438  int64_t: notEqualOInt64G, \
4439  int32_t: notEqualOInt32G, \
4440  uint32_t: notEqualOUint32G, \
4441  uint64_t: notEqualOUint64G, \
4442  smallJsont*: equalSmallDictSmallJsonG, \
4443  smallDictt*: equalSmallDictG, \
4444  default: notEqualOG), \
4445  smallIntt*: _Generic((obj), \
4446  char: equalSmallIntChaG, \
4447  char *: equalSmallIntCharG, \
4448  const char *: equalSmallIntCharG, \
4449  baset*: equalSmallIntBaseG, \
4450  bool: equalSmallIntBoolG, \
4451  double: equalSmallIntDoubleG, \
4452  int64_t: equalSmallIntInt64G, \
4453  int32_t: equalSmallIntInt32G, \
4454  uint32_t: equalSmallIntUint32G, \
4455  uint64_t: equalSmallIntUint64G, \
4456  smallBoolt*: equalSmallIntSmallBoolG, \
4457  smallBytest*: equalSmallIntSmallBytesG, \
4458  smallDoublet*: equalSmallIntSmallDoubleG, \
4459  smallIntt*: equalSmallIntFG, \
4460  smallJsont*: equalSmallIntSmallJsonG, \
4461  smallStringt*: equalSmallIntSmallStringG, \
4462  default: notEqualOG), \
4463  smallJsont*: _Generic((obj), \
4464  char: equalSmallJsonChaG, \
4465  char *: equalSmallJsonCharG, \
4466  const char *: equalSmallJsonCharG, \
4467  char **: equalSmallJsonArrayG, \
4468  const char **: equalSmallJsonCArrayG, \
4469  baset*: equalSmallJsonBaseG, \
4470  bool: equalSmallJsonBoolG, \
4471  double: equalSmallJsonDoubleG, \
4472  int64_t: equalSmallJsonInt64G, \
4473  int32_t: equalSmallJsonInt32G, \
4474  uint32_t: equalSmallJsonUint32G, \
4475  uint64_t: equalSmallJsonUint64G, \
4476  smallArrayt*: equalSmallJsonSmallArrayG, \
4477  smallBoolt*: equalSmallJsonSmallBoolG, \
4478  smallBytest*: equalSmallJsonSmallBytesG, \
4479  smallDictt*: equalSmallJsonSmallDictG, \
4480  smallDoublet*: equalSmallJsonSmallDoubleG, \
4481  smallIntt*: equalSmallJsonSmallIntG, \
4482  smallJsont*: equalSmallJsonSmallJsonG, \
4483  smallStringt*: equalSmallJsonSmallStringG, \
4484  default: notEqualOG), \
4485  smallStringt*: _Generic((obj), \
4486  char *: equalSSmallStringG, \
4487  const char *: equalSSmallStringG, \
4488  char: equalCharSmallStringG, \
4489  baset*: equalSmallStringBaseG, \
4490  bool: equalSmallStringBoolG, \
4491  double: equalSmallStringDoubleG, \
4492  int64_t: equalSmallStringInt64G, \
4493  int32_t: equalSmallStringInt32G, \
4494  uint32_t: equalSmallStringUint32G, \
4495  uint64_t: equalSmallStringUint64G, \
4496  smallBoolt*: equalSmallStringSmallBoolG, \
4497  smallBytest*: equalSmallStringSmallBytesG, \
4498  smallDoublet*: equalSmallStringSmallDoubleG, \
4499  smallIntt*: equalSmallStringSmallIntG, \
4500  smallJsont*: equalSmallStringSmallJsonG, \
4501  smallStringt*: equalSmallStringFG, \
4502  default: notEqualOG) \
4503  )(self, obj)
4504 
4509 #define icEqG(self, obj) FUNC(\
4510  bool UNIQVAR(r);\
4511  /* if self is NULL and sheepy object, return false */\
4512  if (isLSheepyObject(self) and !(self)) UNIQVAR(r) = false;\
4513  else UNIQVAR(r) = icEqDirectG(self, obj);\
4514  /*return*/UNIQVAR(r);\
4515  )
4516 
4521 #define icEqDirectG(self, obj) _Generic((self), \
4522  char: _Generic(obj, \
4523  char *: icEqCharS, \
4524  const char *: icEqCharS, \
4525  char: icEqCharChar, \
4526  baset*: icEqualChaOG, \
4527  bool: equalChaBoolG, \
4528  double: equalChaDoubleG, \
4529  int64_t: equalChaInt64G, \
4530  int32_t: equalChaInt32G, \
4531  uint32_t: equalChaUint32G, \
4532  uint64_t: equalChaUint64G, \
4533  smallDoublet*: equalChaSmallDoubleG, \
4534  smallIntt*: equalChaSmallIntG, \
4535  smallJsont*: icEqualChaSmallJsonG, \
4536  smallStringt*: icEqualChaSmallStringG, \
4537  default: notEqualCharG \
4538  ) , \
4539  char *: _Generic((obj), \
4540  char *: icEqS, \
4541  const char *: icEqS, \
4542  char: icEqSChar, \
4543  baset*: icEqualCharOG, \
4544  bool: equalCharBoolG, \
4545  double: equalCharDoubleG, \
4546  int64_t: equalCharInt64G, \
4547  int32_t: equalCharInt32G, \
4548  uint32_t: equalCharUint32G, \
4549  uint64_t: equalCharUint64G, \
4550  smallBoolt*: equalCharSmallBoolG, \
4551  smallBytest*: equalCharSmallBytesG, \
4552  smallDoublet*: equalCharSmallDoubleG, \
4553  smallIntt*: equalCharSmallIntG, \
4554  smallJsont*: icEqualCharPSmallJsonG, \
4555  smallStringt*: icEqualCharPSmallStringG, \
4556  default: notEqualOG), \
4557  const char *: _Generic((obj), \
4558  char *: icEqS, \
4559  const char *: icEqS, \
4560  char: icEqSChar, \
4561  baset*: icEqualCharOG, \
4562  bool: equalCharBoolG, \
4563  double: equalCharDoubleG, \
4564  int64_t: equalCharInt64G, \
4565  int32_t: equalCharInt32G, \
4566  uint32_t: equalCharUint32G, \
4567  uint64_t: equalCharUint64G, \
4568  smallBoolt*: equalCharSmallBoolG, \
4569  smallBytest*: equalCharSmallBytesG, \
4570  smallDoublet*: equalCharSmallDoubleG, \
4571  smallIntt*: equalCharSmallIntG, \
4572  smallJsont*: icEqualCharPSmallJsonG, \
4573  smallStringt*: icEqualCharPSmallStringG, \
4574  default: notEqualCCOG), \
4575  char **: _Generic((obj) , \
4576  char: notEqualOCharG, \
4577  char **: icListEqS, \
4578  const char **: icListEqCG, \
4579  baset*: icEqualArrayOG, \
4580  bool: notEqualOBoolG, \
4581  double: notEqualDoubleG, \
4582  int64_t: notEqualOInt64G, \
4583  int32_t: notEqualOInt32G, \
4584  uint32_t: notEqualOUint32G, \
4585  uint64_t: notEqualOUint64G, \
4586  smallJsont*: icEqualArraySmallJsonG, \
4587  smallArrayt*: icEqualArraySmallArrayG, \
4588  default: notEqualOG), \
4589  const char **: _Generic((obj) , \
4590  char: notEqualOCharG, \
4591  char **: icListEqC1G, \
4592  const char **: icListEqCCG, \
4593  baset*: icEqualCArrayOG, \
4594  bool: notEqualOBoolG, \
4595  double: notEqualDoubleG, \
4596  int64_t: notEqualOInt64G, \
4597  int32_t: notEqualOInt32G, \
4598  uint32_t: notEqualOUint32G, \
4599  uint64_t: notEqualOUint64G, \
4600  smallJsont*: icEqualCArraySmallJsonG, \
4601  smallArrayt*: icEqualCArraySmallArrayG, \
4602  default: notEqualOG), \
4603  baset*: _Generic((obj), \
4604  char: icEqualOChaG, \
4605  char *: icEqualOCharG, \
4606  const char *: icEqualOCharG, \
4607  char **: icEqualOArrayG, \
4608  const char **: icEqualOCArrayG, \
4609  baset*: icEqualOOG, \
4610  bool: equalOBoolG, \
4611  double: equalODoubleG, \
4612  int64_t: equalOInt64G, \
4613  int32_t: equalOInt32G, \
4614  uint32_t: equalOUint32G, \
4615  uint64_t: equalOUint64G, \
4616  smallArrayt*: icEqualOSmallArrayG, \
4617  smallBoolt*: equalOSmallBoolG, \
4618  smallBytest*: equalOSmallBytesG, \
4619  smallDoublet*: equalOSmallDoubleG, \
4620  smallDictt*: icEqualOSmallDictG, \
4621  smallIntt*: equalOSmallIntG, \
4622  smallJsont*: icEqualOSmallJsonG, \
4623  smallStringt*: icEqualOSmallStringG, \
4624  default: notEqualOG), \
4625  bool: _Generic((obj), \
4626  char: equalBoolChaG, \
4627  char *: equalBoolCharG, \
4628  const char *: equalBoolCharG, \
4629  baset*: equalBoolOG, \
4630  bool: equalBoolFG, \
4631  double: equalBoolDoubleG, \
4632  int64_t: equalBoolInt64G, \
4633  int32_t: equalBoolInt32G, \
4634  uint32_t: equalBoolUint32G, \
4635  uint64_t: equalBoolUint64G, \
4636  smallBoolt*: equalBoolSmallBoolG, \
4637  smallBytest*: equalBoolSmallBytesG, \
4638  smallDoublet*: equalBoolSmallDoubleG, \
4639  smallIntt*: equalBoolSmallIntG, \
4640  smallJsont*: equalBoolSmallJsonG, \
4641  smallStringt*: equalBoolSmallStringG, \
4642  default: notEqualBoolOG), \
4643  double: _Generic((obj), \
4644  char: equalDoubleChaG, \
4645  char *: equalDoubleCharG, \
4646  const char *: equalDoubleCharG, \
4647  baset*: equalDoubleBaseG, \
4648  bool: equalDoubleBoolG, \
4649  double: equalDoubleFG, \
4650  int64_t: equalDoubleInt64G, \
4651  int32_t: equalDoubleInt32G, \
4652  uint32_t: equalDoubleUint32G, \
4653  uint64_t: equalDoubleUint64G, \
4654  smallBoolt*: equalDoubleSmallBoolG, \
4655  smallBytest*: equalDoubleSmallBytesG, \
4656  smallDoublet*: equalDoubleSmallDoubleG, \
4657  smallIntt*: equalDoubleSmallIntG, \
4658  smallJsont*: equalDoubleSmallJsonG, \
4659  smallStringt*: equalDoubleSmallStringG, \
4660  default: notEqualDoubleOG), \
4661  int64_t: _Generic((obj), \
4662  char: equalInt64ChaG, \
4663  char *: equalInt64CharG, \
4664  const char *: equalInt64CharG, \
4665  baset*: equalInt64BaseG, \
4666  bool: equalInt64BoolG, \
4667  double: equalInt64DoubleG, \
4668  int64_t: equalInt64FG, \
4669  int32_t: equalInt64Int32G, \
4670  uint32_t: equalInt64Uint32G, \
4671  uint64_t: equalInt64Uint64G, \
4672  smallBoolt*: equalInt64SmallBoolG, \
4673  smallBytest*: equalInt64SmallBytesG, \
4674  smallDoublet*: equalInt64SmallDoubleG, \
4675  smallIntt*: equalInt64SmallIntG, \
4676  smallJsont*: equalInt64SmallJsonG, \
4677  smallStringt*: equalInt64SmallStringG, \
4678  default: notEqualInt64OG), \
4679  int32_t: _Generic((obj), \
4680  char: equalInt32ChaG, \
4681  char *: equalInt32CharG, \
4682  const char *: equalInt32CharG, \
4683  baset*: equalInt32BaseG, \
4684  bool: equalInt32BoolG, \
4685  double: equalInt32DoubleG, \
4686  int64_t: equalInt32Int64G, \
4687  int32_t: equalInt32FG, \
4688  uint32_t: equalInt32Uint32G, \
4689  uint64_t: equalInt32Uint64G, \
4690  smallBoolt*: equalInt32SmallBoolG, \
4691  smallBytest*: equalInt32SmallBytesG, \
4692  smallDoublet*: equalInt32SmallDoubleG, \
4693  smallIntt*: equalInt32SmallIntG, \
4694  smallJsont*: equalInt32SmallJsonG, \
4695  smallStringt*: equalInt32SmallStringG, \
4696  default: notEqualInt32OG), \
4697  uint32_t: _Generic((obj), \
4698  char: equalUint32ChaG, \
4699  char *: equalUint32CharG, \
4700  const char *: equalUint32CharG, \
4701  baset*: equalUint32BaseG, \
4702  bool: equalUint32BoolG, \
4703  double: equalUint32DoubleG, \
4704  int64_t: equalUint32Int64G, \
4705  int32_t: equalUint32Int32G, \
4706  uint32_t: equalUint32FG, \
4707  uint64_t: equalUint32Uint64G, \
4708  smallBoolt*: equalUint32SmallBoolG, \
4709  smallBytest*: equalUint32SmallBytesG, \
4710  smallDoublet*: equalUint32SmallDoubleG, \
4711  smallIntt*: equalUint32SmallIntG, \
4712  smallJsont*: equalUint32SmallJsonG, \
4713  smallStringt*: equalUint32SmallStringG, \
4714  default: notEqualUint32OG), \
4715  uint64_t: _Generic((obj), \
4716  char: equalUint64ChaG, \
4717  char *: equalUint64CharG, \
4718  const char *: equalUint64CharG, \
4719  baset*: equalUint64BaseG, \
4720  bool: equalUint64BoolG, \
4721  double: equalUint64DoubleG, \
4722  int64_t: equalUint64Int64G, \
4723  int32_t: equalUint64Int32G, \
4724  uint32_t: equalUint64Uint32G, \
4725  uint64_t: equalUint64FG, \
4726  smallBoolt*: equalUint64SmallBoolG, \
4727  smallBytest*: equalUint64SmallBytesG, \
4728  smallDoublet*: equalUint64SmallDoubleG, \
4729  smallIntt*: equalUint64SmallIntG, \
4730  smallJsont*: equalUint64SmallJsonG, \
4731  smallStringt*: equalUint64SmallStringG, \
4732  default: notEqualUint64OG), \
4733  smallArrayt*: _Generic((obj), \
4734  char: notEqualOCharG, \
4735  char **: icEqualSmallArrayArrayG, \
4736  const char **: icEqualSmallArrayCArrayG, \
4737  baset*: icEqualSmallArrayBaseG, \
4738  bool: notEqualOBoolG, \
4739  double: notEqualDoubleG, \
4740  int64_t: notEqualOInt64G, \
4741  int32_t: notEqualOInt32G, \
4742  uint32_t: notEqualOUint32G, \
4743  uint64_t: notEqualOUint32G, \
4744  smallJsont*: icEqualSmallArraySmallJsonG, \
4745  smallArrayt*: icEqualSmallArrayG, \
4746  default: notEqualOG), \
4747  smallBoolt*: _Generic((obj), \
4748  char: notEqualOCharG, \
4749  char *: equalSmallBoolCharG, \
4750  const char *: equalSmallBoolCharG, \
4751  baset*: equalSmallBoolBaseG, \
4752  bool: equalSmallBoolBoolG, \
4753  double: equalSmallBoolDoubleG, \
4754  int64_t: equalSmallBoolInt64G, \
4755  int32_t: equalSmallBoolInt32G, \
4756  uint32_t: equalSmallBoolUint32G, \
4757  uint64_t: equalSmallBoolUint64G, \
4758  smallBoolt*: equalSmallBoolFG, \
4759  smallBytest*: equalSmallBoolSmallBytesG, \
4760  smallDoublet*: equalSmallBoolSmallDoubleG, \
4761  smallIntt*: equalSmallBoolSmallIntG, \
4762  smallJsont*: equalSmallBoolSmallJsonG, \
4763  smallStringt*: equalSmallBoolSmallStringG, \
4764  default: notEqualOG), \
4765  smallBytest*: _Generic((obj), \
4766  char: notEqualOCharG, \
4767  char *: equalSmallBytesCharG, \
4768  const char *: equalSmallBytesCharG, \
4769  baset*: equalSmallBytesBaseG, \
4770  bool: equalSmallBytesBoolG, \
4771  double: equalSmallBytesDoubleG, \
4772  int64_t: equalSmallBytesInt64G, \
4773  int32_t: equalSmallBytesInt32G, \
4774  uint32_t: equalSmallBytesUint32G, \
4775  uint64_t: equalSmallBytesUint64G, \
4776  smallBoolt*: equalSmallBytesSmallBoolG, \
4777  smallBytest*: equalSmallBytesG, \
4778  smallDoublet*: equalSmallBytesSmallDoubleG, \
4779  smallIntt*: equalSmallBytesSmallIntG, \
4780  smallStringt*: equalSmallBytesSmallStringG, \
4781  default: notEqualOG), \
4782  smallDoublet*: _Generic((obj), \
4783  char: equalSmallDoubleChaG, \
4784  char *: equalSmallDoubleCharG, \
4785  const char *: equalSmallDoubleCharG, \
4786  baset*: equalSmallDoubleBaseG, \
4787  bool: equalSmallDoubleBoolG, \
4788  double: equalSmallDoubleDoubleG, \
4789  int64_t: equalSmallDoubleInt64G, \
4790  int32_t: equalSmallDoubleInt32G, \
4791  uint32_t: equalSmallDoubleUint32G, \
4792  uint64_t: equalSmallDoubleUint64G, \
4793  smallBoolt*: equalSmallDoubleSmallBoolG, \
4794  smallBytest*: equalSmallDoubleSmallBytesG, \
4795  smallDoublet*: equalSmallDoubleFG, \
4796  smallIntt*: equalSmallDoubleSmallIntG, \
4797  smallJsont*: equalSmallDoubleSmallJsonG, \
4798  smallStringt*: equalSmallDoubleSmallStringG, \
4799  default: notEqualOG), \
4800  smallDictt*: _Generic((obj), \
4801  char: notEqualOCharG, \
4802  baset*: icEqualSmallDictBaseG, \
4803  bool: notEqualOBoolG, \
4804  double: notEqualDoubleG, \
4805  int64_t: notEqualOInt64G, \
4806  int32_t: notEqualOInt32G, \
4807  uint32_t: notEqualOUint32G, \
4808  uint64_t: notEqualOUint64G, \
4809  smallJsont*: icEqualSmallDictSmallJsonG, \
4810  smallDictt*: icEqualSmallDictG, \
4811  default: notEqualOG), \
4812  smallIntt*: _Generic((obj), \
4813  char: equalSmallIntChaG, \
4814  char *: equalSmallIntCharG, \
4815  const char *: equalSmallIntCharG, \
4816  baset*: equalSmallIntBaseG, \
4817  bool: equalSmallIntBoolG, \
4818  double: equalSmallIntDoubleG, \
4819  int64_t: equalSmallIntInt64G, \
4820  int32_t: equalSmallIntInt32G, \
4821  uint32_t: equalSmallIntUint32G, \
4822  uint64_t: equalSmallIntUint64G, \
4823  smallBoolt*: equalSmallIntSmallBoolG, \
4824  smallBytest*: equalSmallIntSmallBytesG, \
4825  smallDoublet*: equalSmallIntSmallDoubleG, \
4826  smallIntt*: equalSmallIntFG, \
4827  smallJsont*: equalSmallIntSmallJsonG, \
4828  smallStringt*: equalSmallIntSmallStringG, \
4829  default: notEqualOG), \
4830  smallJsont*: _Generic((obj), \
4831  char *: icEqualSSmallJsonG, \
4832  const char *: icEqualSSmallJsonG, \
4833  char: icEqualCharSmallJsonG, \
4834  char **: icEqualSmallJsonArrayG, \
4835  const char **: icEqualSmallJsonCArrayG, \
4836  baset*: icEqualSmallJsonBaseG, \
4837  bool: equalSmallJsonBoolG, \
4838  double: equalSmallJsonDoubleG, \
4839  int64_t: equalSmallJsonInt64G, \
4840  int32_t: equalSmallJsonInt32G, \
4841  uint32_t: equalSmallJsonUint32G, \
4842  uint64_t: equalSmallJsonUint64G, \
4843  smallArrayt*: icEqualSmallJsonSmallArrayG, \
4844  smallBoolt*: equalSmallJsonSmallBoolG, \
4845  smallBytest*: equalSmallJsonSmallBytesG, \
4846  smallDictt*: icEqualSmallJsonSmallDictG, \
4847  smallDoublet*: equalSmallJsonSmallDoubleG, \
4848  smallIntt*: equalSmallJsonSmallIntG, \
4849  smallJsont*: icEqualSmallJsonSmallJsonG, \
4850  smallStringt*: icEqualSmallJsonSmallStringG, \
4851  default: notEqualOG), \
4852  smallStringt*: _Generic((obj), \
4853  char *: icEqualSSmallStringG, \
4854  const char *: icEqualSSmallStringG, \
4855  char: icEqualCharSmallStringG, \
4856  baset*: icEqualSmallStringBaseG, \
4857  bool: equalSmallStringBoolG, \
4858  double: equalSmallStringDoubleG, \
4859  int64_t: equalSmallStringInt64G, \
4860  int32_t: equalSmallStringInt32G, \
4861  uint32_t: equalSmallStringUint32G, \
4862  uint64_t: equalSmallStringUint64G, \
4863  smallBoolt*: equalSmallStringSmallBoolG, \
4864  smallBytest*: equalSmallStringSmallBytesG, \
4865  smallDoublet*: equalSmallStringSmallDoubleG, \
4866  smallIntt*: equalSmallStringSmallIntG, \
4867  smallJsont*: icEqualSmallStringSmallJsonG, \
4868  smallStringt*: icEqualSmallStringFG, \
4869  default: notEqualOG) \
4870  )(self, obj)
4871 
4872 #define eqIG(self, obj, index) _Generic((self), \
4873  char *: _Generic(obj, \
4874  char *: eqIS, \
4875  const char *: eqIS, \
4876  char: eqICharS, \
4877  int: eqICharS, \
4878  default: eqIS \
4879  ), \
4880  const char *: _Generic(obj, \
4881  char *: eqIS, \
4882  const char *: eqIS, \
4883  char: eqICharS, \
4884  int: eqICharS, \
4885  default: eqIS \
4886  ), \
4887  smallJsont *: _Generic(obj, \
4888  char *: equalISSmallJsonG, \
4889  const char *: equalISSmallJsonG, \
4890  char: equalICharSmallJsonG, \
4891  int: equalICharSmallJsonG, \
4892  smallJsont *: equalIJsonSmallJsonG, \
4893  smallStringt *: equalISmallStringSmallJsonG, \
4894  default: equalISSmallJsonG \
4895  ), \
4896  smallStringt *: _Generic(obj, \
4897  char *: equalISSmallStringG, \
4898  const char *: equalISSmallStringG, \
4899  char: equalICharSmallStringG, \
4900  int: equalICharSmallStringG, \
4901  smallJsont *: equalISmallJsonSmallStringG, \
4902  smallStringt *: equalISmallStringSmallStringG, \
4903  default: equalISSmallStringG \
4904  ) \
4905  )(self, obj, index)
4906 
4907 #define startsWithG(self, obj) _Generic((self), \
4908  char *: _Generic(obj, \
4909  char *: startsWithS, \
4910  const char *: startsWithS, \
4911  char: startsWithCharS, \
4912  int: startsWithCharS, \
4913  default: startsWithS \
4914  ), \
4915  const char *: _Generic(obj, \
4916  char *: startsWithS, \
4917  const char *: startsWithS, \
4918  char: startsWithCharS, \
4919  int: startsWithCharS, \
4920  default: startsWithS \
4921  ), \
4922  smallJsont *: _Generic(obj, \
4923  char *: startsWithSSmallJsonG, \
4924  const char *: startsWithSSmallJsonG, \
4925  char: startsWithCharSmallJsonG, \
4926  int: startsWithCharSmallJsonG, \
4927  smallJsont *: startsWithJsonSmallJsonG, \
4928  smallStringt *: startsWithSmallStringSmallJsonG \
4929  ), \
4930  smallStringt *: _Generic(obj, \
4931  char *: startsWithSSmallStringG, \
4932  const char *: startsWithSSmallStringG, \
4933  char: startsWithCharSmallStringG, \
4934  int: startsWithCharSmallStringG, \
4935  smallJsont *: startsWithSmallJsonSmallStringG, \
4936  smallStringt *: startsWithSmallStringSmallStringG \
4937  ) \
4938  )(self, obj)
4939 
4940 #define endsWithG(self, obj) _Generic((self), \
4941  char *: _Generic(obj, \
4942  char *: endsWithS, \
4943  const char *: endsWithS, \
4944  char: endsWithCharS, \
4945  int: endsWithCharS, \
4946  default: endsWithS \
4947  ), \
4948  const char *: _Generic(obj, \
4949  char *: endsWithS, \
4950  const char *: endsWithS, \
4951  char: endsWithCharS, \
4952  int: endsWithCharS, \
4953  default: endsWithS \
4954  ), \
4955  smallJsont *: _Generic(obj, \
4956  char *: endsWithSSmallJsonG, \
4957  const char *: endsWithSSmallJsonG, \
4958  char: endsWithCharSmallJsonG, \
4959  int: endsWithCharSmallJsonG, \
4960  smallJsont *: endsWithJsonSmallJsonG, \
4961  smallStringt *: endsWithSmallStringSmallJsonG \
4962  ), \
4963  smallStringt *: _Generic(obj, \
4964  char *: endsWithSSmallStringG, \
4965  const char *: endsWithSSmallStringG, \
4966  char: endsWithCharSmallStringG, \
4967  int: endsWithCharSmallStringG, \
4968  smallJsont *: endsWithSmallJsonSmallStringG, \
4969  smallStringt *: endsWithSmallStringSmallStringG \
4970  ) \
4971  )(self, obj)
4972 
4973 #define countG(self, obj) _Generic((self), \
4974  char *: _Generic(obj, \
4975  char *: countS, \
4976  const char *: countS, \
4977  char: countCharS, \
4978  int: countCharS, \
4979  default: countS \
4980  ), \
4981  const char *: _Generic(obj, \
4982  char *: countS, \
4983  const char *: countS, \
4984  char: countCharS, \
4985  int: countCharS, \
4986  default: countS \
4987  ), \
4988  smallJsont *: _Generic(obj, \
4989  char *: countSSmallJsonG, \
4990  const char *: countSSmallJsonG, \
4991  char: countCharSmallJsonG, \
4992  int: countCharSmallJsonG, \
4993  smallJsont *: countJsonSmallJsonG, \
4994  smallStringt *: countSmallStringSmallJsonG \
4995  ), \
4996  smallStringt *: _Generic(obj, \
4997  char *: countSSmallStringG, \
4998  const char *: countSSmallStringG, \
4999  char: countCharSmallStringG, \
5000  int: countCharSmallStringG, \
5001  smallJsont *: countSmallJsonSmallStringG, \
5002  smallStringt *: countSmallStringSmallStringG \
5003  ) \
5004  )(self, obj)
5005 
5006 #define icStartsWithG(self, obj) _Generic((self), \
5007  char *: _Generic(obj, \
5008  char *: icStartsWithS, \
5009  const char *: icStartsWithS, \
5010  char: icStartsWithCharS, \
5011  int: icStartsWithCharS, \
5012  default: icStartsWithS \
5013  ), \
5014  const char *: _Generic(obj, \
5015  char *: icStartsWithS, \
5016  const char *: icStartsWithS, \
5017  char: icStartsWithCharS, \
5018  int: icStartsWithCharS, \
5019  default: icStartsWithS \
5020  ), \
5021  smallJsont *: _Generic(obj, \
5022  char *: icStartsWithSSmallJsonG, \
5023  const char *: icStartsWithSSmallJsonG, \
5024  char: icStartsWithCharSmallJsonG, \
5025  int: icStartsWithCharSmallJsonG, \
5026  smallJsont *: icStartsWithJsonSmallJsonG, \
5027  smallStringt *: icStartsWithSmallStringSmallJsonG \
5028  ), \
5029  smallStringt *: _Generic(obj, \
5030  char *: icStartsWithSSmallStringG, \
5031  const char *: icStartsWithSSmallStringG, \
5032  char: icStartsWithCharSmallStringG, \
5033  int: icStartsWithCharSmallStringG, \
5034  smallJsont *: icStartsWithSmallJsonSmallStringG, \
5035  smallStringt *: icStartsWithSmallStringSmallStringG \
5036  ) \
5037  )(self, obj)
5038 
5039 #define icEndsWithG(self, obj) _Generic((self), \
5040  char *: _Generic(obj, \
5041  char *: icEndsWithS, \
5042  const char *: icEndsWithS, \
5043  char: icEndsWithCharS, \
5044  int: icEndsWithCharS, \
5045  default: icEndsWithS \
5046  ), \
5047  const char *: _Generic(obj, \
5048  char *: icEndsWithS, \
5049  const char *: icEndsWithS, \
5050  char: icEndsWithCharS, \
5051  int: icEndsWithCharS, \
5052  default: icEndsWithS \
5053  ), \
5054  smallJsont *: _Generic(obj, \
5055  char *: icEndsWithSSmallJsonG, \
5056  const char *: icEndsWithSSmallJsonG, \
5057  char: icEndsWithCharSmallJsonG, \
5058  int: icEndsWithCharSmallJsonG, \
5059  smallJsont *: icEndsWithJsonSmallJsonG, \
5060  smallStringt *: icEndsWithSmallStringSmallJsonG \
5061  ), \
5062  smallStringt *: _Generic(obj, \
5063  char *: icEndsWithSSmallStringG, \
5064  const char *: icEndsWithSSmallStringG, \
5065  char: icEndsWithCharSmallStringG, \
5066  int: icEndsWithCharSmallStringG, \
5067  smallJsont *: icEndsWithSmallJsonSmallStringG, \
5068  smallStringt *: icEndsWithSmallStringSmallStringG \
5069  ) \
5070  )(self, obj)
5071 
5072 #define icCountG(self, obj) _Generic((self), \
5073  char *: _Generic(obj, \
5074  char *: icCountS, \
5075  const char *: icCountS, \
5076  char: icCountCharS, \
5077  int: icCountCharS, \
5078  default: icCountS \
5079  ), \
5080  const char *: _Generic(obj, \
5081  char *: icCountS, \
5082  const char *: icCountS, \
5083  char: icCountCharS, \
5084  int: icCountCharS, \
5085  default: icCountS \
5086  ), \
5087  smallJsont *: _Generic(obj, \
5088  char *: icCountSSmallJsonG, \
5089  const char *: icCountSSmallJsonG, \
5090  char: icCountCharSmallJsonG, \
5091  int: icCountCharSmallJsonG, \
5092  smallJsont *: icCountJsonSmallJsonG, \
5093  smallStringt *: icCountSmallStringSmallJsonG \
5094  ), \
5095  smallStringt *: _Generic(obj, \
5096  char *: icCountSSmallStringG, \
5097  const char *: icCountSSmallStringG, \
5098  char: icCountCharSmallStringG, \
5099  int: icCountCharSmallStringG, \
5100  smallJsont *: icCountSmallJsonSmallStringG, \
5101  smallStringt *: icCountSmallStringSmallStringG \
5102  ) \
5103  )(self, obj)
5104 
5105 #define isNumberO(self) (self)->f->isNumber(self)
5106 #define isNumberG(self) _Generic((self), \
5107  char *: isNumber, \
5108  const char *: isNumber, \
5109  smallJsont *: isNumberSmallJsonG, \
5110  smallStringt *: isNumberSmallStringG \
5111  )(self)
5112 
5113 #define isIntO(self) (self)->f->isInt(self)
5114 #define isIntG(self) _Generic((self), \
5115  char *: isInt, \
5116  const char *: isInt, \
5117  smallJsont *: isIntSmallJsonG, \
5118  smallStringt *: isIntSmallStringG \
5119  )(self)
5120 
5121 
5122 #define parseIntO(self) (self)->f->parseInt(self)
5123 #define parseIntG(self) _Generic((self), \
5124  char: parseIntChar, \
5125  int: parseIntChar, \
5126  char *: parseInt, \
5127  const char *: parseInt, \
5128  smallJsont *: parseIntSmallJsonG, \
5129  smallStringt *: parseIntSmallStringG \
5130  )(self)
5131 
5132 #define intToO(self, n) (self)->f->intTo(self, n)
5133 #define intToG(self, n) _Generic((self), \
5134  char *: intToSG, \
5135  smallJsont *: intToSmallJsonG, \
5136  smallStringt *: intToSmallStringG \
5137  )(self, n)
5138 
5139 #define parseDoubleO(self) (self)->f->parseDouble(self)
5140 #define parseDoubleG(self) _Generic((self), \
5141  char: parseDoubleChar, \
5142  int: parseDoubleChar, \
5143  char *: parseDouble, \
5144  const char *: parseDouble, \
5145  smallJsont *: parseDoubleSmallJsonG, \
5146  smallStringt *: parseDoubleSmallStringG \
5147  )(self)
5148 
5149 #define doubleToO(self, n) (self)->f->doubleTo(self, n)
5150 #define doubleToG(self, n) _Generic((self), \
5151  char *: doubleToSG, \
5152  smallJsont *: doubleToSmallJsonG, \
5153  smallStringt *: doubleToSmallStringG \
5154  )(self, n)
5155 
5156 #define lenO(self) (self)->f->len(self)
5157 #define lenG(self) _Generic((self), \
5158  char *: lenS, \
5159  const char *: lenS, \
5160  char **: listLengthS, \
5161  const char **: listLengthCG, \
5162  smallArrayt *: lenSmallArrayG, \
5163  smallBytest *: lenSmallBytesG, \
5164  smallDictt *: lenSmallDictG, \
5165  smallJsont *: lenSmallJsonG, \
5166  smallStringt *: lenSmallStringG \
5167  )(self)
5168 
5169 #define upperO(self) (self)->f->upper(self)
5170 #define upperG(self) _Generic((self), \
5171  char *: upperS, \
5172  const char *: upperS, \
5173  char **: iUpperS, \
5174  smallJsont *: upperSmallJsonG, \
5175  smallStringt *: upperSmallStringG \
5176  )(self)
5177 
5178 #define lowerO(self) (self)->f->lower(self)
5179 #define lowerG(self) _Generic((self), \
5180  char *: lowerS, \
5181  const char *: lowerS, \
5182  char **: iLowerS, \
5183  smallJsont *: lowerSmallJsonG, \
5184  smallStringt *: lowerSmallStringG \
5185  )(self)
5186 
5187 #define trimO(self) (self)->f->trim(self)
5188 #define trimG(self) _Generic((self), \
5189  char *: trimS, \
5190  const char *: trimS, \
5191  char **: iTrimS, \
5192  smallArrayt *: trimSmallArrayG, \
5193  smallDictt *: trimSmallDictG, \
5194  smallJsont *: trimSmallJsonG, \
5195  smallStringt *: trimSmallStringG, \
5196  btt: trimB, \
5197  const btt: trimB, \
5198  btt*: bTrimB, \
5199  const btt*: trimPB \
5200  )(self)
5201 
5202 #define lTrimO(self) (self)->f->lTrim(self)
5203 #define lTrimG(self) _Generic((self), \
5204  char *: lTrimS, \
5205  const char *: lTrimS, \
5206  char **: iLTrimS, \
5207  smallJsont *: lTrimSmallJsonG, \
5208  smallStringt *: lTrimSmallStringG \
5209  )(self)
5210 
5211 #define rTrimO(self) (self)->f->rTrim(self)
5212 #define rTrimG(self) _Generic((self), \
5213  char *: rTrimS, \
5214  const char *: rTrimS, \
5215  char **: iRTrimS, \
5216  smallJsont *: rTrimSmallJsonG, \
5217  smallStringt *: rTrimSmallStringG \
5218  )(self)
5219 
5220 #define uniqO(self, c) (self)->f->uniq(self, c)
5221 #define uniqG(self, c) _Generic((self), \
5222  char *: uniqS, \
5223  const char *: uniqS, \
5224  char **: iUniqS, \
5225  char ***: iListUniqG, \
5226  smallArrayt *: uniqSmallArrayG, \
5227  smallJsont *: uniqSmallJsonG, \
5228  smallStringt *: uniqSmallStringG \
5229  )(self, c)
5230 
5231 #define icUniqO(self, c) (self)->f->icUniq(self, c)
5232 #define icUniqG(self, c) _Generic((self), \
5233  char *: icUniqS, \
5234  const char *: icUniqS, \
5235  char **: iicUniqS, \
5236  char ***: iicListUniqG, \
5237  smallArrayt *: icUniqSmallArrayG, \
5238  smallJsont *: icUniqSmallJsonG, \
5239  smallStringt *: icUniqSmallStringG \
5240  )(self, c)
5241 
5242 #define sliceO(self, start, end) (self)->f->slice(self, start, end)
5243 #define sliceG(self, start, end) _Generic((self), \
5244  char *: sliceS, \
5245  const char *: sliceS, \
5246  char **: iSliceS, \
5247  char ***: iListSliceS, \
5248  smallArrayt *: sliceSmallArrayG, \
5249  smallJsont *: sliceSmallJsonG, \
5250  smallStringt *: sliceSmallStringG, \
5251  btt: sliceB, \
5252  const btt: sliceB, \
5253  btt*: bSliceB, \
5254  const btt*: slicePB \
5255  )(self, start, end)
5256 
5257 
5258 #define cropO(self, start, end) (self)->f->crop(self, start, end)
5259 #define cropG(self, start, end) _Generic((self), \
5260  char *: cropS, \
5261  char **: listCropS, \
5262  char ***: iListCropS, \
5263  smallArrayt *: cropSmallArrayG, \
5264  smallJsont *: cropSmallJsonG, \
5265  smallStringt *: cropSmallStringG \
5266  )(self, start, end)
5267 
5268 #define cropElemO(self, index) (self)->f->cropElem(self, index)
5269 #define cropElemG(self, returnType, index) _Generic((self), \
5270  smallDictt*: _Generic(index, \
5271  char *: _Generic(returnType, \
5272  baset*: cropElemSmallDictG, \
5273  undefinedt*: cropElemUndefinedSmallDictG, \
5274  bool: cropElemBoolSmallDictG, \
5275  double: cropElemDoubleSmallDictG, \
5276  int64_t: cropElemIntSmallDictG, \
5277  int32_t: cropElemInt32SmallDictG, \
5278  uint64_t: cropElemUintSmallDictG, \
5279  uint32_t: cropElemUint32SmallDictG, \
5280  char*: cropElemSSmallDictG, \
5281  smallDictt*: cropElemDictSmallDictG, \
5282  smallArrayt*: cropElemArraySmallDictG, \
5283  smallBoolt*: cropElemSmallBoolSmallDictG, \
5284  smallBytest*: cropElemSmallBytesSmallDictG, \
5285  smallDoublet*: cropElemSmallDoubleSmallDictG, \
5286  smallIntt*: cropElemSmallIntSmallDictG, \
5287  smallJsont*: cropElemSmallJsonSmallDictG, \
5288  smallStringt*: cropElemSmallStringSmallDictG, \
5289  void*: cropElemVoidSmallDictG, \
5290  smallContainert*: cropElemSmallContainerSmallDictG, \
5291  default: cropElemSmallDictG), \
5292  const char *: _Generic(returnType, \
5293  baset*: cropElemSmallDictG, \
5294  undefinedt*: cropElemUndefinedSmallDictG, \
5295  bool: cropElemBoolSmallDictG, \
5296  double: cropElemDoubleSmallDictG, \
5297  int64_t: cropElemIntSmallDictG, \
5298  int32_t: cropElemInt32SmallDictG, \
5299  uint64_t: cropElemUintSmallDictG, \
5300  uint32_t: cropElemUint32SmallDictG, \
5301  char*: cropElemSSmallDictG, \
5302  smallDictt*: cropElemDictSmallDictG, \
5303  smallArrayt*: cropElemArraySmallDictG, \
5304  smallBoolt*: cropElemSmallBoolSmallDictG, \
5305  smallBytest*: cropElemSmallBytesSmallDictG, \
5306  smallDoublet*: cropElemSmallDoubleSmallDictG, \
5307  smallIntt*: cropElemSmallIntSmallDictG, \
5308  smallJsont*: cropElemSmallJsonSmallDictG, \
5309  smallStringt*: cropElemSmallStringSmallDictG, \
5310  void*: cropElemVoidSmallDictG, \
5311  smallContainert*: cropElemSmallContainerSmallDictG, \
5312  default: cropElemSmallDictG), \
5313  default: cropElemSmallDictG \
5314  ), \
5315  smallJsont*: _Generic(index, \
5316  char *: _Generic(returnType, \
5317  baset*: cropElemKeySmallJsonG, \
5318  undefinedt*: cropElemKeyUndefinedSmallJsonG, \
5319  bool: cropElemKeyBoolSmallJsonG, \
5320  double: cropElemKeyDoubleSmallJsonG, \
5321  int64_t: cropElemKeyIntSmallJsonG, \
5322  int32_t: cropElemKeyInt32SmallJsonG, \
5323  uint64_t: cropElemKeyUintSmallJsonG, \
5324  uint32_t: cropElemKeyUint32SmallJsonG, \
5325  char*: cropElemKeySSmallJsonG, \
5326  smallDictt*: cropElemKeyDictSmallJsonG, \
5327  smallArrayt*: cropElemKeyArraySmallJsonG, \
5328  smallBoolt*: cropElemKeySmallBoolSmallJsonG, \
5329  smallBytest*: cropElemKeySmallBytesSmallJsonG, \
5330  smallDoublet*: cropElemKeySmallDoubleSmallJsonG, \
5331  smallIntt*: cropElemKeySmallIntSmallJsonG, \
5332  smallJsont*: cropElemKeySmallJsonSmallJsonG, \
5333  smallStringt*: cropElemKeySmallStringSmallJsonG, \
5334  void*: cropElemKeyVoidSmallJsonG, \
5335  smallContainert*: cropElemKeySmallContainerSmallJsonG, \
5336  default: cropElemKeySmallJsonG), \
5337  const char *: _Generic(returnType, \
5338  baset*: cropElemKeySmallJsonG, \
5339  undefinedt*: cropElemKeyUndefinedSmallJsonG, \
5340  bool: cropElemKeyBoolSmallJsonG, \
5341  double: cropElemKeyDoubleSmallJsonG, \
5342  int64_t: cropElemKeyIntSmallJsonG, \
5343  int32_t: cropElemKeyInt32SmallJsonG, \
5344  uint64_t: cropElemKeyUintSmallJsonG, \
5345  uint32_t: cropElemKeyUint32SmallJsonG, \
5346  char*: cropElemKeySSmallJsonG, \
5347  smallDictt*: cropElemKeyDictSmallJsonG, \
5348  smallArrayt*: cropElemKeyArraySmallJsonG, \
5349  smallBoolt*: cropElemKeySmallBoolSmallJsonG, \
5350  smallBytest*: cropElemKeySmallBytesSmallJsonG, \
5351  smallDoublet*: cropElemKeySmallDoubleSmallJsonG, \
5352  smallIntt*: cropElemKeySmallIntSmallJsonG, \
5353  smallJsont*: cropElemKeySmallJsonSmallJsonG, \
5354  smallStringt*: cropElemKeySmallStringSmallJsonG, \
5355  void*: cropElemKeyVoidSmallJsonG, \
5356  smallContainert*: cropElemKeySmallContainerSmallJsonG, \
5357  default: cropElemKeySmallJsonG), \
5358  int64_t: _Generic(returnType, \
5359  baset*: cropElemAtSmallJsonG, \
5360  undefinedt*: cropElemAtUndefinedSmallJsonG, \
5361  bool: cropElemAtBoolSmallJsonG, \
5362  double: cropElemAtDoubleSmallJsonG, \
5363  int64_t: cropElemAtIntSmallJsonG, \
5364  int32_t: cropElemAtInt32SmallJsonG, \
5365  uint64_t: cropElemAtUintSmallJsonG, \
5366  uint32_t: cropElemAtUint32SmallJsonG, \
5367  char*: cropElemAtSSmallJsonG, \
5368  smallDictt*: cropElemAtDictSmallJsonG, \
5369  smallArrayt*: cropElemAtArraySmallJsonG, \
5370  smallBoolt*: cropElemAtSmallBoolSmallJsonG, \
5371  smallBytest*: cropElemAtSmallBytesSmallJsonG, \
5372  smallDoublet*: cropElemAtSmallDoubleSmallJsonG, \
5373  smallIntt*: cropElemAtSmallIntSmallJsonG, \
5374  smallJsont*: cropElemAtSmallJsonSmallJsonG, \
5375  smallStringt*: cropElemAtSmallStringSmallJsonG, \
5376  void*: cropElemAtVoidSmallJsonG, \
5377  smallContainert*: cropElemAtSmallContainerSmallJsonG, \
5378  default: cropElemAtSmallJsonG), \
5379  int32_t: _Generic(returnType, \
5380  baset*: cropElemAtSmallJsonG, \
5381  undefinedt*: cropElemAtUndefinedSmallJsonG, \
5382  bool: cropElemAtBoolSmallJsonG, \
5383  double: cropElemAtDoubleSmallJsonG, \
5384  int64_t: cropElemAtIntSmallJsonG, \
5385  int32_t: cropElemAtInt32SmallJsonG, \
5386  uint64_t: cropElemAtUintSmallJsonG, \
5387  uint32_t: cropElemAtUint32SmallJsonG, \
5388  char*: cropElemAtSSmallJsonG, \
5389  smallDictt*: cropElemAtDictSmallJsonG, \
5390  smallArrayt*: cropElemAtArraySmallJsonG, \
5391  smallBoolt*: cropElemAtSmallBoolSmallJsonG, \
5392  smallBytest*: cropElemAtSmallBytesSmallJsonG, \
5393  smallDoublet*: cropElemAtSmallDoubleSmallJsonG, \
5394  smallIntt*: cropElemAtSmallIntSmallJsonG, \
5395  smallJsont*: cropElemAtSmallJsonSmallJsonG, \
5396  smallStringt*: cropElemAtSmallStringSmallJsonG, \
5397  void*: cropElemAtVoidSmallJsonG, \
5398  smallContainert*: cropElemAtSmallContainerSmallJsonG, \
5399  default: cropElemAtSmallJsonG), \
5400  int16_t: _Generic(returnType, \
5401  baset*: cropElemAtSmallJsonG, \
5402  undefinedt*: cropElemAtUndefinedSmallJsonG, \
5403  bool: cropElemAtBoolSmallJsonG, \
5404  double: cropElemAtDoubleSmallJsonG, \
5405  int64_t: cropElemAtIntSmallJsonG, \
5406  int32_t: cropElemAtInt32SmallJsonG, \
5407  uint64_t: cropElemAtUintSmallJsonG, \
5408  uint32_t: cropElemAtUint32SmallJsonG, \
5409  char*: cropElemAtSSmallJsonG, \
5410  smallDictt*: cropElemAtDictSmallJsonG, \
5411  smallArrayt*: cropElemAtArraySmallJsonG, \
5412  smallBoolt*: cropElemAtSmallBoolSmallJsonG, \
5413  smallBytest*: cropElemAtSmallBytesSmallJsonG, \
5414  smallDoublet*: cropElemAtSmallDoubleSmallJsonG, \
5415  smallIntt*: cropElemAtSmallIntSmallJsonG, \
5416  smallJsont*: cropElemAtSmallJsonSmallJsonG, \
5417  smallStringt*: cropElemAtSmallStringSmallJsonG, \
5418  void*: cropElemAtVoidSmallJsonG, \
5419  smallContainert*: cropElemAtSmallContainerSmallJsonG, \
5420  default: cropElemAtSmallJsonG), \
5421  int8_t: _Generic(returnType, \
5422  baset*: cropElemAtSmallJsonG, \
5423  undefinedt*: cropElemAtUndefinedSmallJsonG, \
5424  bool: cropElemAtBoolSmallJsonG, \
5425  double: cropElemAtDoubleSmallJsonG, \
5426  int64_t: cropElemAtIntSmallJsonG, \
5427  int32_t: cropElemAtInt32SmallJsonG, \
5428  uint64_t: cropElemAtUintSmallJsonG, \
5429  uint32_t: cropElemAtUint32SmallJsonG, \
5430  char*: cropElemAtSSmallJsonG, \
5431  smallDictt*: cropElemAtDictSmallJsonG, \
5432  smallArrayt*: cropElemAtArraySmallJsonG, \
5433  smallBoolt*: cropElemAtSmallBoolSmallJsonG, \
5434  smallBytest*: cropElemAtSmallBytesSmallJsonG, \
5435  smallDoublet*: cropElemAtSmallDoubleSmallJsonG, \
5436  smallIntt*: cropElemAtSmallIntSmallJsonG, \
5437  smallJsont*: cropElemAtSmallJsonSmallJsonG, \
5438  smallStringt*: cropElemAtSmallStringSmallJsonG, \
5439  void*: cropElemAtVoidSmallJsonG, \
5440  smallContainert*: cropElemAtSmallContainerSmallJsonG, \
5441  default: cropElemAtSmallJsonG), \
5442  uint64_t: _Generic(returnType, \
5443  baset*: cropElemAtSmallJsonG, \
5444  undefinedt*: cropElemAtUndefinedSmallJsonG, \
5445  bool: cropElemAtBoolSmallJsonG, \
5446  double: cropElemAtDoubleSmallJsonG, \
5447  int64_t: cropElemAtIntSmallJsonG, \
5448  int32_t: cropElemAtInt32SmallJsonG, \
5449  uint64_t: cropElemAtUintSmallJsonG, \
5450  uint32_t: cropElemAtUint32SmallJsonG, \
5451  char*: cropElemAtSSmallJsonG, \
5452  smallDictt*: cropElemAtDictSmallJsonG, \
5453  smallArrayt*: cropElemAtArraySmallJsonG, \
5454  smallBoolt*: cropElemAtSmallBoolSmallJsonG, \
5455  smallBytest*: cropElemAtSmallBytesSmallJsonG, \
5456  smallDoublet*: cropElemAtSmallDoubleSmallJsonG, \
5457  smallIntt*: cropElemAtSmallIntSmallJsonG, \
5458  smallJsont*: cropElemAtSmallJsonSmallJsonG, \
5459  smallStringt*: cropElemAtSmallStringSmallJsonG, \
5460  void*: cropElemAtVoidSmallJsonG, \
5461  smallContainert*: cropElemAtSmallContainerSmallJsonG, \
5462  default: cropElemAtSmallJsonG), \
5463  uint32_t: _Generic(returnType, \
5464  baset*: cropElemAtSmallJsonG, \
5465  undefinedt*: cropElemAtUndefinedSmallJsonG, \
5466  bool: cropElemAtBoolSmallJsonG, \
5467  double: cropElemAtDoubleSmallJsonG, \
5468  int64_t: cropElemAtIntSmallJsonG, \
5469  int32_t: cropElemAtInt32SmallJsonG, \
5470  uint64_t: cropElemAtUintSmallJsonG, \
5471  uint32_t: cropElemAtUint32SmallJsonG, \
5472  char*: cropElemAtSSmallJsonG, \
5473  smallDictt*: cropElemAtDictSmallJsonG, \
5474  smallArrayt*: cropElemAtArraySmallJsonG, \
5475  smallBoolt*: cropElemAtSmallBoolSmallJsonG, \
5476  smallBytest*: cropElemAtSmallBytesSmallJsonG, \
5477  smallDoublet*: cropElemAtSmallDoubleSmallJsonG, \
5478  smallIntt*: cropElemAtSmallIntSmallJsonG, \
5479  smallJsont*: cropElemAtSmallJsonSmallJsonG, \
5480  smallStringt*: cropElemAtSmallStringSmallJsonG, \
5481  void*: cropElemAtVoidSmallJsonG, \
5482  smallContainert*: cropElemAtSmallContainerSmallJsonG, \
5483  default: cropElemAtSmallJsonG), \
5484  uint16_t: _Generic(returnType, \
5485  baset*: cropElemAtSmallJsonG, \
5486  undefinedt*: cropElemAtUndefinedSmallJsonG, \
5487  bool: cropElemAtBoolSmallJsonG, \
5488  double: cropElemAtDoubleSmallJsonG, \
5489  int64_t: cropElemAtIntSmallJsonG, \
5490  int32_t: cropElemAtInt32SmallJsonG, \
5491  uint64_t: cropElemAtUintSmallJsonG, \
5492  uint32_t: cropElemAtUint32SmallJsonG, \
5493  char*: cropElemAtSSmallJsonG, \
5494  smallDictt*: cropElemAtDictSmallJsonG, \
5495  smallArrayt*: cropElemAtArraySmallJsonG, \
5496  smallBoolt*: cropElemAtSmallBoolSmallJsonG, \
5497  smallBytest*: cropElemAtSmallBytesSmallJsonG, \
5498  smallDoublet*: cropElemAtSmallDoubleSmallJsonG, \
5499  smallIntt*: cropElemAtSmallIntSmallJsonG, \
5500  smallJsont*: cropElemAtSmallJsonSmallJsonG, \
5501  smallStringt*: cropElemAtSmallStringSmallJsonG, \
5502  void*: cropElemAtVoidSmallJsonG, \
5503  smallContainert*: cropElemAtSmallContainerSmallJsonG, \
5504  default: cropElemAtSmallJsonG), \
5505  uint8_t: _Generic(returnType, \
5506  baset*: cropElemAtSmallJsonG, \
5507  undefinedt*: cropElemAtUndefinedSmallJsonG, \
5508  bool: cropElemAtBoolSmallJsonG, \
5509  double: cropElemAtDoubleSmallJsonG, \
5510  int64_t: cropElemAtIntSmallJsonG, \
5511  int32_t: cropElemAtInt32SmallJsonG, \
5512  uint64_t: cropElemAtUintSmallJsonG, \
5513  uint32_t: cropElemAtUint32SmallJsonG, \
5514  char*: cropElemAtSSmallJsonG, \
5515  smallDictt*: cropElemAtDictSmallJsonG, \
5516  smallArrayt*: cropElemAtArraySmallJsonG, \
5517  smallBoolt*: cropElemAtSmallBoolSmallJsonG, \
5518  smallBytest*: cropElemAtSmallBytesSmallJsonG, \
5519  smallDoublet*: cropElemAtSmallDoubleSmallJsonG, \
5520  smallIntt*: cropElemAtSmallIntSmallJsonG, \
5521  smallJsont*: cropElemAtSmallJsonSmallJsonG, \
5522  smallStringt*: cropElemAtSmallStringSmallJsonG, \
5523  void*: cropElemAtVoidSmallJsonG, \
5524  smallContainert*: cropElemAtSmallContainerSmallJsonG, \
5525  default: cropElemAtSmallJsonG), \
5526  default: cropElemKeySmallJsonG \
5527  ), \
5528  smallArrayt*: _Generic(returnType, \
5529  baset*: cropElemSmallArrayG, \
5530  undefinedt*: cropElemUndefinedSmallArrayG, \
5531  bool: cropElemBoolSmallArrayG, \
5532  double: cropElemDoubleSmallArrayG, \
5533  int64_t: cropElemIntSmallArrayG, \
5534  int32_t: cropElemInt32SmallArrayG, \
5535  uint64_t: cropElemUintSmallArrayG, \
5536  uint32_t: cropElemUint32SmallArrayG, \
5537  char*: cropElemSSmallArrayG, \
5538  smallDictt*: cropElemDictSmallArrayG, \
5539  smallArrayt*: cropElemArraySmallArrayG, \
5540  smallBoolt*: cropElemSmallBoolSmallArrayG, \
5541  smallBytest*: cropElemSmallBytesSmallArrayG, \
5542  smallDoublet*: cropElemSmallDoubleSmallArrayG, \
5543  smallIntt*: cropElemSmallIntSmallArrayG, \
5544  smallJsont*: cropElemSmallJsonSmallArrayG, \
5545  smallStringt*: cropElemSmallStringSmallArrayG, \
5546  void*: cropElemVoidSmallArrayG, \
5547  smallContainert*: cropElemSmallContainerSmallArrayG, \
5548  default: cropElemSmallArrayG), \
5549  smallStringt*: cropElemSmallStringG, \
5550  char *: cropElemS, \
5551  char **: listCropElemS, \
5552  char ***: iListCropElemS \
5553  )(self, index)
5554 
5555 
5556 #define cropSmallJsonO(self, start, end) (self)->f->cropSmallJson(self, start, end)
5557 #define cropElemAtSmallJsonO(self, index) (self)->f->cropElemAtSmallJson(self, index)
5558 #define cropElemKeySmallJsonO(self, key) (self)->f->cropElemKeySmallJson(self, key)
5559 #define cropSmallStringO(self, start, end) (self)->f->cropSmallString(self, start, end)
5560 #define cropElemSmallStringO(self, index) (self)->f->cropElemSmallString(self, index)
5561 
5562 #define copyRngO(self, start, end) (self)->f->copy(self, start, end)
5563 #define copyRngG(self, start, end) _Generic((self), \
5564  char *: sliceS, \
5565  const char *: sliceS, \
5566  char **: iListCopyS, \
5567  smallArrayt *: copySmallArrayG, \
5568  smallJsont *: copySmallJsonG, \
5569  smallStringt *: copySmallStringG \
5570  )(self, start, end)
5571 
5572 #define insertO(self, index, toInsert) (self)->f->insert(self, index, toInsert)
5573 #define insertG(self, index, toInsert) _Generic((self), \
5574  char *: _Generic((toInsert), \
5575  char *: insertS, \
5576  char: injectS, \
5577  int: injectS, \
5578  default: injectS \
5579  ), \
5580  const char *: _Generic((toInsert), \
5581  char *: insertS, \
5582  char: injectS, \
5583  int: injectS, \
5584  default: injectS \
5585  ), \
5586  char **: _Generic((toInsert), \
5587  char *: iInsertS, \
5588  char: iInjectS, \
5589  int: iInjectS, \
5590  default: iInjectS \
5591  ), \
5592  char ***: _Generic((toInsert), \
5593  char **: iListInsertS, \
5594  char *: iListInjectS, \
5595  char: iListInjectCharS, \
5596  int: iListInjectCharS, \
5597  default: iListInjectS \
5598  ), \
5599  smallArrayt*: _Generic((toInsert), \
5600  baset*: injectSmallArrayG, \
5601  bool: injectBoolSmallArrayG, \
5602  double: injectDoubleSmallArrayG, \
5603  int64_t: injectIntSmallArrayG, \
5604  int32_t: injectIntSmallArrayG, \
5605  uint32_t: injectIntSmallArrayG, \
5606  uint64_t: injectIntSmallArrayG, \
5607  char*: injectSSmallArrayG, \
5608  char: injectCharSmallArrayG, \
5609  const char*: injectSSmallArrayG, \
5610  smallDictt*: injectDictSmallArrayG, \
5611  smallArrayt*: insertSmallArrayG, \
5612  char **: injectArraycSmallArrayG, \
5613  const char **: injectCArraycSmallArrayG, \
5614  smallBoolt*: injectSmallBoolSmallArrayG, \
5615  smallBytest*: injectSmallBytesSmallArrayG, \
5616  smallDoublet*: injectSmallDoubleSmallArrayG, \
5617  smallIntt*: injectSmallIntSmallArrayG, \
5618  smallJsont*: insertSmallJsonSmallArrayG, \
5619  smallStringt*: injectSmallStringSmallArrayG, \
5620  smallContainert*: injectSmallContainerSmallArrayG, \
5621  undefinedt*: injectUndefinedSmallArrayG, \
5622  default: injectVoidSmallArrayG \
5623  ), \
5624  smallJsont*: _Generic((toInsert), \
5625  baset*: injectSmallJsonG, \
5626  bool: injectBoolSmallJsonG, \
5627  double: injectDoubleSmallJsonG, \
5628  int64_t: injectIntSmallJsonG, \
5629  int32_t: injectIntSmallJsonG, \
5630  uint32_t: injectIntSmallJsonG, \
5631  uint64_t: injectIntSmallJsonG, \
5632  char*: injectSSmallJsonG, \
5633  char: injectCharSmallJsonG, \
5634  const char*: injectSSmallJsonG, \
5635  smallDictt*: injectDictSmallJsonG, \
5636  smallArrayt*: insertSmallJsonG, \
5637  char **: injectArraycSmallJsonG, \
5638  const char **: injectCArraycSmallJsonG, \
5639  smallBoolt*: injectSmallBoolSmallJsonG, \
5640  smallBytest*: injectSmallBytesSmallJsonG, \
5641  smallDoublet*: injectSmallDoubleSmallJsonG, \
5642  smallIntt*: injectSmallIntSmallJsonG, \
5643  smallJsont*: insertSmallJsonSmallJsonG, \
5644  smallStringt*: injectSmallStringSmallJsonG, \
5645  smallContainert*: injectSmallContainerSmallJsonG, \
5646  undefinedt*: injectUndefinedSmallJsonG, \
5647  default: injectVoidSmallJsonG \
5648  ), \
5649  smallStringt *: _Generic(toInsert, \
5650  char *: insertSSmallStringG, \
5651  const char *: insertSSmallStringG, \
5652  char: injectSmallStringG, \
5653  int: injectSmallStringG, \
5654  smallJsont *: insertSmallJsonSmallStringG, \
5655  smallStringt *: insertSmallStringG, \
5656  default: insertSSmallStringG \
5657  ) \
5658  )(self, index, toInsert)
5659 
5660 #define insertNSmashO(self, index, toInsert) (self)->f->insertNSmash(self, index, toInsert)
5661 #define insertNFreeO insertNSmashO
5662 #define insertNFreeG insertNSmashG
5663 #define insertNSmashG(self, index, toInsert) _Generic((self), \
5664  char *: _Generic((toInsert), \
5665  char *: insertNFreeS, \
5666  char: injectS, \
5667  int: injectS, \
5668  default: injectS \
5669  ), \
5670  const char *: _Generic((toInsert), \
5671  char *: insertNFreeS, \
5672  char: injectS, \
5673  int: injectS, \
5674  default: injectS \
5675  ), \
5676  char **: _Generic((toInsert), \
5677  char *: iInsertNFreeS, \
5678  char: iInjectS, \
5679  int: iInjectS, \
5680  default: iInjectS \
5681  ), \
5682  char ***: _Generic((toInsert), \
5683  char **: iListInsertNFreeS, \
5684  char *: iListInjectS, \
5685  char: iListInjectCharS, \
5686  int: iListInjectCharS, \
5687  default: iListInjectS \
5688  ), \
5689  smallArrayt*: _Generic((toInsert), \
5690  baset*: injectNFreeSmallArrayG, \
5691  bool: injectBoolSmallArrayG, \
5692  double: injectDoubleSmallArrayG, \
5693  int64_t: injectIntSmallArrayG, \
5694  int32_t: injectIntSmallArrayG, \
5695  uint32_t: injectIntSmallArrayG, \
5696  uint64_t: injectIntSmallArrayG, \
5697  char*: injectNFreeSSmallArrayG, \
5698  char: injectCharSmallArrayG, \
5699  smallDictt*: injectNFreeDictSmallArrayG, \
5700  smallArrayt*: insertNSmashSmallArrayG, \
5701  char **: injectNFreeArraycSmallArrayG, \
5702  smallBoolt*: injectNFreeSmallBoolSmallArrayG, \
5703  smallBytest*: injectNFreeSmallBytesSmallArrayG, \
5704  smallDoublet*: injectNFreeSmallDoubleSmallArrayG, \
5705  smallIntt*: injectNFreeSmallIntSmallArrayG, \
5706  smallJsont*: insertNSmashSmallJsonSmallArrayG, \
5707  smallStringt*: injectNFreeSmallStringSmallArrayG, \
5708  smallContainert*: injectNFreeSmallContainerSmallArrayG, \
5709  undefinedt*: injectNFreeUndefinedSmallArrayG, \
5710  default: injectVoidSmallArrayG \
5711  ), \
5712  smallJsont*: _Generic((toInsert), \
5713  baset*: injectNFreeSmallJsonG, \
5714  bool: injectBoolSmallJsonG, \
5715  double: injectDoubleSmallJsonG, \
5716  int64_t: injectIntSmallJsonG, \
5717  int32_t: injectIntSmallJsonG, \
5718  uint32_t: injectIntSmallJsonG, \
5719  uint64_t: injectIntSmallJsonG, \
5720  char*: injectNFreeSSmallJsonG, \
5721  char: injectCharSmallJsonG, \
5722  smallDictt*: injectNFreeDictSmallJsonG, \
5723  smallArrayt*: insertNSmashSmallJsonG, \
5724  char **: injectNFreeArraycSmallJsonG, \
5725  smallBoolt*: injectNFreeSmallBoolSmallJsonG, \
5726  smallBytest*: injectNFreeSmallBytesSmallJsonG, \
5727  smallDoublet*: injectNFreeSmallDoubleSmallJsonG, \
5728  smallIntt*: injectNFreeSmallIntSmallJsonG, \
5729  smallJsont*: insertNSmashSmallJsonSmallJsonG, \
5730  smallStringt*: injectNFreeSmallStringSmallJsonG, \
5731  smallContainert*: injectNFreeSmallContainerSmallJsonG, \
5732  undefinedt*: injectNFreeUndefinedSmallJsonG, \
5733  default: injectVoidSmallJsonG \
5734  ), \
5735  smallStringt *: _Generic(toInsert, \
5736  char *: insertSNFreeSmallStringG, \
5737  char: injectSmallStringG, \
5738  int: injectSmallStringG, \
5739  smallJsont *: insertNFreeSmallJsonSmallStringG, \
5740  smallStringt *: insertNFreeSmallStringG, \
5741  default: insertSNFreeSmallStringG \
5742  ) \
5743  )(self, index, toInsert)
5744 
5745 #define injectG(self, index, value) _Generic((self), \
5746  char *: injectS, \
5747  const char *: injectS, \
5748  char **: iInjectS, \
5749  char ***: _Generic(value, \
5750  char *: iListInjectS, \
5751  char: iListInjectCharS, \
5752  int: iListInjectCharS, \
5753  default: iListInjectS \
5754  ), \
5755  smallArrayt*: _Generic((value), \
5756  baset*: injectSmallArrayG, \
5757  bool: injectBoolSmallArrayG, \
5758  double: injectDoubleSmallArrayG, \
5759  int64_t: injectIntSmallArrayG, \
5760  int32_t: injectIntSmallArrayG, \
5761  uint32_t: injectIntSmallArrayG, \
5762  uint64_t: injectIntSmallArrayG, \
5763  char*: injectSSmallArrayG, \
5764  char: injectCharSmallArrayG, \
5765  const char*: injectSSmallArrayG, \
5766  smallDictt*: injectDictSmallArrayG, \
5767  smallArrayt*: injectArraySmallArrayG, \
5768  char **: injectArraycSmallArrayG, \
5769  const char **: injectCArraycSmallArrayG, \
5770  smallBoolt*: injectSmallBoolSmallArrayG, \
5771  smallBytest*: injectSmallBytesSmallArrayG, \
5772  smallDoublet*: injectSmallDoubleSmallArrayG, \
5773  smallIntt*: injectSmallIntSmallArrayG, \
5774  smallJsont*: injectSmallJsonSmallArrayG, \
5775  smallStringt*: injectSmallStringSmallArrayG, \
5776  smallContainert*: injectSmallContainerSmallArrayG, \
5777  undefinedt*: injectUndefinedSmallArrayG, \
5778  default: injectVoidSmallArrayG), \
5779  smallJsont*: _Generic((value), \
5780  baset*: injectSmallJsonG, \
5781  bool: injectBoolSmallJsonG, \
5782  double: injectDoubleSmallJsonG, \
5783  int64_t: injectIntSmallJsonG, \
5784  int32_t: injectIntSmallJsonG, \
5785  uint32_t: injectIntSmallJsonG, \
5786  uint64_t: injectIntSmallJsonG, \
5787  char*: injectSSmallJsonG, \
5788  char: injectCharSmallJsonG, \
5789  const char*: injectSSmallJsonG, \
5790  smallDictt*: injectDictSmallJsonG, \
5791  smallArrayt*: injectArraySmallJsonG, \
5792  char **: injectArraycSmallJsonG, \
5793  const char **: injectCArraycSmallJsonG, \
5794  smallBoolt*: injectSmallBoolSmallJsonG, \
5795  smallBytest*: injectSmallBytesSmallJsonG, \
5796  smallDoublet*: injectSmallDoubleSmallJsonG, \
5797  smallIntt*: injectSmallIntSmallJsonG, \
5798  smallJsont*: injectSmallJsonSmallJsonG, \
5799  smallStringt*: injectSmallStringSmallJsonG, \
5800  smallContainert*: injectSmallContainerSmallJsonG, \
5801  undefinedt*: injectUndefinedSmallJsonG, \
5802  default: injectVoidSmallJsonG), \
5803  smallStringt *: injectSmallStringG\
5804  )(self, index, value)
5805 
5806 #define injectNFreeG(self, index, value) _Generic((self), \
5807  char *: injectS, \
5808  const char *: injectS, \
5809  char **: iInjectS, \
5810  char ***: iListInjectS, \
5811  smallArrayt*: _Generic((value), \
5812  baset*: injectNFreeSmallArrayG, \
5813  bool: injectBoolSmallArrayG, \
5814  double: injectDoubleSmallArrayG, \
5815  int64_t: injectIntSmallArrayG, \
5816  int32_t: injectIntSmallArrayG, \
5817  uint32_t: injectIntSmallArrayG, \
5818  uint64_t: injectIntSmallArrayG, \
5819  char*: injectNFreeSSmallArrayG, \
5820  char: injectCharSmallArrayG, \
5821  smallDictt*: injectNFreeDictSmallArrayG, \
5822  smallArrayt*: injectNFreeArraySmallArrayG, \
5823  char **: injectNFreeArraycSmallArrayG, \
5824  smallBoolt*: injectNFreeSmallBoolSmallArrayG, \
5825  smallBytest*: injectNFreeSmallBytesSmallArrayG, \
5826  smallDoublet*: injectNFreeSmallDoubleSmallArrayG, \
5827  smallIntt*: injectNFreeSmallIntSmallArrayG, \
5828  smallJsont*: injectNFreeSmallJsonSmallArrayG, \
5829  smallStringt*: injectNFreeSmallStringSmallArrayG, \
5830  smallContainert*: injectNFreeSmallContainerSmallArrayG, \
5831  undefinedt*: injectNFreeUndefinedSmallArrayG, \
5832  default: injectVoidSmallArrayG), \
5833  smallJsont*: _Generic((value), \
5834  baset*: injectNFreeSmallJsonG, \
5835  bool: injectBoolSmallJsonG, \
5836  double: injectDoubleSmallJsonG, \
5837  int64_t: injectIntSmallJsonG, \
5838  int32_t: injectIntSmallJsonG, \
5839  uint32_t: injectIntSmallJsonG, \
5840  uint64_t: injectIntSmallJsonG, \
5841  char*: injectNFreeSSmallJsonG, \
5842  char: injectCharSmallJsonG, \
5843  smallDictt*: injectNFreeDictSmallJsonG, \
5844  smallArrayt*: injectNFreeArraySmallJsonG, \
5845  char **: injectNFreeArraycSmallJsonG, \
5846  smallBoolt*: injectNFreeSmallBoolSmallJsonG, \
5847  smallBytest*: injectNFreeSmallBytesSmallJsonG, \
5848  smallDoublet*: injectNFreeSmallDoubleSmallJsonG, \
5849  smallIntt*: injectNFreeSmallIntSmallJsonG, \
5850  smallJsont*: injectNFreeSmallJsonSmallJsonG, \
5851  smallStringt*: injectNFreeSmallStringSmallJsonG, \
5852  smallContainert*: injectNFreeSmallContainerSmallJsonG, \
5853  undefinedt*: injectNFreeUndefinedSmallJsonG, \
5854  default: injectVoidSmallJsonG), \
5855  smallStringt *: injectSmallStringG\
5856  )(self, index, value)
5857 
5858 #define findO(self, needle) (self)->f->find(self, needle)
5859 #define findG(self, needle) _Generic((self), \
5860  char *: _Generic(needle, \
5861  char *: findS, \
5862  const char *: findS, \
5863  char: findCharS, \
5864  int: findCharS, \
5865  default: findS \
5866  ), \
5867  const char *: _Generic(needle, \
5868  char *: findS, \
5869  const char *: findS, \
5870  char: findCharS, \
5871  int: findCharS, \
5872  default: findS \
5873  ), \
5874  char **: listIndexOfS , \
5875  const char **: listIndexOfCG, \
5876  smallArrayt *: _Generic(needle, \
5877  char *: indexOfSSmallArrayG, \
5878  const char *: indexOfSSmallArrayG, \
5879  char: indexOfCharSmallArrayG, \
5880  int: indexOfCharSmallArrayG, \
5881  smallJsont*: indexOfSmallJsonSmallArrayG, \
5882  smallStringt*: indexOfSmallStringSmallArrayG, \
5883  default: indexOfSSmallArrayG), \
5884  smallJsont *: _Generic(needle, \
5885  char *: findSmallJsonG, \
5886  const char *: findSmallJsonG, \
5887  char: findCharSmallJsonG, \
5888  int: findCharSmallJsonG, \
5889  smallJsont *: findJsonSmallJsonG, \
5890  smallStringt *: findSmallStringSmallJsonG \
5891  ), \
5892  smallStringt *: _Generic(needle, \
5893  char *: findSmallStringG, \
5894  const char *: findSmallStringG, \
5895  char: findCharSmallStringG, \
5896  int: findCharSmallStringG, \
5897  smallJsont *: findSmallJsonSmallStringG, \
5898  smallStringt *: findSmallStringSmallStringG \
5899  ) \
5900  )(self, needle)
5901 
5902 #define hasO(self, key) (self)->f->has(self, key)
5903 #define hasG(self, needle) _Generic((self), \
5904  char *: _Generic(needle, \
5905  char *: hasS, \
5906  const char *: hasS, \
5907  char: hasCharS, \
5908  int: hasCharS, \
5909  default: hasS \
5910  ), \
5911  const char *: _Generic(needle, \
5912  char *: hasS, \
5913  const char *: hasS, \
5914  char: hasCharS, \
5915  int: hasCharS, \
5916  default: hasS \
5917  ), \
5918  char **: _Generic(needle, \
5919  char *: listHasS , \
5920  const char *: listHasS , \
5921  char: listHasCharS, \
5922  int: listHasCharS, \
5923  default: listHasS \
5924  ), \
5925  const char **: _Generic(needle, \
5926  char *: listHasCG , \
5927  const char *: listHasCG , \
5928  char: listHasCharCG, \
5929  int: listHasCharCG, \
5930  default: listHasCG \
5931  ), \
5932  smallArrayt*: _Generic((needle), \
5933  baset*: hasSmallArrayG, \
5934  bool: hasBoolSmallArrayG, \
5935  double: hasDoubleSmallArrayG, \
5936  int64_t: hasIntSmallArrayG, \
5937  int32_t: hasIntSmallArrayG, \
5938  uint32_t: hasIntSmallArrayG, \
5939  uint64_t: hasIntSmallArrayG, \
5940  char*: hasSSmallArrayG, \
5941  char: hasCharSmallArrayG, \
5942  const char*: hasSSmallArrayG, \
5943  smallDictt*: hasDictSmallArrayG, \
5944  smallArrayt*: hasArraySmallArrayG, \
5945  char **: hasArraycSmallArrayG, \
5946  const char **: hasCArraycSmallArrayG, \
5947  smallBoolt*: hasSmallBoolSmallArrayG, \
5948  smallBytest*: hasSmallBytesSmallArrayG, \
5949  smallDoublet*: hasSmallDoubleSmallArrayG, \
5950  smallIntt*: hasSmallIntSmallArrayG, \
5951  smallJsont*: hasSmallJsonSmallArrayG, \
5952  smallStringt*: hasSmallStringSmallArrayG, \
5953  smallContainert*: hasSmallContainerSmallArrayG, \
5954  undefinedt*: hasUndefinedSmallArrayG, \
5955  default: hasUndefinedSmallArrayG), \
5956  smallJsont*: _Generic((needle), \
5957  baset*: hasSmallJsonG, \
5958  bool: hasBoolSmallJsonG, \
5959  double: hasDoubleSmallJsonG, \
5960  int64_t: hasIntSmallJsonG, \
5961  int32_t: hasIntSmallJsonG, \
5962  uint32_t: hasIntSmallJsonG, \
5963  uint64_t: hasIntSmallJsonG, \
5964  char*: hasSSmallJsonG, \
5965  char: hasCharSmallJsonG, \
5966  const char*: hasSSmallJsonG, \
5967  smallDictt*: hasDictSmallJsonG, \
5968  smallArrayt*: hasArraySmallJsonG, \
5969  char **: hasArraycSmallJsonG, \
5970  const char **: hasCArraycSmallJsonG, \
5971  smallBoolt*: hasSmallBoolSmallJsonG, \
5972  smallBytest*: hasSmallBytesSmallJsonG, \
5973  smallDoublet*: hasSmallDoubleSmallJsonG, \
5974  smallIntt*: hasSmallIntSmallJsonG, \
5975  smallJsont*: hasSmallJsonSmallJsonG, \
5976  smallStringt*: hasSmallStringSmallJsonG, \
5977  smallContainert*: hasSmallContainerSmallJsonG, \
5978  undefinedt*: hasUndefinedSmallJsonG, \
5979  default: hasUndefinedSmallJsonG), \
5980  smallDictt *: _Generic(needle, \
5981  char *: hasSmallDictG, \
5982  const char *: hasSmallDictG, \
5983  char: hasKCharSmallDictG, \
5984  int: hasKCharSmallDictG, \
5985  default: hasSmallDictG \
5986  ), \
5987  smallStringt *: _Generic(needle, \
5988  char *: hasSmallStringG, \
5989  const char *: hasSmallStringG, \
5990  char: hasCharSmallStringG, \
5991  int: hasCharSmallStringG, \
5992  smallJsont *: hasSmallJsonSmallStringG, \
5993  smallStringt *: hasSmallStringSmallStringG, \
5994  default: hasSmallStringG \
5995  ) \
5996  )(self, needle)
5997 
5998 #define indexOfO(self, key) (self)->f->indexOf(self, key)
5999 #define indexOfG(self, needle) _Generic((self), \
6000  char *: _Generic(needle, \
6001  char *: indexOfS, \
6002  const char *: indexOfS, \
6003  char: indexOfCharS, \
6004  int: indexOfCharS, \
6005  default: indexOfS \
6006  ), \
6007  const char *: _Generic(needle, \
6008  char *: indexOfS, \
6009  const char *: indexOfS, \
6010  char: indexOfCharS, \
6011  int: indexOfCharS, \
6012  default: indexOfS \
6013  ), \
6014  char **: _Generic(needle, \
6015  char *: listIndexOfS , \
6016  const char *: listIndexOfS , \
6017  char: listIndexOfCharS , \
6018  int: listIndexOfCharS , \
6019  default: listIndexOfS \
6020  ), \
6021  const char **: _Generic(needle, \
6022  char *: listIndexOfCG , \
6023  const char *: listIndexOfCG , \
6024  char: listIndexOfCharCG , \
6025  int: listIndexOfCharCG , \
6026  default: listIndexOfCG \
6027  ), \
6028  smallArrayt*: _Generic((needle), \
6029  baset*: indexOfSmallArrayG, \
6030  bool: indexOfBoolSmallArrayG, \
6031  double: indexOfDoubleSmallArrayG, \
6032  int64_t: indexOfIntSmallArrayG, \
6033  int32_t: indexOfIntSmallArrayG, \
6034  uint32_t: indexOfIntSmallArrayG, \
6035  uint64_t: indexOfIntSmallArrayG, \
6036  char*: indexOfSSmallArrayG, \
6037  char: indexOfCharSmallArrayG, \
6038  const char*: indexOfSSmallArrayG, \
6039  smallDictt*: indexOfDictSmallArrayG, \
6040  smallArrayt*: indexOfArraySmallArrayG, \
6041  char **: indexOfArraycSmallArrayG, \
6042  const char **: indexOfCArraycSmallArrayG, \
6043  smallBoolt*: indexOfSmallBoolSmallArrayG, \
6044  smallBytest*: indexOfSmallBytesSmallArrayG, \
6045  smallDoublet*: indexOfSmallDoubleSmallArrayG, \
6046  smallIntt*: indexOfSmallIntSmallArrayG, \
6047  smallJsont*: indexOfSmallJsonSmallArrayG, \
6048  smallStringt*: indexOfSmallStringSmallArrayG, \
6049  smallContainert*: indexOfSmallContainerSmallArrayG, \
6050  undefinedt*: indexOfUndefinedSmallArrayG, \
6051  default: indexOfUndefinedSmallArrayG \
6052  ), \
6053  smallJsont*: _Generic((needle), \
6054  baset*: indexOfSmallJsonG, \
6055  bool: indexOfBoolSmallJsonG, \
6056  double: indexOfDoubleSmallJsonG, \
6057  int64_t: indexOfIntSmallJsonG, \
6058  int32_t: indexOfIntSmallJsonG, \
6059  uint32_t: indexOfIntSmallJsonG, \
6060  uint64_t: indexOfIntSmallJsonG, \
6061  char*: indexOfSSmallJsonG, \
6062  char: indexOfCharSmallJsonG, \
6063  const char*: indexOfSSmallJsonG, \
6064  smallDictt*: indexOfDictSmallJsonG, \
6065  smallArrayt*: indexOfArraySmallJsonG, \
6066  char **: indexOfArraycSmallJsonG, \
6067  const char **: indexOfCArraycSmallJsonG, \
6068  smallBoolt*: indexOfSmallBoolSmallJsonG, \
6069  smallBytest*: indexOfSmallBytesSmallJsonG, \
6070  smallDoublet*: indexOfSmallDoubleSmallJsonG, \
6071  smallIntt*: indexOfSmallIntSmallJsonG, \
6072  smallJsont*: indexOfSmallJsonSmallJsonG, \
6073  smallStringt*: indexOfSmallStringSmallJsonG, \
6074  smallContainert*: indexOfSmallContainerSmallJsonG, \
6075  undefinedt*: indexOfUndefinedSmallJsonG, \
6076  default: indexOfUndefinedSmallJsonG \
6077  ), \
6078  smallDictt*: _Generic((needle), \
6079  baset*: keyBySmallDictG, \
6080  bool: keyByBoolSmallDictG, \
6081  double: keyByDoubleSmallDictG, \
6082  int64_t: keyByIntSmallDictG, \
6083  int32_t: keyByIntSmallDictG, \
6084  uint32_t: keyByIntSmallDictG, \
6085  uint64_t: keyByIntSmallDictG, \
6086  char*: keyBySSmallDictG, \
6087  char: keyByCharSmallDictG, \
6088  const char*: keyBySSmallDictG, \
6089  smallDictt*: keyByDictSmallDictG, \
6090  smallArrayt*: keyByArraySmallDictG, \
6091  char **: keyByArraycSmallDictG, \
6092  const char **: keyByCArraycSmallDictG, \
6093  smallBoolt*: keyBySmallBoolSmallDictG, \
6094  smallBytest*: keyBySmallBytesSmallDictG, \
6095  smallDoublet*: keyBySmallDoubleSmallDictG, \
6096  smallIntt*: keyBySmallIntSmallDictG, \
6097  smallJsont*: keyBySmallJsonSmallDictG, \
6098  smallStringt*: keyBySmallStringSmallDictG, \
6099  smallContainert*: keyBySmallContainerSmallDictG, \
6100  undefinedt*: keyByUndefinedSmallDictG, \
6101  default: keyByUndefinedSmallDictG \
6102  ), \
6103  smallStringt *: _Generic(needle, \
6104  char *: indexOfSmallStringG, \
6105  const char *: indexOfSmallStringG, \
6106  char: indexOfCharSmallStringG, \
6107  int: indexOfCharSmallStringG, \
6108  smallJsont *: indexOfSmallJsonSmallStringG, \
6109  smallStringt *: indexOfSmallStringSmallStringG, \
6110  default: indexOfSmallStringG \
6111  ) \
6112  )(self, needle)
6113 
6114 #define keyByO(self, value) (self)->f->keyBy(self, value)
6115 #define keyByG(self, needle) _Generic((self), \
6116  char *: _Generic(needle, \
6117  char *: indexOfS, \
6118  const char *: indexOfS, \
6119  char: indexOfCharS, \
6120  int: indexOfCharS, \
6121  default: indexOfS \
6122  ), \
6123  const char *: _Generic(needle, \
6124  char *: indexOfS, \
6125  const char *: indexOfS, \
6126  char: indexOfCharS, \
6127  int: indexOfCharS, \
6128  default: indexOfS \
6129  ), \
6130  char **: _Generic(needle, \
6131  char *: listIndexOfS , \
6132  const char *: listIndexOfS , \
6133  char: listIndexOfCharS , \
6134  int: listIndexOfCharS , \
6135  default: listIndexOfS \
6136  ), \
6137  const char **: _Generic(needle, \
6138  char *: listIndexOfCG , \
6139  const char *: listIndexOfCG , \
6140  char: listIndexOfCharCG , \
6141  int: listIndexOfCharCG , \
6142  default: listIndexOfCG \
6143  ), \
6144  smallArrayt*: _Generic((needle), \
6145  baset*: indexOfSmallArrayG, \
6146  bool: indexOfBoolSmallArrayG, \
6147  double: indexOfDoubleSmallArrayG, \
6148  int64_t: indexOfIntSmallArrayG, \
6149  int32_t: indexOfIntSmallArrayG, \
6150  uint32_t: indexOfIntSmallArrayG, \
6151  uint64_t: indexOfIntSmallArrayG, \
6152  char*: indexOfSSmallArrayG, \
6153  char: indexOfCharSmallArrayG, \
6154  const char*: indexOfSSmallArrayG, \
6155  smallDictt*: indexOfDictSmallArrayG, \
6156  smallArrayt*: indexOfArraySmallArrayG, \
6157  char **: indexOfArraycSmallArrayG, \
6158  const char **: indexOfCArraycSmallArrayG, \
6159  smallBoolt*: indexOfSmallBoolSmallArrayG, \
6160  smallBytest*: indexOfSmallBytesSmallArrayG, \
6161  smallDoublet*: indexOfSmallDoubleSmallArrayG, \
6162  smallIntt*: indexOfSmallIntSmallArrayG, \
6163  smallJsont*: indexOfSmallJsonSmallArrayG, \
6164  smallStringt*: indexOfSmallStringSmallArrayG, \
6165  smallContainert*: indexOfSmallContainerSmallArrayG, \
6166  undefinedt*: indexOfUndefinedSmallArrayG, \
6167  default: indexOfUndefinedSmallArrayG \
6168  ), \
6169  smallDictt*: _Generic((needle), \
6170  baset*: keyBySmallDictG, \
6171  bool: keyByBoolSmallDictG, \
6172  double: keyByDoubleSmallDictG, \
6173  int64_t: keyByIntSmallDictG, \
6174  int32_t: keyByIntSmallDictG, \
6175  uint32_t: keyByIntSmallDictG, \
6176  uint64_t: keyByIntSmallDictG, \
6177  char*: keyBySSmallDictG, \
6178  char: keyByCharSmallDictG, \
6179  const char*: keyBySSmallDictG, \
6180  smallDictt*: keyByDictSmallDictG, \
6181  smallArrayt*: keyByArraySmallDictG, \
6182  char **: keyByArraycSmallDictG, \
6183  const char **: keyByCArraycSmallDictG, \
6184  smallBoolt*: keyBySmallBoolSmallDictG, \
6185  smallBytest*: keyBySmallBytesSmallDictG, \
6186  smallDoublet*: keyBySmallDoubleSmallDictG, \
6187  smallIntt*: keyBySmallIntSmallDictG, \
6188  smallJsont*: keyBySmallJsonSmallDictG, \
6189  smallStringt*: keyBySmallStringSmallDictG, \
6190  smallContainert*: keyBySmallContainerSmallDictG, \
6191  undefinedt*: keyByUndefinedSmallDictG, \
6192  default: keyByUndefinedSmallDictG \
6193  ), \
6194  smallJsont*: _Generic((needle), \
6195  baset*: keyBySmallJsonG, \
6196  bool: keyByBoolSmallJsonG, \
6197  double: keyByDoubleSmallJsonG, \
6198  int64_t: keyByIntSmallJsonG, \
6199  int32_t: keyByIntSmallJsonG, \
6200  uint32_t: keyByIntSmallJsonG, \
6201  uint64_t: keyByIntSmallJsonG, \
6202  char*: keyBySSmallJsonG, \
6203  char: keyByCharSmallJsonG, \
6204  const char*: keyBySSmallJsonG, \
6205  smallDictt*: keyByDictSmallJsonG, \
6206  smallArrayt*: keyByArraySmallJsonG, \
6207  char **: keyByArraycSmallJsonG, \
6208  const char **: keyByCArraycSmallJsonG, \
6209  smallBoolt*: keyBySmallBoolSmallJsonG, \
6210  smallBytest*: keyBySmallBytesSmallJsonG, \
6211  smallDoublet*: keyBySmallDoubleSmallJsonG, \
6212  smallIntt*: keyBySmallIntSmallJsonG, \
6213  smallJsont*: keyBySmallJsonSmallJsonG, \
6214  smallStringt*: keyBySmallStringSmallJsonG, \
6215  smallContainert*: keyBySmallContainerSmallJsonG, \
6216  undefinedt*: keyByUndefinedSmallJsonG, \
6217  default: keyByUndefinedSmallJsonG \
6218  ), \
6219  smallStringt *: _Generic(needle, \
6220  char *: indexOfSmallStringG, \
6221  const char *: indexOfSmallStringG, \
6222  char: indexOfCharSmallStringG, \
6223  int: indexOfCharSmallStringG, \
6224  smallJsont *: indexOfSmallJsonSmallStringG, \
6225  smallStringt *: indexOfSmallStringSmallStringG, \
6226  default: indexOfSmallStringG \
6227  ) \
6228  )(self, needle)
6229 
6230 #define icFindO(self, needle) (self)->f->icFind(self, needle)
6231 #define icFindG(self, needle) _Generic((self), \
6232  char *: _Generic(needle, \
6233  char *: icFindS, \
6234  const char *: icFindS, \
6235  char: icFindCharS, \
6236  int: icFindCharS, \
6237  default: icFindS \
6238  ), \
6239  const char *: _Generic(needle, \
6240  char *: icFindS, \
6241  const char *: icFindS, \
6242  char: icFindCharS, \
6243  int: icFindCharS, \
6244  default: icFindS \
6245  ), \
6246  char **: icListIndexOfS, \
6247  const char **: icListIndexOfCG, \
6248  smallArrayt *: _Generic(needle, \
6249  char *: icIndexOfSSmallArrayG, \
6250  const char *: icIndexOfSSmallArrayG, \
6251  char: icIndexOfCharSmallArrayG, \
6252  int: icIndexOfCharSmallArrayG, \
6253  smallJsont*: icIndexOfSmallJsonSmallArrayG, \
6254  smallStringt*: icIndexOfSmallStringSmallArrayG \
6255  ), \
6256  smallJsont *: _Generic(needle, \
6257  char *: icFindSmallJsonG, \
6258  const char *: icFindSmallJsonG, \
6259  char: icFindCharSmallJsonG, \
6260  int: icFindCharSmallJsonG, \
6261  smallJsont *: icFindJsonSmallJsonG, \
6262  smallStringt *: icFindSmallStringSmallJsonG \
6263  ), \
6264  smallStringt *: _Generic(needle, \
6265  char *: icFindSmallStringG, \
6266  const char *: icFindSmallStringG, \
6267  char: icFindCharSmallStringG, \
6268  int: icFindCharSmallStringG, \
6269  smallJsont *: icFindSmallJsonSmallStringG, \
6270  smallStringt *: icFindSmallStringSmallStringG \
6271  ) \
6272  )(self, needle)
6273 
6274 #define icHasO(self, key) (self)->f->icHas(self, key)
6275 #define icHasG(self, needle) _Generic((self), \
6276  char *: _Generic(needle, \
6277  char *: icHasS, \
6278  const char *: icHasS, \
6279  char: icHasCharS, \
6280  int: icHasCharS, \
6281  default: icHasS \
6282  ), \
6283  const char *: _Generic(needle, \
6284  char *: icHasS, \
6285  const char *: icHasS, \
6286  char: icHasCharS, \
6287  int: icHasCharS, \
6288  default: icHasS \
6289  ), \
6290  char **: _Generic(needle, \
6291  char *: icListHasS , \
6292  const char *: icListHasS , \
6293  char: icListHasCharS, \
6294  int: icListHasCharS, \
6295  default: icListHasS \
6296  ), \
6297  const char **: _Generic(needle, \
6298  char *: icListHasCG , \
6299  const char *: icListHasCG , \
6300  char: icListHasCharCG, \
6301  int: icListHasCharCG, \
6302  default: icListHasCG \
6303  ), \
6304  smallArrayt*: _Generic((needle), \
6305  baset*: icHasSmallArrayG, \
6306  bool: hasBoolSmallArrayG, \
6307  double: hasDoubleSmallArrayG, \
6308  int64_t: hasIntSmallArrayG, \
6309  int32_t: hasIntSmallArrayG, \
6310  uint32_t: hasIntSmallArrayG, \
6311  uint64_t: hasIntSmallArrayG, \
6312  char*: icHasSSmallArrayG, \
6313  char: icHasCharSmallArrayG, \
6314  const char*: icHasSSmallArrayG, \
6315  smallDictt*: icHasDictSmallArrayG, \
6316  smallArrayt*: icHasArraySmallArrayG, \
6317  char **: icHasArraycSmallArrayG, \
6318  const char **: icHasCArraycSmallArrayG, \
6319  smallBoolt*: hasSmallBoolSmallArrayG, \
6320  smallBytest*: hasSmallBytesSmallArrayG, \
6321  smallDoublet*: hasSmallDoubleSmallArrayG, \
6322  smallIntt*: hasSmallIntSmallArrayG, \
6323  smallJsont*: icHasSmallJsonSmallArrayG, \
6324  smallStringt*: icHasSmallStringSmallArrayG, \
6325  smallContainert*: hasSmallContainerSmallArrayG, \
6326  undefinedt*: hasUndefinedSmallArrayG, \
6327  default: hasUndefinedSmallArrayG), \
6328  smallJsont*: _Generic((needle), \
6329  baset*: icHasSmallJsonG, \
6330  bool: hasBoolSmallJsonG, \
6331  double: hasDoubleSmallJsonG, \
6332  int64_t: hasIntSmallJsonG, \
6333  int32_t: hasIntSmallJsonG, \
6334  uint32_t: hasIntSmallJsonG, \
6335  uint64_t: hasIntSmallJsonG, \
6336  char*: icHasSSmallJsonG, \
6337  char: icHasCharSmallJsonG, \
6338  const char*: icHasSSmallJsonG, \
6339  smallDictt*: icHasDictSmallJsonG, \
6340  smallArrayt*: icHasArraySmallJsonG, \
6341  char **: icHasArraycSmallJsonG, \
6342  const char **: icHasCArraycSmallJsonG, \
6343  smallBoolt*: hasSmallBoolSmallJsonG, \
6344  smallBytest*: hasSmallBytesSmallJsonG, \
6345  smallDoublet*: hasSmallDoubleSmallJsonG, \
6346  smallIntt*: hasSmallIntSmallJsonG, \
6347  smallJsont*: hasSmallJsonSmallJsonG, \
6348  smallStringt*: icHasSmallStringSmallJsonG, \
6349  smallContainert*: hasSmallContainerSmallJsonG, \
6350  undefinedt*: hasUndefinedSmallJsonG, \
6351  default: hasUndefinedSmallJsonG), \
6352  smallDictt *: _Generic(needle, \
6353  char *: hasSmallDictG, \
6354  const char *: hasSmallDictG, \
6355  char: hasKCharSmallDictG, \
6356  int: hasKCharSmallDictG, \
6357  default: hasSmallDictG \
6358  ), \
6359  smallStringt *: _Generic(needle, \
6360  char *: icHasSmallStringG, \
6361  const char *: icHasSmallStringG, \
6362  char: icHasCharSmallStringG, \
6363  int: icHasCharSmallStringG, \
6364  smallJsont *: icHasSmallJsonSmallStringG, \
6365  smallStringt *: icHasSmallStringSmallStringG, \
6366  default: icHasSmallStringG \
6367  ) \
6368  )(self, needle)
6369 
6370 #define icIndexOfO(self, key) (self)->f->icIndexOf(self, key)
6371 #define icIndexOfG(self, needle) _Generic((self), \
6372  char *: _Generic(needle, \
6373  char *: icIndexOfS, \
6374  const char *: icIndexOfS, \
6375  char: icIndexOfCharS, \
6376  int: icIndexOfCharS, \
6377  default: icIndexOfS \
6378  ), \
6379  const char *: _Generic(needle, \
6380  char *: icIndexOfS, \
6381  const char *: icIndexOfS, \
6382  char: icIndexOfCharS, \
6383  int: icIndexOfCharS, \
6384  default: icIndexOfS \
6385  ), \
6386  char **: _Generic(needle, \
6387  char *: icListIndexOfS , \
6388  const char *: icListIndexOfS , \
6389  char: icListIndexOfCharS , \
6390  int: icListIndexOfCharS , \
6391  default: icListIndexOfS \
6392  ), \
6393  const char **: _Generic(needle, \
6394  char *: icListIndexOfCG , \
6395  const char *: icListIndexOfCG , \
6396  char: icListIndexOfCharCG , \
6397  int: icListIndexOfCharCG , \
6398  default: icListIndexOfCG \
6399  ), \
6400  smallArrayt*: _Generic((needle), \
6401  baset*: icIndexOfSmallArrayG, \
6402  bool: indexOfBoolSmallArrayG, \
6403  double: indexOfDoubleSmallArrayG, \
6404  int64_t: indexOfIntSmallArrayG, \
6405  int32_t: indexOfIntSmallArrayG, \
6406  uint32_t: indexOfIntSmallArrayG, \
6407  uint64_t: indexOfIntSmallArrayG, \
6408  char*: icIndexOfSSmallArrayG, \
6409  char: icIndexOfCharSmallArrayG, \
6410  const char*: icIndexOfSSmallArrayG, \
6411  smallDictt*: icIndexOfDictSmallArrayG, \
6412  smallArrayt*: icIndexOfArraySmallArrayG, \
6413  char **: icIndexOfArraycSmallArrayG, \
6414  const char **: icIndexOfCArraycSmallArrayG, \
6415  smallBoolt*: indexOfSmallBoolSmallArrayG, \
6416  smallBytest*: indexOfSmallBytesSmallArrayG, \
6417  smallDoublet*: indexOfSmallDoubleSmallArrayG, \
6418  smallIntt*: indexOfSmallIntSmallArrayG, \
6419  smallJsont*: icIndexOfSmallJsonSmallArrayG, \
6420  smallStringt*: icIndexOfSmallStringSmallArrayG, \
6421  smallContainert*: indexOfSmallContainerSmallArrayG, \
6422  undefinedt*: indexOfUndefinedSmallArrayG, \
6423  default: indexOfUndefinedSmallArrayG \
6424  ), \
6425  smallJsont*: _Generic((needle), \
6426  baset*: icIndexOfSmallJsonG, \
6427  bool: indexOfBoolSmallJsonG, \
6428  double: indexOfDoubleSmallJsonG, \
6429  int64_t: indexOfIntSmallJsonG, \
6430  int32_t: indexOfIntSmallJsonG, \
6431  uint32_t: indexOfIntSmallJsonG, \
6432  uint64_t: indexOfIntSmallJsonG, \
6433  char*: icIndexOfSSmallJsonG, \
6434  char: icIndexOfCharSmallJsonG, \
6435  const char*: icIndexOfSSmallJsonG, \
6436  smallDictt*: icIndexOfDictSmallJsonG, \
6437  smallArrayt*: icIndexOfArraySmallJsonG, \
6438  char **: icIndexOfArraycSmallJsonG, \
6439  const char **: icIndexOfCArraycSmallJsonG, \
6440  smallBoolt*: indexOfSmallBoolSmallJsonG, \
6441  smallBytest*: indexOfSmallBytesSmallJsonG, \
6442  smallDoublet*: indexOfSmallDoubleSmallJsonG, \
6443  smallIntt*: indexOfSmallIntSmallJsonG, \
6444  smallJsont*: indexOfSmallJsonSmallJsonG, \
6445  smallStringt*: icIndexOfSmallStringSmallJsonG, \
6446  smallContainert*: indexOfSmallContainerSmallJsonG, \
6447  undefinedt*: indexOfUndefinedSmallJsonG, \
6448  default: indexOfUndefinedSmallJsonG \
6449  ), \
6450  smallDictt*: _Generic((needle), \
6451  baset*: icKeyBySmallDictG, \
6452  bool: keyByBoolSmallDictG, \
6453  double: keyByDoubleSmallDictG, \
6454  int64_t: keyByIntSmallDictG, \
6455  int32_t: keyByIntSmallDictG, \
6456  uint32_t: keyByIntSmallDictG, \
6457  uint64_t: keyByIntSmallDictG, \
6458  char*: icKeyBySSmallDictG, \
6459  char: icKeyByCharSmallDictG, \
6460  const char*: icKeyBySSmallDictG, \
6461  smallDictt*: icKeyByDictSmallDictG, \
6462  smallArrayt*: icKeyByArraySmallDictG, \
6463  char **: icKeyByArraycSmallDictG, \
6464  const char **: icKeyByCArraycSmallDictG, \
6465  smallBoolt*: keyBySmallBoolSmallDictG, \
6466  smallBytest*: keyBySmallBytesSmallDictG, \
6467  smallDoublet*: keyBySmallDoubleSmallDictG, \
6468  smallIntt*: keyBySmallIntSmallDictG, \
6469  smallJsont*: icKeyBySmallJsonSmallDictG, \
6470  smallStringt*: icKeyBySmallStringSmallDictG, \
6471  smallContainert*: keyBySmallContainerSmallDictG, \
6472  undefinedt*: keyByUndefinedSmallDictG, \
6473  default: keyByUndefinedSmallDictG \
6474  ), \
6475  smallStringt *: _Generic(needle, \
6476  char *: icIndexOfSmallStringG, \
6477  const char *: icIndexOfSmallStringG, \
6478  char: icIndexOfCharSmallStringG, \
6479  int: icIndexOfCharSmallStringG, \
6480  smallJsont *: icIndexOfSmallJsonSmallStringG, \
6481  smallStringt *: icIndexOfSmallStringSmallStringG, \
6482  default: icIndexOfSmallStringG \
6483  ) \
6484  )(self, needle)
6485 
6486 #define icKeyByO(self, value) (self)->f->icKeyBy(self, value)
6487 #define icKeyByG(self, needle) _Generic((self), \
6488  char *: _Generic(needle, \
6489  char *: icIndexOfS, \
6490  const char *: icIndexOfS, \
6491  char: icIndexOfCharS, \
6492  int: icIndexOfCharS, \
6493  default: icIndexOfS \
6494  ), \
6495  const char *: _Generic(needle, \
6496  char *: icIndexOfS, \
6497  const char *: icIndexOfS, \
6498  char: icIndexOfCharS, \
6499  int: icIndexOfCharS, \
6500  default: icIndexOfS \
6501  ), \
6502  char **: _Generic(needle, \
6503  char *: icListIndexOfS , \
6504  const char *: icListIndexOfS , \
6505  char: icListIndexOfCharS , \
6506  int: icListIndexOfCharS , \
6507  default: icListIndexOfS \
6508  ), \
6509  const char **: _Generic(needle, \
6510  char *: icListIndexOfCG , \
6511  const char *: icListIndexOfCG , \
6512  char: icListIndexOfCharCG , \
6513  int: icListIndexOfCharCG , \
6514  default: icListIndexOfCG \
6515  ), \
6516  smallArrayt*: _Generic((needle), \
6517  baset*: icIndexOfSmallArrayG, \
6518  bool: indexOfBoolSmallArrayG, \
6519  double: indexOfDoubleSmallArrayG, \
6520  int64_t: indexOfIntSmallArrayG, \
6521  int32_t: indexOfIntSmallArrayG, \
6522  uint32_t: indexOfIntSmallArrayG, \
6523  uint64_t: indexOfIntSmallArrayG, \
6524  char*: icIndexOfSSmallArrayG, \
6525  char: icIndexOfCharSmallArrayG, \
6526  const char*: icIndexOfSSmallArrayG, \
6527  smallDictt*: icIndexOfDictSmallArrayG, \
6528  smallArrayt*: icIndexOfArraySmallArrayG, \
6529  char **: icIndexOfArraycSmallArrayG, \
6530  const char **: icIndexOfCArraycSmallArrayG, \
6531  smallBoolt*: indexOfSmallBoolSmallArrayG, \
6532  smallBytest*: indexOfSmallBytesSmallArrayG, \
6533  smallDoublet*: indexOfSmallDoubleSmallArrayG, \
6534  smallIntt*: indexOfSmallIntSmallArrayG, \
6535  smallJsont*: icIndexOfSmallJsonSmallArrayG, \
6536  smallStringt*: icIndexOfSmallStringSmallArrayG, \
6537  smallContainert*: indexOfSmallContainerSmallArrayG, \
6538  undefinedt*: indexOfUndefinedSmallArrayG, \
6539  default: indexOfUndefinedSmallArrayG \
6540  ), \
6541  smallDictt*: _Generic((needle), \
6542  baset*: icKeyBySmallDictG, \
6543  bool: keyByBoolSmallDictG, \
6544  double: keyByDoubleSmallDictG, \
6545  int64_t: keyByIntSmallDictG, \
6546  int32_t: keyByIntSmallDictG, \
6547  uint32_t: keyByIntSmallDictG, \
6548  uint64_t: keyByIntSmallDictG, \
6549  char*: icKeyBySSmallDictG, \
6550  char: icKeyByCharSmallDictG, \
6551  const char*: icKeyBySSmallDictG, \
6552  smallDictt*: icKeyByDictSmallDictG, \
6553  smallArrayt*: icKeyByArraySmallDictG, \
6554  char **: icKeyByArraycSmallDictG, \
6555  const char **: icKeyByCArraycSmallDictG, \
6556  smallBoolt*: keyBySmallBoolSmallDictG, \
6557  smallBytest*: keyBySmallBytesSmallDictG, \
6558  smallDoublet*: keyBySmallDoubleSmallDictG, \
6559  smallIntt*: keyBySmallIntSmallDictG, \
6560  smallJsont*: icKeyBySmallJsonSmallDictG, \
6561  smallStringt*: icKeyBySmallStringSmallDictG, \
6562  smallContainert*: keyBySmallContainerSmallDictG, \
6563  undefinedt*: keyByUndefinedSmallDictG, \
6564  default: keyByUndefinedSmallDictG \
6565  ), \
6566  smallJsont*: _Generic((needle), \
6567  baset*: icKeyBySmallJsonG, \
6568  bool: keyByBoolSmallJsonG, \
6569  double: keyByDoubleSmallJsonG, \
6570  int64_t: keyByIntSmallJsonG, \
6571  int32_t: keyByIntSmallJsonG, \
6572  uint32_t: keyByIntSmallJsonG, \
6573  uint64_t: keyByIntSmallJsonG, \
6574  char*: icKeyBySSmallJsonG, \
6575  char: icKeyByCharSmallJsonG, \
6576  const char*: icKeyBySSmallJsonG, \
6577  smallDictt*: icKeyByDictSmallJsonG, \
6578  smallArrayt*: icKeyByArraySmallJsonG, \
6579  char **: icKeyByArraycSmallJsonG, \
6580  const char **: icKeyByCArraycSmallJsonG, \
6581  smallBoolt*: keyBySmallBoolSmallJsonG, \
6582  smallBytest*: keyBySmallBytesSmallJsonG, \
6583  smallDoublet*: keyBySmallDoubleSmallJsonG, \
6584  smallIntt*: keyBySmallIntSmallJsonG, \
6585  smallJsont*: keyBySmallJsonSmallJsonG, \
6586  smallStringt*: icKeyBySmallStringSmallJsonG, \
6587  smallContainert*: keyBySmallContainerSmallJsonG, \
6588  undefinedt*: keyByUndefinedSmallJsonG, \
6589  default: keyByUndefinedSmallJsonG \
6590  ), \
6591  smallStringt *: _Generic(needle, \
6592  char *: icIndexOfSmallStringG, \
6593  const char *: icIndexOfSmallStringG, \
6594  char: icIndexOfCharSmallStringG, \
6595  int: icIndexOfCharSmallStringG, \
6596  smallJsont *: icIndexOfSmallJsonSmallStringG, \
6597  smallStringt *: icIndexOfSmallStringSmallStringG, \
6598  default: icIndexOfSmallStringG \
6599  ) \
6600  )(self, needle)
6601 
6602 #define emptyO(self) (self)->f->empty(self)
6603 #define emptyG(self) _Generic((self), \
6604  char **: iEmptySF, \
6605  char ***: iListEmptySF, \
6606  smallArrayt *: emptySmallArrayG, \
6607  smallDictt *: emptySmallDictG, \
6608  smallJsont *: emptySmallJsonG, \
6609  smallStringt *: emptySmallStringG \
6610  )(self)
6611 
6612 #define isEmptyO(self) (self)->f->isEmpty(self)
6613 #define isEmptyG(self) _Generic((self), \
6614  char *: isEmptyS, \
6615  const char *: isEmptyS, \
6616  char **: listIsEmptyS, \
6617  smallArrayt *: isEmptySmallArrayG, \
6618  smallBytest *: isEmptySmallBytesG, \
6619  smallDictt *: isEmptySmallDictG, \
6620  smallJsont *: isEmptySmallJsonG, \
6621  smallStringt *: isEmptySmallStringG \
6622  )(self)
6623 
6624 #define isBlankO(self) (self)->f->isBlank(self)
6625 #define isBlankG(self) _Generic((self), \
6626  char *: isBlankS, \
6627  const char *: isBlankS, \
6628  char **: listIsBlankS, \
6629  smallArrayt *: isBlankSmallArrayG, \
6630  smallDictt *: isEmptySmallDictG, \
6631  smallJsont *: isBlankSmallJsonG, \
6632  smallStringt *: isBlankSmallStringG \
6633  )(self)
6634 
6635 #define fromArrayO(self, array, size) (self)->f->fromArray(self, array, size)
6636 #define fromArrayG(self, array, size) _Generic((self), \
6637  char **: _Generic(array, \
6638  char **: listFromArrayG, \
6639  const char **: listFromCArrayG \
6640  ), \
6641  smallArrayt *: _Generic(array, \
6642  char **: fromArraySmallArrayG, \
6643  const char **: fromCArraySmallArrayG), \
6644  smallJsont *: _Generic(array, \
6645  char **: fromArraySmallJsonG, \
6646  const char **: fromCArraySmallJsonG) \
6647  )(self, array, size)
6648 
6649 #define splitO(self, delim) (self)->f->split(self, delim)
6650 #define splitG(self, delim) _Generic((self), \
6651  char *: _Generic(delim, \
6652  char *: split, \
6653  const char *: split, \
6654  char: splitChar, \
6655  int: splitChar, \
6656  default: split \
6657  ), \
6658  const char *: _Generic(delim, \
6659  char *: split, \
6660  const char *: split, \
6661  char: splitChar, \
6662  int: splitChar, \
6663  default: split \
6664  ), \
6665  smallJsont *: _Generic(delim, \
6666  char *: splitSmallJsonG, \
6667  const char *: splitSmallJsonG, \
6668  char: splitCharSmallJsonG, \
6669  int: splitCharSmallJsonG, \
6670  smallJsont *: splitSmallJsonSmallJsonG, \
6671  smallStringt *: splitSmallStringSmallJsonG, \
6672  default: splitSmallJsonG \
6673  ), \
6674  smallStringt *: _Generic(delim, \
6675  char *: splitSmallStringG, \
6676  const char *: splitSmallStringG, \
6677  char: splitCharSmallStringG, \
6678  int: splitCharSmallStringG, \
6679  smallJsont *: splitSmallJsonSmallStringG, \
6680  smallStringt *: splitSmallStringSmallStringG, \
6681  default: splitSmallStringG \
6682  ), \
6683  btt: _Generic(delim, \
6684  char*: splitCharB, \
6685  const char*: splitCharB, \
6686  btt: splitB, \
6687  const btt: splitB, \
6688  btt*: splitDPB, \
6689  const btt*: splitDPB, \
6690  default: splitB), \
6691  const btt: _Generic(delim, \
6692  char*: splitCharB, \
6693  const char*: splitCharB, \
6694  btt: splitB, \
6695  const btt: splitB, \
6696  btt*: splitDPB, \
6697  const btt*: splitDPB, \
6698  default: splitB), \
6699  btt*: _Generic(delim, \
6700  char*: splitPCharB, \
6701  const char*: splitPCharB, \
6702  btt: splitPB, \
6703  const btt: splitPB, \
6704  btt*: splitPDPB, \
6705  const btt*: splitPDPB, \
6706  default: splitPB),\
6707  const btt*: _Generic(delim, \
6708  char*: splitPCharB, \
6709  const char*: splitPCharB, \
6710  btt: splitPB, \
6711  const btt: splitPB, \
6712  btt*: splitPDPB, \
6713  const btt*: splitPDPB, \
6714  default: splitPB)\
6715  )(self, delim)
6716 
6717 //TODO create splitS generic
6718 
6719 #define icSplitO(self, delim) (self)->f->icSplit(self, delim)
6720 #define icSplitG(self, delim) _Generic((self), \
6721  char *: _Generic(delim, \
6722  char *: icSplit, \
6723  const char *: icSplit, \
6724  char: icSplitChar, \
6725  int: icSplitChar, \
6726  default: icSplit \
6727  ), \
6728  const char *: _Generic(delim, \
6729  char *: icSplit, \
6730  const char *: icSplit, \
6731  char: icSplitChar, \
6732  int: icSplitChar, \
6733  default: icSplit \
6734  ), \
6735  smallJsont *: _Generic(delim, \
6736  char *: icSplitSmallJsonG, \
6737  const char *: icSplitSmallJsonG, \
6738  char: icSplitCharSmallJsonG, \
6739  int: icSplitCharSmallJsonG, \
6740  smallJsont *: icSplitSmallJsonSmallJsonG, \
6741  smallStringt *: icSplitSmallStringSmallJsonG \
6742  ), \
6743  smallStringt *: _Generic(delim, \
6744  char *: icSplitSmallStringG, \
6745  const char *: icSplitSmallStringG, \
6746  char: icSplitCharSmallStringG, \
6747  int: icSplitCharSmallStringG, \
6748  smallJsont *: icSplitSmallJsonSmallStringG, \
6749  smallStringt *: icSplitSmallStringSmallStringG \
6750  ) \
6751  )(self, delim)
6752 
6753 #define joinO(self, delim) (self)->f->join(self, delim)
6754 #define joinG(self, delim) _Generic((self), \
6755  char **: _Generic(delim, \
6756  char *: join, \
6757  const char *: join, \
6758  char: joinChar, \
6759  int: joinChar, \
6760  default: join \
6761  ), \
6762  const char **: _Generic(delim, \
6763  char *: joinCG, \
6764  const char *: joinCG, \
6765  char: joinCharCG, \
6766  int: joinCharCG, \
6767  default: joinCG \
6768  ), \
6769  smallArrayt *: _Generic(delim, \
6770  char *: joinSmallArrayG, \
6771  const char*: joinSmallArrayG, \
6772  char: joinCharSmallArrayG, \
6773  int: joinCharSmallArrayG, \
6774  smallJsont *: joinSmallJsonSmallArrayG, \
6775  smallStringt *: joinSmallStringSmallArrayG \
6776  ), \
6777  smallJsont *: _Generic(delim, \
6778  char *: joinSmallJsonG, \
6779  const char*: joinSmallJsonG, \
6780  char: joinCharSmallJsonG, \
6781  int: joinCharSmallJsonG, \
6782  smallJsont *: joinSmallJsonSmallJsonG, \
6783  smallStringt *: joinSmallStringSmallJsonG \
6784  ) \
6785  )(self, delim)
6786 
6787 #define joinSO(self, delim) (self)->f->join(self, delim)
6788 #define joinSG(self, delim) _Generic((self), \
6789  char **: _Generic(delim, \
6790  char *: join, \
6791  const char *: join, \
6792  char: joinChar, \
6793  int: joinChar, \
6794  default: join \
6795  ), \
6796  const char **: _Generic(delim, \
6797  char *: joinCG, \
6798  const char *: joinCG, \
6799  char: joinCharCG, \
6800  int: joinCharCG, \
6801  default: joinCG \
6802  ), \
6803  smallArrayt *: _Generic(delim, \
6804  char *: joinSSmallArrayG, \
6805  const char*: joinSSmallArrayG, \
6806  char: joinCharSSmallArrayG, \
6807  int: joinCharSSmallArrayG, \
6808  smallJsont *: joinSmallJsonSSmallArrayG, \
6809  smallStringt *: joinSmallStringSSmallArrayG \
6810  ), \
6811  smallJsont *: _Generic(delim, \
6812  char *: joinSSmallJsonG, \
6813  const char*: joinSSmallJsonG, \
6814  char: joinCharSSmallJsonG, \
6815  int: joinCharSSmallJsonG, \
6816  smallJsont *: joinSmallJsonSSmallJsonG, \
6817  smallStringt *: joinSmallStringSSmallJsonG \
6818  ) \
6819  )(self, delim)
6820 
6821 #define extractO(self, delim1, delim2) (self)->f->extract(self, delim1, delim2)
6822 #define extractG(self, delim1, delim2) _Generic((self), \
6823  char *: _Generic(delim1, \
6824  char *: _Generic(delim2, \
6825  char *: extractS , \
6826  const char *: extractS , \
6827  char: extractSCharS , \
6828  int: extractSCharS, \
6829  default: extractS \
6830  ), \
6831  const char *: _Generic(delim2, \
6832  char *: extractS , \
6833  const char *: extractS , \
6834  char: extractSCharS , \
6835  int: extractSCharS, \
6836  default: extractS \
6837  ), \
6838  char: _Generic(delim2, \
6839  char *: extractCharSS , \
6840  const char *: extractCharSS , \
6841  char: extractCharCharS , \
6842  int: extractCharCharS, \
6843  default: extractCharSS \
6844  ), \
6845  int: _Generic(delim2, \
6846  char *: extractCharSS , \
6847  const char *: extractCharSS , \
6848  char: extractCharCharS , \
6849  int: extractCharCharS, \
6850  default: extractCharSS \
6851  ), \
6852  default: extractS \
6853  ), \
6854  const char *: _Generic(delim1, \
6855  char *: _Generic(delim2, \
6856  char *: extractS , \
6857  const char *: extractS , \
6858  char: extractSCharS , \
6859  int: extractSCharS, \
6860  default: extractS \
6861  ), \
6862  const char *: _Generic(delim2, \
6863  char *: extractS , \
6864  const char *: extractS , \
6865  char: extractSCharS , \
6866  int: extractSCharS, \
6867  default: extractS \
6868  ), \
6869  char: _Generic(delim2, \
6870  char *: extractCharSS , \
6871  const char *: extractCharSS , \
6872  char: extractCharCharS , \
6873  int: extractCharCharS, \
6874  default: extractCharSS \
6875  ), \
6876  int: _Generic(delim2, \
6877  char *: extractCharSS , \
6878  const char *: extractCharSS , \
6879  char: extractCharCharS , \
6880  int: extractCharCharS, \
6881  default: extractCharSS \
6882  ), \
6883  default: extractS \
6884  ), \
6885  smallJsont *: _Generic(delim1, \
6886  char *: _Generic(delim2, \
6887  char *: extractSmallJsonG, \
6888  const char *: extractSmallJsonG, \
6889  char: extractSCharSmallJsonG, \
6890  int: extractSCharSmallJsonG, \
6891  smallJsont *: extractSSmallJsonSmallJsonG, \
6892  smallStringt *: extractSSmallStringSmallJsonG \
6893  ), \
6894  const char *: _Generic(delim2, \
6895  char *: extractSmallJsonG, \
6896  const char *: extractSmallJsonG, \
6897  char: extractSCharSmallJsonG, \
6898  int: extractSCharSmallJsonG, \
6899  smallJsont *: extractSSmallJsonSmallJsonG, \
6900  smallStringt *: extractSSmallStringSmallJsonG \
6901  ),\
6902  char: _Generic(delim2, \
6903  char *: extractCharSSmallJsonG, \
6904  const char *: extractCharSSmallJsonG, \
6905  char: extractCharCharSmallJsonG, \
6906  int: extractCharCharSmallJsonG, \
6907  smallJsont *: extractCharSmallJsonSmallJsonG, \
6908  smallStringt *: extractCharSmallStringSmallJsonG \
6909  ),\
6910  int: _Generic(delim2, \
6911  char *: extractCharSSmallJsonG, \
6912  const char *: extractCharSSmallJsonG, \
6913  char: extractCharCharSmallJsonG, \
6914  int: extractCharCharSmallJsonG, \
6915  smallJsont *: extractCharSmallJsonSmallJsonG, \
6916  smallStringt *: extractCharSmallStringSmallJsonG \
6917  ),\
6918  smallJsont *: _Generic(delim2, \
6919  char *: extractSmallJsonSSmallJsonG, \
6920  const char *: extractSmallJsonSSmallJsonG, \
6921  char: extractSmallJsonCharSmallJsonG, \
6922  int: extractSmallJsonCharSmallJsonG, \
6923  smallJsont *: extractSmallJsonSmallJsonSmallJsonG, \
6924  smallStringt *: extractSmallJsonSmallStringSmallJsonG \
6925  ),\
6926  smallStringt *: _Generic(delim2, \
6927  char *: extractSmallStringSSmallJsonG, \
6928  const char *: extractSmallStringSSmallJsonG, \
6929  char: extractSmallStringCharSmallJsonG, \
6930  int: extractSmallStringCharSmallJsonG, \
6931  smallJsont *: extractSmallStringSmallJsonSmallJsonG, \
6932  smallStringt *: extractSmallStringSmallStringSmallJsonG \
6933  )\
6934  ), \
6935  smallStringt *: _Generic(delim1, \
6936  char *: _Generic(delim2, \
6937  char *: extractSmallStringG, \
6938  const char *: extractSmallStringG, \
6939  char: extractSCharSmallStringG, \
6940  int: extractSCharSmallStringG, \
6941  smallJsont *: extractSSmallJsonSmallStringG, \
6942  smallStringt *: extractSSmallStringSmallStringG \
6943  ), \
6944  const char *: _Generic(delim2, \
6945  char *: extractSmallStringG, \
6946  const char *: extractSmallStringG, \
6947  char: extractSCharSmallStringG, \
6948  int: extractSCharSmallStringG, \
6949  smallJsont *: extractSSmallJsonSmallStringG, \
6950  smallStringt *: extractSSmallStringSmallStringG \
6951  ),\
6952  char: _Generic(delim2, \
6953  char *: extractCharSSmallStringG, \
6954  const char *: extractCharSSmallStringG, \
6955  char: extractCharCharSmallStringG, \
6956  int: extractCharCharSmallStringG, \
6957  smallJsont *: extractCharSmallJsonSmallStringG, \
6958  smallStringt *: extractCharSmallStringSmallStringG \
6959  ),\
6960  int: _Generic(delim2, \
6961  char *: extractCharSSmallStringG, \
6962  const char *: extractCharSSmallStringG, \
6963  char: extractCharCharSmallStringG, \
6964  int: extractCharCharSmallStringG, \
6965  smallJsont *: extractCharSmallJsonSmallStringG, \
6966  smallStringt *: extractCharSmallStringSmallStringG \
6967  ),\
6968  smallJsont *: _Generic(delim2, \
6969  char *: extractSmallJsonSSmallStringG, \
6970  const char *: extractSmallJsonSSmallStringG, \
6971  char: extractSmallJsonCharSmallStringG, \
6972  int: extractSmallJsonCharSmallStringG, \
6973  smallJsont *: extractSmallJsonSmallJsonSmallStringG, \
6974  smallStringt *: extractSmallJsonSmallStringSmallStringG \
6975  ),\
6976  smallStringt *: _Generic(delim2, \
6977  char *: extractSmallStringSSmallStringG, \
6978  const char *: extractSmallStringSSmallStringG, \
6979  char: extractSmallStringCharSmallStringG, \
6980  int: extractSmallStringCharSmallStringG, \
6981  smallJsont *: extractSmallStringSmallJsonSmallStringG, \
6982  smallStringt *: extractSmallStringSmallStringSmallStringG \
6983  )\
6984  ) \
6985  )(self, delim1, delim2)
6986 
6987 #define icExtractO(self, delim1, delim2) (self)->f->icExtract(self, delim1, delim2)
6988 #define icExtractG(self, delim1, delim2) _Generic((self), \
6989  char *: _Generic(delim1, \
6990  char *: _Generic(delim2, \
6991  char *: icExtractS , \
6992  const char *: icExtractS , \
6993  char: icExtractSCharS , \
6994  int: icExtractSCharS, \
6995  default: icExtractS \
6996  ), \
6997  const char *: _Generic(delim2, \
6998  char *: icExtractS , \
6999  const char *: icExtractS , \
7000  char: icExtractSCharS , \
7001  int: icExtractSCharS, \
7002  default: icExtractS \
7003  ), \
7004  char: _Generic(delim2, \
7005  char *: icExtractCharSS , \
7006  const char *: icExtractCharSS , \
7007  char: icExtractCharCharS , \
7008  int: icExtractCharCharS, \
7009  default: icExtractCharSS \
7010  ), \
7011  int: _Generic(delim2, \
7012  char *: icExtractCharSS , \
7013  const char *: icExtractCharSS , \
7014  char: icExtractCharCharS , \
7015  int: icExtractCharCharS, \
7016  default: icExtractCharSS \
7017  ), \
7018  default: icExtractS \
7019  ), \
7020  const char *: _Generic(delim1, \
7021  char *: _Generic(delim2, \
7022  char *: icExtractS , \
7023  const char *: icExtractS , \
7024  char: icExtractSCharS , \
7025  int: icExtractSCharS, \
7026  default: icExtractS \
7027  ), \
7028  const char *: _Generic(delim2, \
7029  char *: icExtractS , \
7030  const char *: icExtractS , \
7031  char: icExtractSCharS , \
7032  int: icExtractSCharS, \
7033  default: icExtractS \
7034  ), \
7035  char: _Generic(delim2, \
7036  char *: icExtractCharSS , \
7037  const char *: icExtractCharSS , \
7038  char: icExtractCharCharS , \
7039  int: icExtractCharCharS, \
7040  default: icExtractCharSS \
7041  ), \
7042  int: _Generic(delim2, \
7043  char *: icExtractCharSS , \
7044  const char *: icExtractCharSS , \
7045  char: icExtractCharCharS , \
7046  int: icExtractCharCharS, \
7047  default: icExtractCharSS \
7048  ), \
7049  default: icExtractS \
7050  ), \
7051  smallJsont *: _Generic(delim1, \
7052  char *: _Generic(delim2, \
7053  char *: icExtractSmallJsonG, \
7054  const char *: icExtractSmallJsonG, \
7055  char: icExtractSCharSmallJsonG, \
7056  int: icExtractSCharSmallJsonG, \
7057  smallJsont *: icExtractSSmallJsonSmallJsonG, \
7058  smallStringt *: icExtractSSmallStringSmallJsonG \
7059  ), \
7060  const char *: _Generic(delim2, \
7061  char *: icExtractSmallJsonG, \
7062  const char *: icExtractSmallJsonG, \
7063  char: icExtractSCharSmallJsonG, \
7064  int: icExtractSCharSmallJsonG, \
7065  smallJsont *: icExtractSSmallJsonSmallJsonG, \
7066  smallStringt *: icExtractSSmallStringSmallJsonG \
7067  ),\
7068  char: _Generic(delim2, \
7069  char *: icExtractCharSSmallJsonG, \
7070  const char *: icExtractCharSSmallJsonG, \
7071  char: icExtractCharCharSmallJsonG, \
7072  int: icExtractCharCharSmallJsonG, \
7073  smallJsont *: icExtractCharSmallJsonSmallJsonG, \
7074  smallStringt *: icExtractCharSmallStringSmallJsonG \
7075  ),\
7076  int: _Generic(delim2, \
7077  char *: icExtractCharSSmallJsonG, \
7078  const char *: icExtractCharSSmallJsonG, \
7079  char: icExtractCharCharSmallJsonG, \
7080  int: icExtractCharCharSmallJsonG, \
7081  smallJsont *: icExtractCharSmallJsonSmallJsonG, \
7082  smallStringt *: icExtractCharSmallStringSmallJsonG \
7083  ),\
7084  smallJsont *: _Generic(delim2, \
7085  char *: icExtractSmallJsonSSmallJsonG, \
7086  const char *: icExtractSmallJsonSSmallJsonG, \
7087  char: icExtractSmallJsonCharSmallJsonG, \
7088  int: icExtractSmallJsonCharSmallJsonG, \
7089  smallJsont *: icExtractSmallJsonSmallJsonSmallJsonG, \
7090  smallStringt *: icExtractSmallJsonSmallStringSmallJsonG \
7091  ),\
7092  smallStringt *: _Generic(delim2, \
7093  char *: icExtractSmallStringSSmallJsonG, \
7094  const char *: icExtractSmallStringSSmallJsonG, \
7095  char: icExtractSmallStringCharSmallJsonG, \
7096  int: icExtractSmallStringCharSmallJsonG, \
7097  smallJsont *: icExtractSmallStringSmallJsonSmallJsonG, \
7098  smallStringt *: icExtractSmallStringSmallStringSmallJsonG \
7099  )\
7100  ), \
7101  smallStringt *: _Generic(delim1, \
7102  char *: _Generic(delim2, \
7103  char *: icExtractSmallStringG, \
7104  const char *: icExtractSmallStringG, \
7105  char: icExtractSCharSmallStringG, \
7106  int: icExtractSCharSmallStringG, \
7107  smallJsont *: icExtractSSmallJsonSmallStringG, \
7108  smallStringt *: icExtractSSmallStringSmallStringG \
7109  ), \
7110  const char *: _Generic(delim2, \
7111  char *: icExtractSmallStringG, \
7112  const char *: icExtractSmallStringG, \
7113  char: icExtractSCharSmallStringG, \
7114  int: icExtractSCharSmallStringG, \
7115  smallJsont *: icExtractSSmallJsonSmallStringG, \
7116  smallStringt *: icExtractSSmallStringSmallStringG \
7117  ),\
7118  char: _Generic(delim2, \
7119  char *: icExtractCharSSmallStringG, \
7120  const char *: icExtractCharSSmallStringG, \
7121  char: icExtractCharCharSmallStringG, \
7122  int: icExtractCharCharSmallStringG, \
7123  smallJsont *: icExtractCharSmallJsonSmallStringG, \
7124  smallStringt *: icExtractCharSmallStringSmallStringG \
7125  ),\
7126  int: _Generic(delim2, \
7127  char *: icExtractCharSSmallStringG, \
7128  const char *: icExtractCharSSmallStringG, \
7129  char: icExtractCharCharSmallStringG, \
7130  int: icExtractCharCharSmallStringG, \
7131  smallJsont *: icExtractCharSmallJsonSmallStringG, \
7132  smallStringt *: icExtractCharSmallStringSmallStringG \
7133  ),\
7134  smallJsont *: _Generic(delim2, \
7135  char *: icExtractSmallJsonSSmallStringG, \
7136  const char *: icExtractSmallJsonSSmallStringG, \
7137  char: icExtractSmallJsonCharSmallStringG, \
7138  int: icExtractSmallJsonCharSmallStringG, \
7139  smallJsont *: icExtractSmallJsonSmallJsonSmallStringG, \
7140  smallStringt *: icExtractSmallJsonSmallStringSmallStringG \
7141  ),\
7142  smallStringt *: _Generic(delim2, \
7143  char *: icExtractSmallStringSSmallStringG, \
7144  const char *: icExtractSmallStringSSmallStringG, \
7145  char: icExtractSmallStringCharSmallStringG, \
7146  int: icExtractSmallStringCharSmallStringG, \
7147  smallJsont *: icExtractSmallStringSmallJsonSmallStringG, \
7148  smallStringt *: icExtractSmallStringSmallStringSmallStringG \
7149  )\
7150  ) \
7151  )(self, delim1, delim2)
7152 
7153 #define reverseO(self) (self)->f->reverse(self)
7154 #define reverseG(self) _Generic((self), \
7155  char **: listReverseS, \
7156  char ***: iListReverseS, \
7157  smallArrayt *: reverseSmallArrayG, \
7158  smallJsont *: reverseSmallJsonG \
7159  )(self)
7160 
7161 #define addO(self, array) (self)->f->add(self, array)
7162 #define addG(self, list) _Generic((self), \
7163  char *: appendS, \
7164  const char *: appendS, \
7165  char **: _Generic(list, \
7166  char **: listAddS, \
7167  const char **: listAddCG, \
7168  default: listAddS \
7169  ), \
7170  smallStringt *: appendSmallStringG, \
7171  smallArrayt *: addSmallArrayG, \
7172  smallJsont *: _Generic(list, \
7173  smallArrayt *: addSmallJsonG, \
7174  smallJsont *: addJsonSmallJsonG, \
7175  default: addJsonSmallJsonG \
7176  ) \
7177  )(self, list)
7178 
7179 #define sortO(self) (self)->f->sort(self)
7180 #define sortG(self) _Generic((self), \
7181  char **: listSortS, \
7182  char ***: iListSortS, \
7183  smallArrayt *: sortSmallArrayG, \
7184  smallJsont *: sortSmallJsonG \
7185  )(self)
7186 
7187 #define binarySearchO(self, value) (self)->f->binarySearch(self, value)
7188 #define binarySearchG(self, string) _Generic((self), \
7189  char **: _Generic(string, \
7190  char *: listBinarySearchS, \
7191  const char *: listBinarySearchS, \
7192  char: listBinarySearchCharS, \
7193  int: listBinarySearchCharS, \
7194  default: listBinarySearchS \
7195  ), \
7196  smallArrayt *: _Generic((string), \
7197  baset*: binarySearchSmallArrayG, \
7198  bool: binarySearchBoolSmallArrayG, \
7199  double: binarySearchDoubleSmallArrayG, \
7200  int64_t: binarySearchIntSmallArrayG, \
7201  int32_t: binarySearchIntSmallArrayG, \
7202  uint32_t: binarySearchIntSmallArrayG, \
7203  uint64_t: binarySearchIntSmallArrayG, \
7204  char*: binarySearchSSmallArrayG, \
7205  const char*: binarySearchSSmallArrayG, \
7206  char: binarySearchCharSmallArrayG, \
7207  smallDictt*: binarySearchDictSmallArrayG, \
7208  smallArrayt*: binarySearchArraySmallArrayG, \
7209  char **: binarySearchArraycSmallArrayG, \
7210  const char **: binarySearchCArraycSmallArrayG, \
7211  smallBoolt*: binarySearchSmallBoolSmallArrayG, \
7212  smallBytest*: binarySearchSmallBytesSmallArrayG, \
7213  smallDoublet*: binarySearchSmallDoubleSmallArrayG, \
7214  smallIntt*: binarySearchSmallIntSmallArrayG, \
7215  smallJsont*: binarySearchSmallJsonSmallArrayG, \
7216  smallStringt*: binarySearchSmallStringSmallArrayG, \
7217  smallContainert*: binarySearchSmallContainerSmallArrayG, \
7218  undefinedt*: binarySearchUndefinedSmallArrayG, \
7219  default: binarySearchUndefinedSmallArrayG \
7220  ), \
7221  smallJsont *: _Generic((string), \
7222  baset*: binarySearchSmallJsonG, \
7223  bool: binarySearchBoolSmallJsonG, \
7224  double: binarySearchDoubleSmallJsonG, \
7225  int64_t: binarySearchIntSmallJsonG, \
7226  int32_t: binarySearchIntSmallJsonG, \
7227  uint32_t: binarySearchIntSmallJsonG, \
7228  uint64_t: binarySearchIntSmallJsonG, \
7229  char*: binarySearchSSmallJsonG, \
7230  const char*: binarySearchSSmallJsonG, \
7231  char: binarySearchCharSmallJsonG, \
7232  smallDictt*: binarySearchDictSmallJsonG, \
7233  smallArrayt*: binarySearchArraySmallJsonG, \
7234  char **: binarySearchArraycSmallJsonG, \
7235  const char **: binarySearchCArraycSmallJsonG, \
7236  smallBoolt*: binarySearchSmallBoolSmallJsonG, \
7237  smallBytest*: binarySearchSmallBytesSmallJsonG, \
7238  smallDoublet*: binarySearchSmallDoubleSmallJsonG, \
7239  smallIntt*: binarySearchSmallIntSmallJsonG, \
7240  smallJsont*: binarySearchSmallJsonSmallJsonG, \
7241  smallStringt*: binarySearchSmallStringSmallJsonG, \
7242  smallContainert*: binarySearchSmallContainerSmallJsonG, \
7243  undefinedt*: binarySearchUndefinedSmallJsonG, \
7244  default: binarySearchUndefinedSmallJsonG \
7245  ) \
7246  )(self, string)
7247 
7248 #define icSortO(self) (self)->f->icSort(self)
7249 #define icSortG(self) _Generic((self), \
7250  char **: icListSortS, \
7251  char ***: iicListSortS, \
7252  smallArrayt *: icSortSmallArrayG, \
7253  smallJsont *: icSortSmallJsonG \
7254  )(self)
7255 
7256 #define icBinarySearchO(self, value) (self)->f->icBinarySearch(self, value)
7257 #define icBinarySearchG(self, string) _Generic((self), \
7258  char **: _Generic(string, \
7259  char *: icListBinarySearchS, \
7260  const char *: icListBinarySearchS, \
7261  char: icListBinarySearchCharS, \
7262  int: icListBinarySearchCharS, \
7263  default: icListBinarySearchS \
7264  ), \
7265  smallArrayt *: _Generic((string), \
7266  baset*: icBinarySearchSmallArrayG, \
7267  bool: binarySearchBoolSmallArrayG, \
7268  double: binarySearchDoubleSmallArrayG, \
7269  int64_t: binarySearchIntSmallArrayG, \
7270  int32_t: binarySearchIntSmallArrayG, \
7271  uint32_t: binarySearchIntSmallArrayG, \
7272  uint64_t: binarySearchIntSmallArrayG, \
7273  char*: icBinarySearchSSmallArrayG, \
7274  const char*: icBinarySearchSSmallArrayG, \
7275  char: icBinarySearchCharSmallArrayG, \
7276  smallDictt*: icBinarySearchDictSmallArrayG, \
7277  smallArrayt*: icBinarySearchArraySmallArrayG, \
7278  char **: icBinarySearchArraycSmallArrayG, \
7279  const char **: icBinarySearchCArraycSmallArrayG, \
7280  smallBoolt*: binarySearchSmallBoolSmallArrayG, \
7281  smallBytest*: binarySearchSmallBytesSmallArrayG, \
7282  smallDoublet*: binarySearchSmallDoubleSmallArrayG, \
7283  smallIntt*: binarySearchSmallIntSmallArrayG, \
7284  smallJsont*: icBinarySearchSmallJsonSmallArrayG, \
7285  smallStringt*: icBinarySearchSmallStringSmallArrayG, \
7286  smallContainert*: binarySearchSmallContainerSmallArrayG, \
7287  undefinedt*: binarySearchUndefinedSmallArrayG, \
7288  default: binarySearchUndefinedSmallArrayG \
7289  ), \
7290  smallJsont *: _Generic((string), \
7291  baset*: icBinarySearchSmallJsonG, \
7292  bool: binarySearchBoolSmallJsonG, \
7293  double: binarySearchDoubleSmallJsonG, \
7294  int64_t: binarySearchIntSmallJsonG, \
7295  int32_t: binarySearchIntSmallJsonG, \
7296  uint32_t: binarySearchIntSmallJsonG, \
7297  uint64_t: binarySearchIntSmallJsonG, \
7298  char*: icBinarySearchSSmallJsonG, \
7299  const char*: icBinarySearchSSmallJsonG, \
7300  char: icBinarySearchCharSmallJsonG, \
7301  smallDictt*: icBinarySearchDictSmallJsonG, \
7302  smallArrayt*: icBinarySearchArraySmallJsonG, \
7303  char **: icBinarySearchArraycSmallJsonG, \
7304  const char **: icBinarySearchCArraycSmallJsonG, \
7305  smallBoolt*: binarySearchSmallBoolSmallJsonG, \
7306  smallBytest*: binarySearchSmallBytesSmallJsonG, \
7307  smallDoublet*: binarySearchSmallDoubleSmallJsonG, \
7308  smallIntt*: binarySearchSmallIntSmallJsonG, \
7309  smallJsont*: binarySearchSmallJsonSmallJsonG, \
7310  smallStringt*: icBinarySearchSmallStringSmallJsonG, \
7311  smallContainert*: binarySearchSmallContainerSmallJsonG, \
7312  undefinedt*: binarySearchUndefinedSmallJsonG, \
7313  default: binarySearchUndefinedSmallJsonG \
7314  ) \
7315  )(self, string)
7316 
7317 #define compactO(self) (self)->f->compact(self)
7318 #define compactG(self) _Generic((self), \
7319  char **: listCompactS, \
7320  char ***: iListCompactS, \
7321  smallArrayt *: compactSmallArrayG, \
7322  smallJsont *: compactSmallJsonG \
7323  )(self)
7324 
7325 #define parseO(self, input) (self)->f->parse(self, input)
7326 #define parseG(self, input) _Generic(input, \
7327  char *: parseSmallJsonG, \
7328  const char *: parseSmallJsonG, \
7329  smallJsont *: parseSmallJsonSmallJsonG, \
7330  smallStringt *: parseSmallStringSmallJsonG \
7331  )(self, input)
7332 
7333 #define parseYMLO(self, input) (self)->f->parseYML(self, input)
7334 #define parseYMLG(self, input) _Generic(input, \
7335  char *: parseYMLSmallJsonG, \
7336  const char *: parseYMLSmallJsonG, \
7337  smallJsont *: parseYMLSmallJsonSmallJsonG, \
7338  smallStringt *: parseYMLSmallStringSmallJsonG \
7339  )(self, input)
7340 
7341 //TODO stringifySmallJson rtChar rtSmallStringt
7342 //TODO toYMLSmallJson rtChar rtSmallStringt
7343 
7344 
7345 #define execG(cmd, out, err) _Generic(cmd, \
7346  char *: execO, \
7347  const char *: execO, \
7348  smallJsont *: execSmallJsonO, \
7349  smallStringt *: execSmallStringO \
7350  )(cmd, out, err)
7351 
7352 #define renameG(src, dst) _Generic(src, \
7353  char *: _Generic(dst, \
7354  char *: shRename, \
7355  const char *: shRename, \
7356  smallJsont *: renameSSmallJsonO, \
7357  smallStringt *: renameSO \
7358  ), \
7359  const char*: _Generic(dst, \
7360  char *: shRename, \
7361  const char *: shRename, \
7362  smallJsont *: renameSSmallJsonO, \
7363  smallStringt *: renameSO \
7364  ), \
7365  smallJsont *: _Generic(dst, \
7366  char *: renameSmallJsonOS, \
7367  const char *: renameSmallJsonOS, \
7368  smallJsont *: renameSmallJsonSmallJson, \
7369  smallStringt *: renameSmallJsonO \
7370  ), \
7371  smallStringt *: _Generic(dst, \
7372  char *: renameOS, \
7373  const char *: renameOS, \
7374  smallJsont *: renameOSmallJson, \
7375  smallStringt *: renameO \
7376  ) \
7377  )(src, dst)
7378 
7379 #define moveG(src, dst) _Generic(src, \
7380  char *: _Generic(dst, \
7381  char *: shMove, \
7382  const char *: shMove, \
7383  smallJsont *: moveSSmallJsonO, \
7384  smallStringt *: moveSO \
7385  ), \
7386  const char*: _Generic(dst, \
7387  char *: shMove, \
7388  const char *: shMove, \
7389  smallJsont *: moveSSmallJsonO, \
7390  smallStringt *: moveSO \
7391  ), \
7392  smallJsont *: _Generic(dst, \
7393  char *: moveSmallJsonOS, \
7394  const char *: moveSmallJsonOS, \
7395  smallJsont *: moveSmallJsonSmallJson, \
7396  smallStringt *: moveSmallJsonO \
7397  ), \
7398  smallStringt *: _Generic(dst, \
7399  char *: moveOS, \
7400  const char *: moveOS, \
7401  smallJsont *: moveOSmallJson, \
7402  smallStringt *: moveO \
7403  ) \
7404  )(src, dst)
7405 
7409 #define logO(self) (self)->f->log(self)
7410 #define logG(self) _Generic(self, \
7411  smallArrayt *: logSmallArrayG, \
7412  smallDictt *: logSmallDictG, \
7413  smallJsont *: logSmallJsonG, \
7414  char **: listPrintS, \
7415  const char **: listPrintCG \
7416  )(self)
7417 
7418 
7426 #define logVarG(var)\
7427  do {\
7428  char *UNIQVAR(tmpString) = toStringG(var);\
7429  logD("%s=%s\n", stringifyExpr(var), UNIQVAR(tmpString));\
7430  free(UNIQVAR(tmpString));\
7431  } while(0);
7432 
7433 #define logMVarG(mask, var)\
7434  do {\
7435  char *UNIQVAR(tmpString) = toStringG(var);\
7436  logMD(mask, "%s=%s\n", stringifyExpr(var), UNIQVAR(tmpString));\
7437  free(UNIQVAR(tmpString));\
7438  } while(0);
7439 
7447 #define logTVarG(var)\
7448  do {\
7449  char *UNIQVAR(tmpString) = toStringG(var);\
7450  logD("%s %s=%s\n", getOTypeG(var), stringifyExpr(var), UNIQVAR(tmpString));\
7451  free(UNIQVAR(tmpString));\
7452  } while(0);
7453 
7454 #define logMTVarG(mask, var)\
7455  do {\
7456  char *UNIQVAR(tmpString) = toStringG(var);\
7457  logMD(mask, "%s %s=%s\n", getOTypeG(var), stringifyExpr(var), UNIQVAR(tmpString));\
7458  free(UNIQVAR(tmpString));\
7459  } while(0);
7460 
7461 #define logTypeG(var) logD("%s %s\n", getOTypeG(var), stringifyExpr(var))
7462 
7466 #define catO(self, ...) (self)->f->cat((self), __VA_ARGS__, NULL)
7467 #define catG catO
7468 #define catSO(self, ...) (self)->f->catSt((self), __VA_ARGS__, NULL)
7469 #define catSG catSO
7470 
7471 #define pushManyO(self, ...) (self)->f->pushMany(self, __VA_ARGS__, NULL)
7472 #define pushManyG pushManyO
7473 
7474 #define pushManySO(self, ...) (self)->f->pushManyS(self, __VA_ARGS__, NULL)
7475 #define pushManySG pushManySO
7476 
7477 #define pushNFreeManyO(self, ...) (self)->f->pushNFreeMany(self, __VA_ARGS__, NULL)
7478 #define pushNFreeManyG pushNFreeManyO
7479 
7480 #define pushNFreeManySO(self, ...) (self)->f->pushNFreeManyS(self, __VA_ARGS__, NULL)
7481 #define pushNFreeManySG pushNFreeManySO
7482 
7483 
7484 // smallBytes pushBuffer
7485 #define pushBufferO(self, data, size) (self)->f->pushBuffer(self, data, size)
7486 #define pushBufferG pushBufferO
7487 
7488 
7489 #define setTopSO setTopStringO
7490 #define setTopSG setTopStringO
7491 
7492 // generated with utils/oGMacros
7493 
7494 #define escapeO(self) (self)->f->escape(self)
7495 #define escapeG escapeO
7496 
7497 #define disposeO(self) (self)->f->dispose(self)
7498 #define disposeG disposeO
7499 
7500 #define helpO(self) (self)->f->help(self)
7501 #define helpG helpO
7502 
7503 #define resetO(self) (self)->f->reset(self)
7504 #define resetG resetO
7505 
7506 #define getsoO(self) (self)->f->getso(self)
7507 #define getsoG getsoO
7508 
7509 #define setsoO(self, so) (self)->f->setso(self, so)
7510 #define setsoG setsoO
7511 
7512 #define mirrorO(self) (self)->f->mirror(self)
7513 #define mirrorG mirrorO
7514 
7515 #define fromCArrayO(self, array, size) (self)->f->fromCArray(self, array, size)
7516 #define fromCArrayG fromCArrayO
7517 
7518 #define fromArrayNFreeO(self, array, size) (self)->f->fromArrayNFree(self, array, size)
7519 #define fromArrayNFreeG fromArrayNFreeO
7520 
7521 #define pushCharO(self, c) (self)->f->pushChar(self, c)
7522 #define pushCharG pushCharO
7523 
7524 #define pushArraycO(self, array) (self)->f->pushArrayc(self, array)
7525 #define pushArraycG pushArraycO
7526 
7527 #define pushCArraycO(self, array) (self)->f->pushCArrayc(self, array)
7528 #define pushCArraycG pushCArraycO
7529 
7530 #define pushNFreeArraycO(self, array) (self)->f->pushNFreeArrayc(self, array)
7531 #define pushNFreeArraycG pushNFreeArraycO
7532 
7533 #define pushNFreeSmallBytesO(self, value) (self)->f->pushNFreeSmallBytes(self, value)
7534 #define pushNFreeSmallBytesG pushNFreeSmallBytesO
7535 
7536 #define popSmallBytesO(self) (self)->f->popSmallBytes(self)
7537 #define popSmallBytesG popSmallBytesO
7538 
7539 #define popNumO(self) (self)->f->popNum(self)
7540 #define popNumG popNumO
7541 
7542 #define prependUndefinedO(self) (self)->f->prependUndefined(self)
7543 #define prependUndefinedG prependUndefinedO
7544 
7545 #define prependBoolO(self, value) (self)->f->prependBool(self, value)
7546 #define prependBoolG prependBoolO
7547 
7548 #define prependDoubleO(self, value) (self)->f->prependDouble(self, value)
7549 #define prependDoubleG prependDoubleO
7550 
7551 #define prependIntO(self, value) (self)->f->prependInt(self, value)
7552 #define prependIntG prependIntO
7553 
7554 #define prependSO(self, string) (self)->f->prependS(self, string)
7555 #define prependSG prependSO
7556 
7557 #define prependCharO(self, c) (self)->f->prependChar(self, c)
7558 #define prependCharG prependCharO
7559 
7560 #define prependDictO(self, dict) (self)->f->prependDict(self, dict)
7561 #define prependDictG prependDictO
7562 
7563 #define prependArrayO(self, array) (self)->f->prependArray(self, array)
7564 #define prependArrayG prependArrayO
7565 
7566 #define prependArraycO(self, array) (self)->f->prependArrayc(self, array)
7567 #define prependArraycG prependArraycO
7568 
7569 #define prependCArraycO(self, array) (self)->f->prependCArrayc(self, array)
7570 #define prependCArraycG prependCArraycO
7571 
7572 #define prependSmallBoolO(self, value) (self)->f->prependSmallBool(self, value)
7573 #define prependSmallBoolG prependSmallBoolO
7574 
7575 #define prependSmallBytesO(self, value) (self)->f->prependSmallBytes(self, value)
7576 #define prependSmallBytesG prependSmallBytesO
7577 
7578 #define prependSmallDoubleO(self, value) (self)->f->prependSmallDouble(self, value)
7579 #define prependSmallDoubleG prependSmallDoubleO
7580 
7581 #define prependSmallIntO(self, value) (self)->f->prependSmallInt(self, value)
7582 #define prependSmallIntG prependSmallIntO
7583 
7584 #define prependSmallContainerO(self, container) (self)->f->prependSmallContainer(self, container)
7585 #define prependSmallContainerG prependSmallContainerO
7586 
7587 #define prependNFreeUndefinedO(self, u) (self)->f->prependNFreeUndefined(self, u)
7588 #define prependNFreeUndefinedG prependNFreeUndefinedO
7589 
7590 #define prependNFreeSO(self, string) (self)->f->prependNFreeS(self, string)
7591 #define prependNFreeSG prependNFreeSO
7592 
7593 #define prependNFreeDictO(self, dict) (self)->f->prependNFreeDict(self, dict)
7594 #define prependNFreeDictG prependNFreeDictO
7595 
7596 #define prependNFreeArrayO(self, array) (self)->f->prependNFreeArray(self, array)
7597 #define prependNFreeArrayG prependNFreeArrayO
7598 
7599 #define prependNFreeArraycO(self, array) (self)->f->prependNFreeArrayc(self, array)
7600 #define prependNFreeArraycG prependNFreeArraycO
7601 
7602 #define prependNFreeSmallBoolO(self, value) (self)->f->prependNFreeSmallBool(self, value)
7603 #define prependNFreeSmallBoolG prependNFreeSmallBoolO
7604 
7605 #define prependNFreeSmallBytesO(self, value) (self)->f->prependNFreeSmallBytes(self, value)
7606 #define prependNFreeSmallBytesG prependNFreeSmallBytesO
7607 
7608 #define prependNFreeSmallDoubleO(self, value) (self)->f->prependNFreeSmallDouble(self, value)
7609 #define prependNFreeSmallDoubleG prependNFreeSmallDoubleO
7610 
7611 #define prependNFreeSmallIntO(self, value) (self)->f->prependNFreeSmallInt(self, value)
7612 #define prependNFreeSmallIntG prependNFreeSmallIntO
7613 
7614 #define prependNFreeSmallStringO(self, string) (self)->f->prependNFreeSmallString(self, string)
7615 #define prependNFreeSmallStringG prependNFreeSmallStringO
7616 
7617 #define prependNFreeSmallContainerO(self, container) (self)->f->prependNFreeSmallContainer(self, container)
7618 #define prependNFreeSmallContainerG prependNFreeSmallContainerO
7619 
7620 #define dequeueUndefinedO(self) (self)->f->dequeueUndefined(self)
7621 #define dequeueUndefinedG dequeueUndefinedO
7622 
7623 #define dequeueBoolO(self) (self)->f->dequeueBool(self)
7624 #define dequeueBoolG dequeueBoolO
7625 
7626 #define dequeueDoubleO(self) (self)->f->dequeueDouble(self)
7627 #define dequeueDoubleG dequeueDoubleO
7628 
7629 #define dequeueIntO(self) (self)->f->dequeueInt(self)
7630 #define dequeueIntG dequeueIntO
7631 
7632 #define dequeueInt32O(self) (self)->f->dequeueInt32(self)
7633 #define dequeueInt32G dequeueInt32O
7634 
7635 #define dequeueUintO(self) (self)->f->dequeueUint(self)
7636 #define dequeueUintG dequeueUintO
7637 
7638 #define dequeueUint32O(self) (self)->f->dequeueUint32(self)
7639 #define dequeueUint32G dequeueUint32O
7640 
7641 #define dequeueSO(self) (self)->f->dequeueS(self)
7642 #define dequeueSG dequeueSO
7643 
7644 #define dequeueDictO(self) (self)->f->dequeueDict(self)
7645 #define dequeueDictG dequeueDictO
7646 
7647 #define dequeueArrayO(self) (self)->f->dequeueArray(self)
7648 #define dequeueArrayG dequeueArrayO
7649 
7650 #define dequeueSmallBoolO(self) (self)->f->dequeueSmallBool(self)
7651 #define dequeueSmallBoolG dequeueSmallBoolO
7652 
7653 #define dequeueSmallBytesO(self) (self)->f->dequeueSmallBytes(self)
7654 #define dequeueSmallBytesG dequeueSmallBytesO
7655 
7656 #define dequeueSmallDoubleO(self) (self)->f->dequeueSmallDouble(self)
7657 #define dequeueSmallDoubleG dequeueSmallDoubleO
7658 
7659 #define dequeueSmallIntO(self) (self)->f->dequeueSmallInt(self)
7660 #define dequeueSmallIntG dequeueSmallIntO
7661 
7662 #define dequeueSmallStringO(self) (self)->f->dequeueSmallString(self)
7663 #define dequeueSmallStringG dequeueSmallStringO
7664 
7665 #define dequeueVoidO(self) (self)->f->dequeueVoid(self)
7666 #define dequeueVoidG dequeueVoidO
7667 
7668 #define dequeueSmallContainerO(self) (self)->f->dequeueSmallContainer(self)
7669 #define dequeueSmallContainerG dequeueSmallContainerO
7670 
7671 #define dequeueNumO(self) (self)->f->dequeueNum(self)
7672 #define dequeueNumG dequeueNumO
7673 
7674 #define appendArrayO(self, array) (self)->f->appendArray(self, array)
7675 #define appendArrayG appendArrayO
7676 
7677 #define appendCArrayO(self, array) (self)->f->appendCArray(self, array)
7678 #define appendCArrayG appendCArrayO
7679 
7680 #define appendNSmashArrayO(self, array) (self)->f->appendNSmashArray(self, array)
7681 #define appendNSmashArrayG appendNSmashArrayO
7682 
7683 #define cropElemUndefinedO(self, index) (self)->f->cropElemUndefined(self, index)
7684 #define cropElemUndefinedG cropElemUndefinedO
7685 
7686 #define cropElemBoolO(self, index) (self)->f->cropElemBool(self, index)
7687 #define cropElemBoolG cropElemBoolO
7688 
7689 #define cropElemDoubleO(self, index) (self)->f->cropElemDouble(self, index)
7690 #define cropElemDoubleG cropElemDoubleO
7691 
7692 #define cropElemIntO(self, index) (self)->f->cropElemInt(self, index)
7693 #define cropElemIntG cropElemIntO
7694 
7695 #define cropElemInt32O(self, index) (self)->f->cropElemInt32(self, index)
7696 #define cropElemInt32G cropElemInt32O
7697 
7698 #define cropElemUintO(self, index) (self)->f->cropElemUint(self, index)
7699 #define cropElemUintG cropElemUintO
7700 
7701 #define cropElemUint32O(self, index) (self)->f->cropElemUint32(self, index)
7702 #define cropElemUint32G cropElemUint32O
7703 
7704 #define cropElemSO(self, index) (self)->f->cropElemS(self, index)
7705 #define cropElemSG cropElemSO
7706 
7707 #define cropElemDictO(self, index) (self)->f->cropElemDict(self, index)
7708 #define cropElemDictG cropElemDictO
7709 
7710 #define cropElemArrayO(self, index) (self)->f->cropElemArray(self, index)
7711 #define cropElemArrayG cropElemArrayO
7712 
7713 #define cropElemSmallBoolO(self, index) (self)->f->cropElemSmallBool(self, index)
7714 #define cropElemSmallBoolG cropElemSmallBoolO
7715 
7716 #define cropElemSmallBytesO(self, index) (self)->f->cropElemSmallBytes(self, index)
7717 #define cropElemSmallBytesG cropElemSmallBytesO
7718 
7719 #define cropElemSmallDoubleO(self, index) (self)->f->cropElemSmallDouble(self, index)
7720 #define cropElemSmallDoubleG cropElemSmallDoubleO
7721 
7722 #define cropElemSmallIntO(self, index) (self)->f->cropElemSmallInt(self, index)
7723 #define cropElemSmallIntG cropElemSmallIntO
7724 
7725 #define cropElemSmallJsonO(self, index) (self)->f->cropElemSmallJson(self, index)
7726 #define cropElemSmallJsonG cropElemSmallJsonO
7727 
7728 #define cropElemVoidO(self, index) (self)->f->cropElemVoid(self, index)
7729 #define cropElemVoidG cropElemVoidO
7730 
7731 #define cropElemSmallContainerO(self, index) (self)->f->cropElemSmallContainer(self, index)
7732 #define cropElemSmallContainerG cropElemSmallContainerO
7733 
7734 #define injectUndefinedO(self, index) (self)->f->injectUndefined(self, index)
7735 #define injectUndefinedG injectUndefinedO
7736 
7737 #define injectBoolO(self, index, toInject) (self)->f->injectBool(self, index, toInject)
7738 #define injectBoolG injectBoolO
7739 
7740 #define injectDoubleO(self, index, toInject) (self)->f->injectDouble(self, index, toInject)
7741 #define injectDoubleG injectDoubleO
7742 
7743 #define injectIntO(self, index, toInject) (self)->f->injectInt(self, index, toInject)
7744 #define injectIntG injectIntO
7745 
7746 #define injectSO(self, index, toInject) (self)->f->injectS(self, index, toInject)
7747 #define injectSG injectSO
7748 
7749 #define injectCharO(self, index, c) (self)->f->injectChar(self, index, c)
7750 #define injectCharG injectCharO
7751 
7752 #define injectDictO(self, index, toInject) (self)->f->injectDict(self, index, toInject)
7753 #define injectDictG injectDictO
7754 
7755 #define injectArrayO(self, index, toInject) (self)->f->injectArray(self, index, toInject)
7756 #define injectArrayG injectArrayO
7757 
7758 #define injectArraycO(self, index, toInject) (self)->f->injectArrayc(self, index, toInject)
7759 #define injectArraycG injectArraycO
7760 
7761 #define injectCArraycO(self, index, toInject) (self)->f->injectCArrayc(self, index, toInject)
7762 #define injectCArraycG injectCArraycO
7763 
7764 #define injectSmallBoolO(self, index, toInject) (self)->f->injectSmallBool(self, index, toInject)
7765 #define injectSmallBoolG injectSmallBoolO
7766 
7767 #define injectSmallBytesO(self, index, toInject) (self)->f->injectSmallBytes(self, index, toInject)
7768 #define injectSmallBytesG injectSmallBytesO
7769 
7770 #define injectSmallDoubleO(self, index, toInject) (self)->f->injectSmallDouble(self, index, toInject)
7771 #define injectSmallDoubleG injectSmallDoubleO
7772 
7773 #define injectSmallIntO(self, index, toInject) (self)->f->injectSmallInt(self, index, toInject)
7774 #define injectSmallIntG injectSmallIntO
7775 
7776 #define injectSmallContainerO(self, index, toInject) (self)->f->injectSmallContainer(self, index, toInject)
7777 #define injectSmallContainerG injectSmallContainerO
7778 
7779 #define injectNFreeUndefinedO(self, index, u) (self)->f->injectNFreeUndefined(self, index, u)
7780 #define injectNFreeUndefinedG injectNFreeUndefinedO
7781 
7782 #define injectNFreeSO(self, index, toInject) (self)->f->injectNFreeS(self, index, toInject)
7783 #define injectNFreeSG injectNFreeSO
7784 
7785 #define injectNFreeDictO(self, index, toInject) (self)->f->injectNFreeDict(self, index, toInject)
7786 #define injectNFreeDictG injectNFreeDictO
7787 
7788 #define injectNFreeArrayO(self, index, toInject) (self)->f->injectNFreeArray(self, index, toInject)
7789 #define injectNFreeArrayG injectNFreeArrayO
7790 
7791 #define injectNFreeArraycO(self, index, toInject) (self)->f->injectNFreeArrayc(self, index, toInject)
7792 #define injectNFreeArraycG injectNFreeArraycO
7793 
7794 #define injectNFreeSmallBoolO(self, index, toInject) (self)->f->injectNFreeSmallBool(self, index, toInject)
7795 #define injectNFreeSmallBoolG injectNFreeSmallBoolO
7796 
7797 #define injectNFreeSmallBytesO(self, index, toInject) (self)->f->injectNFreeSmallBytes(self, index, toInject)
7798 #define injectNFreeSmallBytesG injectNFreeSmallBytesO
7799 
7800 #define injectNFreeSmallDoubleO(self, index, toInject) (self)->f->injectNFreeSmallDouble(self, index, toInject)
7801 #define injectNFreeSmallDoubleG injectNFreeSmallDoubleO
7802 
7803 #define injectNFreeSmallIntO(self, index, toInject) (self)->f->injectNFreeSmallInt(self, index, toInject)
7804 #define injectNFreeSmallIntG injectNFreeSmallIntO
7805 
7806 #define injectNFreeSmallStringO(self, index, toInject) (self)->f->injectNFreeSmallString(self, index, toInject)
7807 #define injectNFreeSmallStringG injectNFreeSmallStringO
7808 
7809 #define injectNFreeSmallContainerO(self, index, toInject) (self)->f->injectNFreeSmallContainer(self, index, toInject)
7810 #define injectNFreeSmallContainerG injectNFreeSmallContainerO
7811 
7812 #define sortFO(self, compareFunction) (self)->f->sortF(self, compareFunction)
7813 #define sortFG sortFO
7814 
7815 #define equalO(self, array) (self)->f->equal(self, array)
7816 #define equalG equalO
7817 
7818 #define equalSmallJsonO(self, array) (self)->f->equalSmallJson(self, array)
7819 #define equalSmallJsonG equalSmallJsonO
7820 
7821 #define equalArrayO(self, p2) (self)->f->equalArray(self, p2)
7822 #define equalArrayG equalArrayO
7823 
7824 #define equalCArrayO(self, p2) (self)->f->equalCArray(self, p2)
7825 #define equalCArrayG equalCArrayO
7826 
7827 #define equalBaseO(self, p2) (self)->f->equalBase(self, p2)
7828 #define equalBaseG equalBaseO
7829 
7830 #define icEqualO(self, array) (self)->f->icEqual(self, array)
7831 #define icEqualG icEqualO
7832 
7833 #define icEqualSmallJsonO(self, array) (self)->f->icEqualSmallJson(self, array)
7834 #define icEqualSmallJsonG icEqualSmallJsonO
7835 
7836 #define setAtCharO(self, index, c) (self)->f->setAtChar(self, index, c)
7837 #define setAtCharG setAtCharO
7838 
7839 #define setAtArraycO(self, index, array) (self)->f->setAtArrayc(self, index, array)
7840 #define setAtArraycG setAtArraycO
7841 
7842 #define setAtCArraycO(self, index, array) (self)->f->setAtCArrayc(self, index, array)
7843 #define setAtCArraycG setAtCArraycO
7844 
7845 #define setAtSmallBytesO(self, index, value) (self)->f->setAtSmallBytes(self, index, value)
7846 #define setAtSmallBytesG setAtSmallBytesO
7847 
7848 #define setAtNFreeArraycO(self, index, array) (self)->f->setAtNFreeArrayc(self, index, array)
7849 #define setAtNFreeArraycG setAtNFreeArraycO
7850 
7851 #define setAtNFreeSmallBytesO(self, index, value) (self)->f->setAtNFreeSmallBytes(self, index, value)
7852 #define setAtNFreeSmallBytesG setAtNFreeSmallBytesO
7853 
7854 #define setPAtSmallJsonO(self, index, json) (self)->f->setPAtSmallJson(self, index, json)
7855 #define setPAtSmallJsonG setPAtSmallJsonO
7856 
7857 #define setPAtNFreeSmallJsonO(self, index, json) (self)->f->setPAtNFreeSmallJson(self, index, json)
7858 #define setPAtNFreeSmallJsonG setPAtNFreeSmallJsonO
7859 
7860 #define hasUndefinedO(self, u) (self)->f->hasUndefined(self, u)
7861 #define hasUndefinedG hasUndefinedO
7862 
7863 #define hasBoolO(self, value) (self)->f->hasBool(self, value)
7864 #define hasBoolG hasBoolO
7865 
7866 #define hasDoubleO(self, value) (self)->f->hasDouble(self, value)
7867 #define hasDoubleG hasDoubleO
7868 
7869 #define hasIntO(self, value) (self)->f->hasInt(self, value)
7870 #define hasIntG hasIntO
7871 
7872 #define hasSO(self, string) (self)->f->hasS(self, string)
7873 #define hasSG hasSO
7874 
7875 #define hasCharO(self, c) (self)->f->hasChar(self, c)
7876 #define hasCharG hasCharO
7877 
7878 #define hasDictO(self, dict) (self)->f->hasDict(self, dict)
7879 #define hasDictG hasDictO
7880 
7881 #define hasArrayO(self, array) (self)->f->hasArray(self, array)
7882 #define hasArrayG hasArrayO
7883 
7884 #define hasArraycO(self, array) (self)->f->hasArrayc(self, array)
7885 #define hasArraycG hasArraycO
7886 
7887 #define hasCArraycO(self, array) (self)->f->hasCArrayc(self, array)
7888 #define hasCArraycG hasCArraycO
7889 
7890 #define hasSmallBoolO(self, value) (self)->f->hasSmallBool(self, value)
7891 #define hasSmallBoolG hasSmallBoolO
7892 
7893 #define hasSmallBytesO(self, value) (self)->f->hasSmallBytes(self, value)
7894 #define hasSmallBytesG hasSmallBytesO
7895 
7896 #define hasSmallDoubleO(self, value) (self)->f->hasSmallDouble(self, value)
7897 #define hasSmallDoubleG hasSmallDoubleO
7898 
7899 #define hasSmallIntO(self, value) (self)->f->hasSmallInt(self, value)
7900 #define hasSmallIntG hasSmallIntO
7901 
7902 #define hasSmallContainerO(self, container) (self)->f->hasSmallContainer(self, container)
7903 #define hasSmallContainerG hasSmallContainerO
7904 
7905 #define indexOfUndefinedO(self, u) (self)->f->indexOfUndefined(self, u)
7906 #define indexOfUndefinedG indexOfUndefinedO
7907 
7908 #define indexOfBoolO(self, value) (self)->f->indexOfBool(self, value)
7909 #define indexOfBoolG indexOfBoolO
7910 
7911 #define indexOfDoubleO(self, value) (self)->f->indexOfDouble(self, value)
7912 #define indexOfDoubleG indexOfDoubleO
7913 
7914 #define indexOfIntO(self, value) (self)->f->indexOfInt(self, value)
7915 #define indexOfIntG indexOfIntO
7916 
7917 #define indexOfSO(self, string) (self)->f->indexOfS(self, string)
7918 #define indexOfSG indexOfSO
7919 
7920 #define indexOfCharO(self, c) (self)->f->indexOfChar(self, c)
7921 #define indexOfCharG indexOfCharO
7922 
7923 #define indexOfDictO(self, dict) (self)->f->indexOfDict(self, dict)
7924 #define indexOfDictG indexOfDictO
7925 
7926 #define indexOfArrayO(self, array) (self)->f->indexOfArray(self, array)
7927 #define indexOfArrayG indexOfArrayO
7928 
7929 #define indexOfArraycO(self, array) (self)->f->indexOfArrayc(self, array)
7930 #define indexOfArraycG indexOfArraycO
7931 
7932 #define indexOfCArraycO(self, array) (self)->f->indexOfCArrayc(self, array)
7933 #define indexOfCArraycG indexOfCArraycO
7934 
7935 #define indexOfSmallBoolO(self, value) (self)->f->indexOfSmallBool(self, value)
7936 #define indexOfSmallBoolG indexOfSmallBoolO
7937 
7938 #define indexOfSmallBytesO(self, value) (self)->f->indexOfSmallBytes(self, value)
7939 #define indexOfSmallBytesG indexOfSmallBytesO
7940 
7941 #define indexOfSmallDoubleO(self, value) (self)->f->indexOfSmallDouble(self, value)
7942 #define indexOfSmallDoubleG indexOfSmallDoubleO
7943 
7944 #define indexOfSmallIntO(self, value) (self)->f->indexOfSmallInt(self, value)
7945 #define indexOfSmallIntG indexOfSmallIntO
7946 
7947 #define binarySearchUndefinedO(self, u) (self)->f->binarySearchUndefined(self, u)
7948 #define binarySearchUndefinedG binarySearchUndefinedO
7949 
7950 #define binarySearchBoolO(self, value) (self)->f->binarySearchBool(self, value)
7951 #define binarySearchBoolG binarySearchBoolO
7952 
7953 #define binarySearchDoubleO(self, value) (self)->f->binarySearchDouble(self, value)
7954 #define binarySearchDoubleG binarySearchDoubleO
7955 
7956 #define binarySearchIntO(self, value) (self)->f->binarySearchInt(self, value)
7957 #define binarySearchIntG binarySearchIntO
7958 
7959 #define binarySearchSO(self, string) (self)->f->binarySearchS(self, string)
7960 #define binarySearchSG binarySearchSO
7961 
7962 #define binarySearchCharO(self, c) (self)->f->binarySearchChar(self, c)
7963 #define binarySearchCharG binarySearchCharO
7964 
7965 #define binarySearchDictO(self, dict) (self)->f->binarySearchDict(self, dict)
7966 #define binarySearchDictG binarySearchDictO
7967 
7968 #define binarySearchArrayO(self, array) (self)->f->binarySearchArray(self, array)
7969 #define binarySearchArrayG binarySearchArrayO
7970 
7971 #define binarySearchArraycO(self, array) (self)->f->binarySearchArrayc(self, array)
7972 #define binarySearchArraycG binarySearchArraycO
7973 
7974 #define binarySearchCArraycO(self, array) (self)->f->binarySearchCArrayc(self, array)
7975 #define binarySearchCArraycG binarySearchCArraycO
7976 
7977 #define binarySearchSmallBoolO(self, value) (self)->f->binarySearchSmallBool(self, value)
7978 #define binarySearchSmallBoolG binarySearchSmallBoolO
7979 
7980 #define binarySearchSmallBytesO(self, value) (self)->f->binarySearchSmallBytes(self, value)
7981 #define binarySearchSmallBytesG binarySearchSmallBytesO
7982 
7983 #define binarySearchSmallDoubleO(self, value) (self)->f->binarySearchSmallDouble(self, value)
7984 #define binarySearchSmallDoubleG binarySearchSmallDoubleO
7985 
7986 #define binarySearchSmallIntO(self, value) (self)->f->binarySearchSmallInt(self, value)
7987 #define binarySearchSmallIntG binarySearchSmallIntO
7988 
7989 #define binarySearchSmallStringO(self, string) (self)->f->binarySearchSmallString(self, string)
7990 #define binarySearchSmallStringG binarySearchSmallStringO
7991 
7992 #define icHasSO(self, string) (self)->f->icHasS(self, string)
7993 #define icHasSG icHasSO
7994 
7995 #define icHasCharO(self, c) (self)->f->icHasChar(self, c)
7996 #define icHasCharG icHasCharO
7997 
7998 #define icHasDictO(self, dict) (self)->f->icHasDict(self, dict)
7999 #define icHasDictG icHasDictO
8000 
8001 #define icHasArrayO(self, array) (self)->f->icHasArray(self, array)
8002 #define icHasArrayG icHasArrayO
8003 
8004 #define icHasArraycO(self, array) (self)->f->icHasArrayc(self, array)
8005 #define icHasArraycG icHasArraycO
8006 
8007 #define icHasCArraycO(self, array) (self)->f->icHasCArrayc(self, array)
8008 #define icHasCArraycG icHasCArraycO
8009 
8010 #define icIndexOfSO(self, string) (self)->f->icIndexOfS(self, string)
8011 #define icIndexOfSG icIndexOfSO
8012 
8013 #define icIndexOfCharO(self, c) (self)->f->icIndexOfChar(self, c)
8014 #define icIndexOfCharG icIndexOfCharO
8015 
8016 #define icIndexOfDictO(self, dict) (self)->f->icIndexOfDict(self, dict)
8017 #define icIndexOfDictG icIndexOfDictO
8018 
8019 #define icIndexOfArrayO(self, array) (self)->f->icIndexOfArray(self, array)
8020 #define icIndexOfArrayG icIndexOfArrayO
8021 
8022 #define icIndexOfArraycO(self, array) (self)->f->icIndexOfArrayc(self, array)
8023 #define icIndexOfArraycG icIndexOfArraycO
8024 
8025 #define icIndexOfCArraycO(self, array) (self)->f->icIndexOfCArrayc(self, array)
8026 #define icIndexOfCArraycG icIndexOfCArraycO
8027 
8028 #define icBinarySearchSO(self, string) (self)->f->icBinarySearchS(self, string)
8029 #define icBinarySearchSG icBinarySearchSO
8030 
8031 #define icBinarySearchCharO(self, c) (self)->f->icBinarySearchChar(self, c)
8032 #define icBinarySearchCharG icBinarySearchCharO
8033 
8034 #define icBinarySearchDictO(self, dict) (self)->f->icBinarySearchDict(self, dict)
8035 #define icBinarySearchDictG icBinarySearchDictO
8036 
8037 #define icBinarySearchArrayO(self, array) (self)->f->icBinarySearchArray(self, array)
8038 #define icBinarySearchArrayG icBinarySearchArrayO
8039 
8040 #define icBinarySearchArraycO(self, array) (self)->f->icBinarySearchArrayc(self, array)
8041 #define icBinarySearchArraycG icBinarySearchArraycO
8042 
8043 #define icBinarySearchCArraycO(self, array) (self)->f->icBinarySearchCArrayc(self, array)
8044 #define icBinarySearchCArraycG icBinarySearchCArraycO
8045 
8046 #define icBinarySearchSmallStringO(self, string) (self)->f->icBinarySearchSmallString(self, string)
8047 #define icBinarySearchSmallStringG icBinarySearchSmallStringO
8048 
8049 #define forEachO(self, closure, funcElem) (self)->f->forEach(self, closure, funcElem)
8050 #define forEachG forEachO
8051 
8052 #define enumerateO(self, closure, funcElem) (self)->f->enumerate(self, closure, funcElem)
8053 #define enumerateG enumerateO
8054 
8055 #define iterStartO(self) (self)->f->iterStart(self)
8056 #define iterStartG iterStartO
8057 
8058 #define iterStartLastO(self) (self)->f->iterStartLast(self)
8059 #define iterStartLastG iterStartLastO
8060 
8061 #define iterStartFromO(self, index) (self)->f->iterStartFrom(self, index)
8062 #define iterStartFromG iterStartFromO
8063 
8064 #define iterStartFromStepO(self, index, step) (self)->f->iterStartFromStep(self, index, step)
8065 #define iterStartFromStepG iterStartFromStepO
8066 
8067 #define iterNextO(self) (self)->f->iterNext(self)
8068 #define iterNextG iterNextO
8069 
8070 #define iterElementO(self) (self)->f->iterElement(self)
8071 #define iterElementG iterElementO
8072 
8073 #define iterIndexO(self) (self)->f->iterIndex(self)
8074 #define iterIndexG iterIndexO
8075 
8076 #define iterStepO(self) (self)->f->iterStep(self)
8077 #define iterStepG iterStepO
8078 
8079 #define joinCharO(self, c) (self)->f->joinChar(self, c)
8080 #define joinCharG joinCharO
8081 
8082 #define joinSmallStringO(self, delim) (self)->f->joinSmallString(self, delim)
8083 #define joinSmallStringG joinSmallStringO
8084 
8085 #define joinCharSO(self, c) (self)->f->joinCharS(self, c)
8086 #define joinCharSG joinCharSO
8087 
8088 #define joinSmallJsonSO(self, delim) (self)->f->joinSmallJsonS(self, delim)
8089 #define joinSmallJsonSG joinSmallJsonSO
8090 
8091 #define joinSmallStringSO(self, delim) (self)->f->joinSmallStringS(self, delim)
8092 #define joinSmallStringSG joinSmallStringSO
8093 
8094 #define zipSmallJsonSmallJsonO(self, array1, array2) (self)->f->zipSmallJsonSmallJson(self, array1, array2)
8095 #define zipSmallJsonSmallJsonG zipSmallJsonSmallJsonO
8096 
8097 #define zipSmallJsonCharO(self, array1, array2) (self)->f->zipSmallJsonChar(self, array1, array2)
8098 #define zipSmallJsonCharG zipSmallJsonCharO
8099 
8100 #define zipSmallJsonCCharO(self, array1, array2) (self)->f->zipSmallJsonCChar(self, array1, array2)
8101 #define zipSmallJsonCCharG zipSmallJsonCCharO
8102 
8103 #define zipArrayO(self, array1, array2) (self)->f->zipArray(self, array1, array2)
8104 #define zipArrayG zipArrayO
8105 
8106 #define zipCArrayO(self, array1, array2) (self)->f->zipCArray(self, array1, array2)
8107 #define zipCArrayG zipCArrayO
8108 
8109 #define zipCharO(self, array1, array2) (self)->f->zipChar(self, array1, array2)
8110 #define zipCharG zipCharO
8111 
8112 #define zipCCharO(self, array1, array2) (self)->f->zipCChar(self, array1, array2)
8113 #define zipCCharG zipCCharO
8114 
8115 #define zipArrayCharO(self, array1, array2) (self)->f->zipArrayChar(self, array1, array2)
8116 #define zipArrayCharG zipArrayCharO
8117 
8118 #define zipCArrayCharO(self, array1, array2) (self)->f->zipCArrayChar(self, array1, array2)
8119 #define zipCArrayCharG zipCArrayCharO
8120 
8121 #define zipArrayCCharO(self, array1, array2) (self)->f->zipArrayCChar(self, array1, array2)
8122 #define zipArrayCCharG zipArrayCCharO
8123 
8124 #define zipCArrayCCharO(self, array1, array2) (self)->f->zipCArrayCChar(self, array1, array2)
8125 #define zipCArrayCCharG zipCArrayCCharO
8126 
8127 #define readTextSmallStringO(self, filePath) (self)->f->readTextSmallString(self, filePath)
8128 #define readTextSmallStringG readTextSmallStringO
8129 
8130 #define readStreamO(self, fp) (self)->f->readStream(self, fp)
8131 #define readStreamG readStreamO
8132 
8133 #define writeTextSmallStringO(self, filePath) (self)->f->writeTextSmallString(self, filePath)
8134 #define writeTextSmallStringG writeTextSmallStringO
8135 
8136 #define writeStreamO(self, fp) (self)->f->writeStream(self, fp)
8137 #define writeStreamG writeStreamO
8138 
8139 #define appendTextO(self, filePath) (self)->f->appendText(self, filePath)
8140 #define appendTextG appendTextO
8141 
8142 #define appendTextSmallStringO(self, filePath) (self)->f->appendTextSmallString(self, filePath)
8143 #define appendTextSmallStringG appendTextSmallStringO
8144 
8145 #define typeStringO(self, index) (self)->f->typeString(self, index)
8146 #define typeStringG typeStringO
8147 
8148 #define typeSmallStringO(self, index) (self)->f->typeSmallString(self, index)
8149 #define typeSmallStringG typeSmallStringO
8150 
8151 #define typeO(self, index) (self)->f->type(self, index)
8152 #define typeG typeO
8153 
8154 #define typeStringsO(self) (self)->f->typeStrings(self)
8155 #define typeStringsG typeStringsO
8156 
8157 #define typeSmallStringsO(self) (self)->f->typeSmallStrings(self)
8158 #define typeSmallStringsG typeSmallStringsO
8159 
8160 #define typesO(self) (self)->f->types(self)
8161 #define typesG typesO
8162 
8163 #define isETypeO(self, index, type) (self)->f->isEType(self, index, type)
8164 #define isETypeG isETypeO
8165 
8166 #define isEUndefinedO(self, index) (self)->f->isEUndefined(self, index)
8167 #define isEUndefinedG isEUndefinedO
8168 
8169 #define isEBoolO(self, index) (self)->f->isEBool(self, index)
8170 #define isEBoolG isEBoolO
8171 
8172 #define isEContainerO(self, index) (self)->f->isEContainer(self, index)
8173 #define isEContainerG isEContainerO
8174 
8175 #define isEDictO(self, index) (self)->f->isEDict(self, index)
8176 #define isEDictG isEDictO
8177 
8178 #define isEDoubleO(self, index) (self)->f->isEDouble(self, index)
8179 #define isEDoubleG isEDoubleO
8180 
8181 #define isEIntO(self, index) (self)->f->isEInt(self, index)
8182 #define isEIntG isEIntO
8183 
8184 #define isEStringO(self, index) (self)->f->isEString(self, index)
8185 #define isEStringG isEStringO
8186 
8187 #define isEFaststringO(self, index) (self)->f->isEFaststring(self, index)
8188 #define isEFaststringG isEFaststringO
8189 
8190 #define isEArrayO(self, index) (self)->f->isEArray(self, index)
8191 #define isEArrayG isEArrayO
8192 
8193 #define isEBytesO(self, index) (self)->f->isEBytes(self, index)
8194 #define isEBytesG isEBytesO
8195 
8196 #define areAllETypeO(self, type) (self)->f->areAllEType(self, type)
8197 #define areAllETypeG areAllETypeO
8198 
8199 #define areAllEUndefinedO(self) (self)->f->areAllEUndefined(self)
8200 #define areAllEUndefinedG areAllEUndefinedO
8201 
8202 #define areAllEBoolO(self) (self)->f->areAllEBool(self)
8203 #define areAllEBoolG areAllEBoolO
8204 
8205 #define areAllEContainerO(self) (self)->f->areAllEContainer(self)
8206 #define areAllEContainerG areAllEContainerO
8207 
8208 #define areAllEDictO(self) (self)->f->areAllEDict(self)
8209 #define areAllEDictG areAllEDictO
8210 
8211 #define areAllEDoubleO(self) (self)->f->areAllEDouble(self)
8212 #define areAllEDoubleG areAllEDoubleO
8213 
8214 #define areAllEIntO(self) (self)->f->areAllEInt(self)
8215 #define areAllEIntG areAllEIntO
8216 
8217 #define areAllEStringO(self) (self)->f->areAllEString(self)
8218 #define areAllEStringG areAllEStringO
8219 
8220 #define areAllEFaststringO(self) (self)->f->areAllEFaststring(self)
8221 #define areAllEFaststringG areAllEFaststringO
8222 
8223 #define areAllEArrayO(self) (self)->f->areAllEArray(self)
8224 #define areAllEArrayG areAllEArrayO
8225 
8226 #define areAllEBytesO(self) (self)->f->areAllEBytes(self)
8227 #define areAllEBytesG areAllEBytesO
8228 
8229 #define setInt64O(self, p2) (self)->f->setInt64(self, p2)
8230 #define setInt64G setInt64O
8231 
8232 #define setInt32O(self, p2) (self)->f->setInt32(self, p2)
8233 #define setInt32G setInt32O
8234 
8235 #define setUint32O(self, p2) (self)->f->setUint32(self, p2)
8236 #define setUint32G setUint32O
8237 
8238 #define setUint64O(self, p2) (self)->f->setUint64(self, p2)
8239 #define setUint64G setUint64O
8240 
8241 #define equalCharO(self, p2) (self)->f->equalChar(self, p2)
8242 #define equalCharG equalCharO
8243 
8244 #define equalBoolO(self, p2) (self)->f->equalBool(self, p2)
8245 #define equalBoolG equalBoolO
8246 
8247 #define equalDoubleO(self, p2) (self)->f->equalDouble(self, p2)
8248 #define equalDoubleG equalDoubleO
8249 
8250 #define equalInt64O(self, p2) (self)->f->equalInt64(self, p2)
8251 #define equalInt64G equalInt64O
8252 
8253 #define equalInt32O(self, p2) (self)->f->equalInt32(self, p2)
8254 #define equalInt32G equalInt32O
8255 
8256 #define equalUint32O(self, p2) (self)->f->equalUint32(self, p2)
8257 #define equalUint32G equalUint32O
8258 
8259 #define equalUint64O(self, p2) (self)->f->equalUint64(self, p2)
8260 #define equalUint64G equalUint64O
8261 
8262 #define equalSmallDoubleO(self, p2) (self)->f->equalSmallDouble(self, p2)
8263 #define equalSmallDoubleG equalSmallDoubleO
8264 
8265 #define equalSmallIntO(self, p2) (self)->f->equalSmallInt(self, p2)
8266 #define equalSmallIntG equalSmallIntO
8267 
8268 #define equalSmallStringO(self, p2) (self)->f->equalSmallString(self, p2)
8269 #define equalSmallStringG equalSmallStringO
8270 
8271 #define appendFileSmallStringO(self, filePath) (self)->f->appendFileSmallString(self, filePath)
8272 #define appendFileSmallStringG appendFileSmallStringO
8273 
8274 #define equalSmallBoolO(self, value) (self)->f->equalSmallBool(self, value)
8275 #define equalSmallBoolG equalSmallBoolO
8276 
8277 #define setClassDataFreeO(self, free) (self)->f->setClassDataFree(self, free)
8278 #define setClassDataFreeG setClassDataFreeO
8279 
8280 #define setObjectDataFreeO(self, free) (self)->f->setObjectDataFree(self, free)
8281 #define setObjectDataFreeG setObjectDataFreeO
8282 
8283 #define setClassDataToStringO(self, toString) (self)->f->setClassDataToString(self, toString)
8284 #define setClassDataToStringG setClassDataToStringO
8285 
8286 #define setObjectDataToStringO(self, toString) (self)->f->setObjectDataToString(self, toString)
8287 #define setObjectDataToStringG setObjectDataToStringO
8288 
8289 #define setClassDataDuplicateO(self, duplicate) (self)->f->setClassDataDuplicate(self, duplicate)
8290 #define setClassDataDuplicateG setClassDataDuplicateO
8291 
8292 #define setObjectDataDuplicateO(self, duplicate) (self)->f->setObjectDataDuplicate(self, duplicate)
8293 #define setObjectDataDuplicateG setObjectDataDuplicateO
8294 
8295 #define setCharO(self, key, c) (self)->f->setChar(self, key, c)
8296 #define setCharG setCharO
8297 
8298 #define setArraycO(self, key, array) (self)->f->setArrayc(self, key, array)
8299 #define setArraycG setArraycO
8300 
8301 #define setCArraycO(self, key, array) (self)->f->setCArrayc(self, key, array)
8302 #define setCArraycG setCArraycO
8303 
8304 #define setKCharO(self, key, value) (self)->f->setKChar(self, key, value)
8305 #define setKCharG setKCharO
8306 
8307 #define setUndefinedKCharO(self, key) (self)->f->setUndefinedKChar(self, key)
8308 #define setUndefinedKCharG setUndefinedKCharO
8309 
8310 #define setBoolKCharO(self, key, value) (self)->f->setBoolKChar(self, key, value)
8311 #define setBoolKCharG setBoolKCharO
8312 
8313 #define setDoubleKCharO(self, key, value) (self)->f->setDoubleKChar(self, key, value)
8314 #define setDoubleKCharG setDoubleKCharO
8315 
8316 #define setIntKCharO(self, key, value) (self)->f->setIntKChar(self, key, value)
8317 #define setIntKCharG setIntKCharO
8318 
8319 #define setSKCharO(self, key, string) (self)->f->setSKChar(self, key, string)
8320 #define setSKCharG setSKCharO
8321 
8322 #define setCharKCharO(self, key, c) (self)->f->setCharKChar(self, key, c)
8323 #define setCharKCharG setCharKCharO
8324 
8325 #define setDictKCharO(self, key, dict) (self)->f->setDictKChar(self, key, dict)
8326 #define setDictKCharG setDictKCharO
8327 
8328 #define setArrayKCharO(self, key, array) (self)->f->setArrayKChar(self, key, array)
8329 #define setArrayKCharG setArrayKCharO
8330 
8331 #define setArraycKCharO(self, key, array) (self)->f->setArraycKChar(self, key, array)
8332 #define setArraycKCharG setArraycKCharO
8333 
8334 #define setCArraycKCharO(self, key, array) (self)->f->setCArraycKChar(self, key, array)
8335 #define setCArraycKCharG setCArraycKCharO
8336 
8337 #define setSmallBoolKCharO(self, key, value) (self)->f->setSmallBoolKChar(self, key, value)
8338 #define setSmallBoolKCharG setSmallBoolKCharO
8339 
8340 #define setSmallBytesKCharO(self, key, value) (self)->f->setSmallBytesKChar(self, key, value)
8341 #define setSmallBytesKCharG setSmallBytesKCharO
8342 
8343 #define setSmallDoubleKCharO(self, key, value) (self)->f->setSmallDoubleKChar(self, key, value)
8344 #define setSmallDoubleKCharG setSmallDoubleKCharO
8345 
8346 #define setSmallIntKCharO(self, key, value) (self)->f->setSmallIntKChar(self, key, value)
8347 #define setSmallIntKCharG setSmallIntKCharO
8348 
8349 #define setSmallJsonKCharO(self, key, value) (self)->f->setSmallJsonKChar(self, key, value)
8350 #define setSmallJsonKCharG setSmallJsonKCharO
8351 
8352 #define setSmallStringKCharO(self, key, string) (self)->f->setSmallStringKChar(self, key, string)
8353 #define setSmallStringKCharG setSmallStringKCharO
8354 
8355 #define setSmallContainerKCharO(self, key, container) (self)->f->setSmallContainerKChar(self, key, container)
8356 #define setSmallContainerKCharG setSmallContainerKCharO
8357 
8358 #define setNFreeArraycO(self, key, array) (self)->f->setNFreeArrayc(self, key, array)
8359 #define setNFreeArraycG setNFreeArraycO
8360 
8361 #define setNFreeSmallBytesO(self, key, value) (self)->f->setNFreeSmallBytes(self, key, value)
8362 #define setNFreeSmallBytesG setNFreeSmallBytesO
8363 
8364 #define setNFreeKCharO(self, key, value) (self)->f->setNFreeKChar(self, key, value)
8365 #define setNFreeKCharG setNFreeKCharO
8366 
8367 #define setNFreeUndefinedKCharO(self, key, u) (self)->f->setNFreeUndefinedKChar(self, key, u)
8368 #define setNFreeUndefinedKCharG setNFreeUndefinedKCharO
8369 
8370 #define setNFreeSKCharO(self, key, string) (self)->f->setNFreeSKChar(self, key, string)
8371 #define setNFreeSKCharG setNFreeSKCharO
8372 
8373 #define setNFreeDictKCharO(self, key, dict) (self)->f->setNFreeDictKChar(self, key, dict)
8374 #define setNFreeDictKCharG setNFreeDictKCharO
8375 
8376 #define setNFreeArrayKCharO(self, key, array) (self)->f->setNFreeArrayKChar(self, key, array)
8377 #define setNFreeArrayKCharG setNFreeArrayKCharO
8378 
8379 #define setNFreeArraycKCharO(self, key, array) (self)->f->setNFreeArraycKChar(self, key, array)
8380 #define setNFreeArraycKCharG setNFreeArraycKCharO
8381 
8382 #define setNFreeSmallBoolKCharO(self, key, value) (self)->f->setNFreeSmallBoolKChar(self, key, value)
8383 #define setNFreeSmallBoolKCharG setNFreeSmallBoolKCharO
8384 
8385 #define setNFreeSmallBytesKCharO(self, key, value) (self)->f->setNFreeSmallBytesKChar(self, key, value)
8386 #define setNFreeSmallBytesKCharG setNFreeSmallBytesKCharO
8387 
8388 #define setNFreeSmallDoubleKCharO(self, key, value) (self)->f->setNFreeSmallDoubleKChar(self, key, value)
8389 #define setNFreeSmallDoubleKCharG setNFreeSmallDoubleKCharO
8390 
8391 #define setNFreeSmallIntKCharO(self, key, value) (self)->f->setNFreeSmallIntKChar(self, key, value)
8392 #define setNFreeSmallIntKCharG setNFreeSmallIntKCharO
8393 
8394 #define setNFreeSmallJsonKCharO(self, key, value) (self)->f->setNFreeSmallJsonKChar(self, key, value)
8395 #define setNFreeSmallJsonKCharG setNFreeSmallJsonKCharO
8396 
8397 #define setNFreeSmallStringKCharO(self, key, string) (self)->f->setNFreeSmallStringKChar(self, key, string)
8398 #define setNFreeSmallStringKCharG setNFreeSmallStringKCharO
8399 
8400 #define setNFreeSmallContainerKCharO(self, key, container) (self)->f->setNFreeSmallContainerKChar(self, key, container)
8401 #define setNFreeSmallContainerKCharG setNFreeSmallContainerKCharO
8402 
8403 #define setPSmallJsonO(self, key, json) (self)->f->setPSmallJson(self, key, json)
8404 #define setPSmallJsonG setPSmallJsonO
8405 
8406 #define setNFreePSmallJsonO(self, key, json) (self)->f->setNFreePSmallJson(self, key, json)
8407 #define setNFreePSmallJsonG setNFreePSmallJsonO
8408 
8409 #define setPArrayKCharO(self, key, array) (self)->f->setPArrayKChar(self, key, array)
8410 #define setPArrayKCharG setPArrayKCharO
8411 
8412 #define setPDictKCharO(self, key, dict) (self)->f->setPDictKChar(self, key, dict)
8413 #define setPDictKCharG setPDictKCharO
8414 
8415 #define setPSmallJsonKCharO(self, key, json) (self)->f->setPSmallJsonKChar(self, key, json)
8416 #define setPSmallJsonKCharG setPSmallJsonKCharO
8417 
8418 #define setPSmallStringKCharO(self, key, string) (self)->f->setPSmallStringKChar(self, key, string)
8419 #define setPSmallStringKCharG setPSmallStringKCharO
8420 
8421 #define setNFreePArrayKCharO(self, key, array) (self)->f->setNFreePArrayKChar(self, key, array)
8422 #define setNFreePArrayKCharG setNFreePArrayKCharO
8423 
8424 #define setNFreePDictKCharO(self, key, dict) (self)->f->setNFreePDictKChar(self, key, dict)
8425 #define setNFreePDictKCharG setNFreePDictKCharO
8426 
8427 #define setNFreePSmallJsonKCharO(self, key, json) (self)->f->setNFreePSmallJsonKChar(self, key, json)
8428 #define setNFreePSmallJsonKCharG setNFreePSmallJsonKCharO
8429 
8430 #define setNFreePSmallStringKCharO(self, key, string) (self)->f->setNFreePSmallStringKChar(self, key, string)
8431 #define setNFreePSmallStringKCharG setNFreePSmallStringKCharO
8432 
8433 #define getSmallBytesO(self, key) (self)->f->getSmallBytes(self, key)
8434 #define getSmallBytesG getSmallBytesO
8435 
8436 #define getKCharO(self, key) (self)->f->getKChar(self, key)
8437 #define getKCharG getKCharO
8438 
8439 #define getUndefinedKCharO(self, key) (self)->f->getUndefinedKChar(self, key)
8440 #define getUndefinedKCharG getUndefinedKCharO
8441 
8442 #define getBoolKCharO(self, key) (self)->f->getBoolKChar(self, key)
8443 #define getBoolKCharG getBoolKCharO
8444 
8445 #define getBoolPKCharO(self, key) (self)->f->getBoolPKChar(self, key)
8446 #define getBoolPKCharG getBoolPKCharO
8447 
8448 #define getDoubleKCharO(self, key) (self)->f->getDoubleKChar(self, key)
8449 #define getDoubleKCharG getDoubleKCharO
8450 
8451 #define getDoublePKCharO(self, key) (self)->f->getDoublePKChar(self, key)
8452 #define getDoublePKCharG getDoublePKCharO
8453 
8454 #define getIntKCharO(self, key) (self)->f->getIntKChar(self, key)
8455 #define getIntKCharG getIntKCharO
8456 
8457 #define getIntPKCharO(self, key) (self)->f->getIntPKChar(self, key)
8458 #define getIntPKCharG getIntPKCharO
8459 
8460 #define getInt32KCharO(self, key) (self)->f->getInt32KChar(self, key)
8461 #define getInt32KCharG getInt32KCharO
8462 
8463 #define getInt32PKCharO(self, key) (self)->f->getInt32PKChar(self, key)
8464 #define getInt32PKCharG getInt32PKCharO
8465 
8466 #define getUintKCharO(self, key) (self)->f->getUintKChar(self, key)
8467 #define getUintKCharG getUintKCharO
8468 
8469 #define getUintPKCharO(self, key) (self)->f->getUintPKChar(self, key)
8470 #define getUintPKCharG getUintPKCharO
8471 
8472 #define getUint32KCharO(self, key) (self)->f->getUint32KChar(self, key)
8473 #define getUint32KCharG getUint32KCharO
8474 
8475 #define getUint32PKCharO(self, key) (self)->f->getUint32PKChar(self, key)
8476 #define getUint32PKCharG getUint32PKCharO
8477 
8478 #define getSKCharO(self, key) (self)->f->getSKChar(self, key)
8479 #define getSKCharG getSKCharO
8480 
8481 #define getDictKCharO(self, key) (self)->f->getDictKChar(self, key)
8482 #define getDictKCharG getDictKCharO
8483 
8484 #define getArrayKCharO(self, key) (self)->f->getArrayKChar(self, key)
8485 #define getArrayKCharG getArrayKCharO
8486 
8487 #define getSmallBoolKCharO(self, key) (self)->f->getSmallBoolKChar(self, key)
8488 #define getSmallBoolKCharG getSmallBoolKCharO
8489 
8490 #define getSmallBytesKCharO(self, key) (self)->f->getSmallBytesKChar(self, key)
8491 #define getSmallBytesKCharG getSmallBytesKCharO
8492 
8493 #define getSmallDoubleKCharO(self, key) (self)->f->getSmallDoubleKChar(self, key)
8494 #define getSmallDoubleKCharG getSmallDoubleKCharO
8495 
8496 #define getSmallIntKCharO(self, key) (self)->f->getSmallIntKChar(self, key)
8497 #define getSmallIntKCharG getSmallIntKCharO
8498 
8499 #define getSmallJsonKCharO(self, key) (self)->f->getSmallJsonKChar(self, key)
8500 #define getSmallJsonKCharG getSmallJsonKCharO
8501 
8502 #define getSmallStringKCharO(self, key) (self)->f->getSmallStringKChar(self, key)
8503 #define getSmallStringKCharG getSmallStringKCharO
8504 
8505 #define getVoidKCharO(self, key) (self)->f->getVoidKChar(self, key)
8506 #define getVoidKCharG getVoidKCharO
8507 
8508 #define getSmallContainerKCharO(self, key) (self)->f->getSmallContainerKChar(self, key)
8509 #define getSmallContainerKCharG getSmallContainerKCharO
8510 
8511 #define getNDupSmallBytesO(self, key) (self)->f->getNDupSmallBytes(self, key)
8512 #define getNDupSmallBytesG getNDupSmallBytesO
8513 
8514 #define getNDupKCharO(self, key) (self)->f->getNDupKChar(self, key)
8515 #define getNDupKCharG getNDupKCharO
8516 
8517 #define getNDupUndefinedKCharO(self, key) (self)->f->getNDupUndefinedKChar(self, key)
8518 #define getNDupUndefinedKCharG getNDupUndefinedKCharO
8519 
8520 #define getNDupBoolKCharO(self, key) (self)->f->getNDupBoolKChar(self, key)
8521 #define getNDupBoolKCharG getNDupBoolKCharO
8522 
8523 #define getNDupDoubleKCharO(self, key) (self)->f->getNDupDoubleKChar(self, key)
8524 #define getNDupDoubleKCharG getNDupDoubleKCharO
8525 
8526 #define getNDupIntKCharO(self, key) (self)->f->getNDupIntKChar(self, key)
8527 #define getNDupIntKCharG getNDupIntKCharO
8528 
8529 #define getNDupInt32KCharO(self, key) (self)->f->getNDupInt32KChar(self, key)
8530 #define getNDupInt32KCharG getNDupInt32KCharO
8531 
8532 #define getNDupUintKCharO(self, key) (self)->f->getNDupUintKChar(self, key)
8533 #define getNDupUintKCharG getNDupUintKCharO
8534 
8535 #define getNDupUint32KCharO(self, key) (self)->f->getNDupUint32KChar(self, key)
8536 #define getNDupUint32KCharG getNDupUint32KCharO
8537 
8538 #define getNDupSKCharO(self, key) (self)->f->getNDupSKChar(self, key)
8539 #define getNDupSKCharG getNDupSKCharO
8540 
8541 #define getNDupDictKCharO(self, key) (self)->f->getNDupDictKChar(self, key)
8542 #define getNDupDictKCharG getNDupDictKCharO
8543 
8544 #define getNDupArrayKCharO(self, key) (self)->f->getNDupArrayKChar(self, key)
8545 #define getNDupArrayKCharG getNDupArrayKCharO
8546 
8547 #define getNDupSmallBoolKCharO(self, key) (self)->f->getNDupSmallBoolKChar(self, key)
8548 #define getNDupSmallBoolKCharG getNDupSmallBoolKCharO
8549 
8550 #define getNDupSmallBytesKCharO(self, key) (self)->f->getNDupSmallBytesKChar(self, key)
8551 #define getNDupSmallBytesKCharG getNDupSmallBytesKCharO
8552 
8553 #define getNDupSmallDoubleKCharO(self, key) (self)->f->getNDupSmallDoubleKChar(self, key)
8554 #define getNDupSmallDoubleKCharG getNDupSmallDoubleKCharO
8555 
8556 #define getNDupSmallIntKCharO(self, key) (self)->f->getNDupSmallIntKChar(self, key)
8557 #define getNDupSmallIntKCharG getNDupSmallIntKCharO
8558 
8559 #define getNDupSmallJsonKCharO(self, key) (self)->f->getNDupSmallJsonKChar(self, key)
8560 #define getNDupSmallJsonKCharG getNDupSmallJsonKCharO
8561 
8562 #define getNDupSmallStringKCharO(self, key) (self)->f->getNDupSmallStringKChar(self, key)
8563 #define getNDupSmallStringKCharG getNDupSmallStringKCharO
8564 
8565 #define getNDupVoidKCharO(self, key) (self)->f->getNDupVoidKChar(self, key)
8566 #define getNDupVoidKCharG getNDupVoidKCharO
8567 
8568 #define getNDupSmallContainerKCharO(self, key) (self)->f->getNDupSmallContainerKChar(self, key)
8569 #define getNDupSmallContainerKCharG getNDupSmallContainerKCharO
8570 
8571 #define delKCharO(self, key) (self)->f->delKChar(self, key)
8572 #define delKCharG delKCharO
8573 
8574 #define removeKCharO(self, key) (self)->f->removeKChar(self, key)
8575 #define removeKCharG removeKCharO
8576 
8577 #define hasKCharO(self, key) (self)->f->hasKChar(self, key)
8578 #define hasKCharG hasKCharO
8579 
8580 #define keyByUndefinedO(self, u) (self)->f->keyByUndefined(self, u)
8581 #define keyByUndefinedG keyByUndefinedO
8582 
8583 #define keyByBoolO(self, value) (self)->f->keyByBool(self, value)
8584 #define keyByBoolG keyByBoolO
8585 
8586 #define keyByDoubleO(self, value) (self)->f->keyByDouble(self, value)
8587 #define keyByDoubleG keyByDoubleO
8588 
8589 #define keyByIntO(self, value) (self)->f->keyByInt(self, value)
8590 #define keyByIntG keyByIntO
8591 
8592 #define keyBySO(self, string) (self)->f->keyByS(self, string)
8593 #define keyBySG keyBySO
8594 
8595 #define keyByCharO(self, c) (self)->f->keyByChar(self, c)
8596 #define keyByCharG keyByCharO
8597 
8598 #define keyByDictO(self, dict) (self)->f->keyByDict(self, dict)
8599 #define keyByDictG keyByDictO
8600 
8601 #define keyByArrayO(self, array) (self)->f->keyByArray(self, array)
8602 #define keyByArrayG keyByArrayO
8603 
8604 #define keyByArraycO(self, array) (self)->f->keyByArrayc(self, array)
8605 #define keyByArraycG keyByArraycO
8606 
8607 #define keyByCArraycO(self, array) (self)->f->keyByCArrayc(self, array)
8608 #define keyByCArraycG keyByCArraycO
8609 
8610 #define keyBySmallBoolO(self, value) (self)->f->keyBySmallBool(self, value)
8611 #define keyBySmallBoolG keyBySmallBoolO
8612 
8613 #define keyBySmallBytesO(self, value) (self)->f->keyBySmallBytes(self, value)
8614 #define keyBySmallBytesG keyBySmallBytesO
8615 
8616 #define keyBySmallDoubleO(self, value) (self)->f->keyBySmallDouble(self, value)
8617 #define keyBySmallDoubleG keyBySmallDoubleO
8618 
8619 #define keyBySmallIntO(self, value) (self)->f->keyBySmallInt(self, value)
8620 #define keyBySmallIntG keyBySmallIntO
8621 
8622 #define keyBySmallStringO(self, string) (self)->f->keyBySmallString(self, string)
8623 #define keyBySmallStringG keyBySmallStringO
8624 
8625 #define keyBySmallContainerO(self, container) (self)->f->keyBySmallContainer(self, container)
8626 #define keyBySmallContainerG keyBySmallContainerO
8627 
8628 #define icKeyBySO(self, string) (self)->f->icKeyByS(self, string)
8629 #define icKeyBySG icKeyBySO
8630 
8631 #define icKeyByCharO(self, c) (self)->f->icKeyByChar(self, c)
8632 #define icKeyByCharG icKeyByCharO
8633 
8634 #define icKeyByDictO(self, dict) (self)->f->icKeyByDict(self, dict)
8635 #define icKeyByDictG icKeyByDictO
8636 
8637 #define icKeyByArrayO(self, array) (self)->f->icKeyByArray(self, array)
8638 #define icKeyByArrayG icKeyByArrayO
8639 
8640 #define icKeyByArraycO(self, array) (self)->f->icKeyByArrayc(self, array)
8641 #define icKeyByArraycG icKeyByArraycO
8642 
8643 #define icKeyByCArraycO(self, array) (self)->f->icKeyByCArrayc(self, array)
8644 #define icKeyByCArraycG icKeyByCArraycO
8645 
8646 #define icKeyBySmallStringO(self, string) (self)->f->icKeyBySmallString(self, string)
8647 #define icKeyBySmallStringG icKeyBySmallStringO
8648 
8649 #define keysO(self) (self)->f->keys(self)
8650 #define keysG keysO
8651 
8652 #define keysSmallStringO(self) (self)->f->keysSmallString(self)
8653 #define keysSmallStringG keysSmallStringO
8654 
8655 #define valuesO(self) (self)->f->values(self)
8656 #define valuesG valuesO
8657 
8658 #define icEqualBaseO(self, p2) (self)->f->icEqualBase(self, p2)
8659 #define icEqualBaseG icEqualBaseO
8660 
8661 #define iterStartKeyO(self) (self)->f->iterStartKey(self)
8662 #define iterStartKeyG iterStartKeyO
8663 
8664 #define iterNextKeyO(self) (self)->f->iterNextKey(self)
8665 #define iterNextKeyG iterNextKeyO
8666 
8667 #define iterKeyO(self) (self)->f->iterKey(self)
8668 #define iterKeyG iterKeyO
8669 
8670 #define zipSmallJsonVArrayO(self, keys, values) (self)->f->zipSmallJsonVArray(self, keys, values)
8671 #define zipSmallJsonVArrayG zipSmallJsonVArrayO
8672 
8673 #define zipSmallJsonVCArrayO(self, keys, values) (self)->f->zipSmallJsonVCArray(self, keys, values)
8674 #define zipSmallJsonVCArrayG zipSmallJsonVCArrayO
8675 
8676 #define zipArrayArrayO(self, keys, values) (self)->f->zipArrayArray(self, keys, values)
8677 #define zipArrayArrayG zipArrayArrayO
8678 
8679 #define zipCArrayArrayO(self, keys, values) (self)->f->zipCArrayArray(self, keys, values)
8680 #define zipCArrayArrayG zipCArrayArrayO
8681 
8682 #define zipArrayCArrayO(self, keys, values) (self)->f->zipArrayCArray(self, keys, values)
8683 #define zipArrayCArrayG zipArrayCArrayO
8684 
8685 #define zipCArrayCArrayO(self, keys, values) (self)->f->zipCArrayCArray(self, keys, values)
8686 #define zipCArrayCArrayG zipCArrayCArrayO
8687 
8688 #define zipVArrayO(self, keys, values) (self)->f->zipVArray(self, keys, values)
8689 #define zipVArrayG zipVArrayO
8690 
8691 #define zipVCArrayO(self, keys, values) (self)->f->zipVCArray(self, keys, values)
8692 #define zipVCArrayG zipVCArrayO
8693 
8694 #define toArrayO(self) (self)->f->toArray(self)
8695 #define toArrayG toArrayO
8696 
8697 #define typeStringKCharO(self, key) (self)->f->typeStringKChar(self, key)
8698 #define typeStringKCharG typeStringKCharO
8699 
8700 #define typeSmallStringKCharO(self, key) (self)->f->typeSmallStringKChar(self, key)
8701 #define typeSmallStringKCharG typeSmallStringKCharO
8702 
8703 #define typeKCharO(self, key) (self)->f->typeKChar(self, key)
8704 #define typeKCharG typeKCharO
8705 
8706 #define equalChaO(self, p2) (self)->f->equalCha(self, p2)
8707 #define equalChaG equalChaO
8708 
8709 #define getTopTypeO(self) (self)->f->getTopType(self)
8710 #define getTopTypeG getTopTypeO
8711 
8712 #define setTypeUndefinedO(self) (self)->f->setTypeUndefined(self)
8713 #define setTypeUndefinedG setTypeUndefinedO
8714 
8715 #define setTypeBoolO(self) (self)->f->setTypeBool(self)
8716 #define setTypeBoolG setTypeBoolO
8717 
8718 #define setTypeDoubleO(self) (self)->f->setTypeDouble(self)
8719 #define setTypeDoubleG setTypeDoubleO
8720 
8721 #define setTypeIntO(self) (self)->f->setTypeInt(self)
8722 #define setTypeIntG setTypeIntO
8723 
8724 #define setTypeStringO(self) (self)->f->setTypeString(self)
8725 #define setTypeStringG setTypeStringO
8726 
8727 #define setTypeDictO(self) (self)->f->setTypeDict(self)
8728 #define setTypeDictG setTypeDictO
8729 
8730 #define setTypeArrayO(self) (self)->f->setTypeArray(self)
8731 #define setTypeArrayG setTypeArrayO
8732 
8733 #define setTopBoolO(self, value) (self)->f->setTopBool(self, value)
8734 #define setTopBoolG setTopBoolO
8735 
8736 #define setTopDoubleO(self, value) (self)->f->setTopDouble(self, value)
8737 #define setTopDoubleG setTopDoubleO
8738 
8739 #define setTopIntO(self, value) (self)->f->setTopInt(self, value)
8740 #define setTopIntG setTopIntO
8741 
8742 #define setTopStringO(self, value) (self)->f->setTopString(self, value)
8743 #define setTopStringG setTopStringO
8744 
8745 #define setTopCharO(self, c) (self)->f->setTopChar(self, c)
8746 #define setTopCharG setTopCharO
8747 
8748 #define setTopDictO(self, value) (self)->f->setTopDict(self, value)
8749 #define setTopDictG setTopDictO
8750 
8751 #define setTopArrayO(self, value) (self)->f->setTopArray(self, value)
8752 #define setTopArrayG setTopArrayO
8753 
8754 #define setTopArraycO(self, value) (self)->f->setTopArrayc(self, value)
8755 #define setTopArraycG setTopArraycO
8756 
8757 #define setTopCArraycO(self, value) (self)->f->setTopCArrayc(self, value)
8758 #define setTopCArraycG setTopCArraycO
8759 
8760 #define setTopSmallBoolO(self, value) (self)->f->setTopSmallBool(self, value)
8761 #define setTopSmallBoolG setTopSmallBoolO
8762 
8763 #define setTopSmallDoubleO(self, value) (self)->f->setTopSmallDouble(self, value)
8764 #define setTopSmallDoubleG setTopSmallDoubleO
8765 
8766 #define setTopSmallIntO(self, value) (self)->f->setTopSmallInt(self, value)
8767 #define setTopSmallIntG setTopSmallIntO
8768 
8769 #define setTopSmallStringO(self, value) (self)->f->setTopSmallString(self, value)
8770 #define setTopSmallStringG setTopSmallStringO
8771 
8772 #define setTopNFreeBoolO(self, value) (self)->f->setTopNFreeBool(self, value)
8773 #define setTopNFreeBoolG setTopNFreeBoolO
8774 
8775 #define setTopNFreeDoubleO(self, value) (self)->f->setTopNFreeDouble(self, value)
8776 #define setTopNFreeDoubleG setTopNFreeDoubleO
8777 
8778 #define setTopNFreeIntO(self, value) (self)->f->setTopNFreeInt(self, value)
8779 #define setTopNFreeIntG setTopNFreeIntO
8780 
8781 #define setTopNFreeStringO(self, value) (self)->f->setTopNFreeString(self, value)
8782 #define setTopNFreeStringG setTopNFreeStringO
8783 
8784 #define setTopNFreeDictO(self, value) (self)->f->setTopNFreeDict(self, value)
8785 #define setTopNFreeDictG setTopNFreeDictO
8786 
8787 #define setTopNFreeArrayO(self, value) (self)->f->setTopNFreeArray(self, value)
8788 #define setTopNFreeArrayG setTopNFreeArrayO
8789 
8790 #define setTopNFreeArraycO(self, value) (self)->f->setTopNFreeArrayc(self, value)
8791 #define setTopNFreeArraycG setTopNFreeArraycO
8792 
8793 #define setTopNFreeSmallBoolO(self, value) (self)->f->setTopNFreeSmallBool(self, value)
8794 #define setTopNFreeSmallBoolG setTopNFreeSmallBoolO
8795 
8796 #define setTopNFreeSmallDoubleO(self, value) (self)->f->setTopNFreeSmallDouble(self, value)
8797 #define setTopNFreeSmallDoubleG setTopNFreeSmallDoubleO
8798 
8799 #define setTopNFreeSmallIntO(self, value) (self)->f->setTopNFreeSmallInt(self, value)
8800 #define setTopNFreeSmallIntG setTopNFreeSmallIntO
8801 
8802 #define setTopNFreeSmallStringO(self, value) (self)->f->setTopNFreeSmallString(self, value)
8803 #define setTopNFreeSmallStringG setTopNFreeSmallStringO
8804 
8805 #define fromArrayDictO(self, items) (self)->f->fromArrayDict(self, items)
8806 #define fromArrayDictG fromArrayDictO
8807 
8808 #define toArrayDictO(self) (self)->f->toArrayDict(self)
8809 #define toArrayDictG toArrayDictO
8810 
8811 #define getTopUndefinedO(self) (self)->f->getTopUndefined(self)
8812 #define getTopUndefinedG getTopUndefinedO
8813 
8814 #define getTopBoolO(self) (self)->f->getTopBool(self)
8815 #define getTopBoolG getTopBoolO
8816 
8817 #define getTopBoolPO(self) (self)->f->getTopBoolP(self)
8818 #define getTopBoolPG getTopBoolPO
8819 
8820 #define getTopDoubleO(self) (self)->f->getTopDouble(self)
8821 #define getTopDoubleG getTopDoubleO
8822 
8823 #define getTopDoublePO(self) (self)->f->getTopDoubleP(self)
8824 #define getTopDoublePG getTopDoublePO
8825 
8826 #define getTopIntO(self) (self)->f->getTopInt(self)
8827 #define getTopIntG getTopIntO
8828 
8829 #define getTopIntPO(self) (self)->f->getTopIntP(self)
8830 #define getTopIntPG getTopIntPO
8831 
8832 #define getTopInt32O(self) (self)->f->getTopInt32(self)
8833 #define getTopInt32G getTopInt32O
8834 
8835 #define getTopInt32PO(self) (self)->f->getTopInt32P(self)
8836 #define getTopInt32PG getTopInt32PO
8837 
8838 #define getTopUintO(self) (self)->f->getTopUint(self)
8839 #define getTopUintG getTopUintO
8840 
8841 #define getTopUintPO(self) (self)->f->getTopUintP(self)
8842 #define getTopUintPG getTopUintPO
8843 
8844 #define getTopUint32O(self) (self)->f->getTopUint32(self)
8845 #define getTopUint32G getTopUint32O
8846 
8847 #define getTopUint32PO(self) (self)->f->getTopUint32P(self)
8848 #define getTopUint32PG getTopUint32PO
8849 
8850 #define getTopSO(self) (self)->f->getTopS(self)
8851 #define getTopSG getTopSO
8852 
8853 #define getTopDictO(self) (self)->f->getTopDict(self)
8854 #define getTopDictG getTopDictO
8855 
8856 #define getTopArrayO(self) (self)->f->getTopArray(self)
8857 #define getTopArrayG getTopArrayO
8858 
8859 #define getTopSmallBoolO(self) (self)->f->getTopSmallBool(self)
8860 #define getTopSmallBoolG getTopSmallBoolO
8861 
8862 #define getTopSmallDoubleO(self) (self)->f->getTopSmallDouble(self)
8863 #define getTopSmallDoubleG getTopSmallDoubleO
8864 
8865 #define getTopSmallIntO(self) (self)->f->getTopSmallInt(self)
8866 #define getTopSmallIntG getTopSmallIntO
8867 
8868 #define getTopSmallStringO(self) (self)->f->getTopSmallString(self)
8869 #define getTopSmallStringG getTopSmallStringO
8870 
8871 #define keyIsO(self, key) (self)->f->keyIs(self, key)
8872 #define keyIsG keyIsO
8873 
8874 #define keyIsSO(self, key) (self)->f->keyIsS(self, key)
8875 #define keyIsSG keyIsSO
8876 
8877 #define makeKeyO(self, key) (self)->f->makeKey(self, key)
8878 #define makeKeyG makeKeyO
8879 
8880 #define iMakeKeyO(self, key) (self)->f->iMakeKey(self, key)
8881 #define iMakeKeyG iMakeKeyO
8882 
8883 #define bMakeKeyO(self, dest, key) (self)->f->bMakeKey(self, dest, key)
8884 #define bMakeKeyG bMakeKeyO
8885 
8886 #define bLMakeKeyO(self, dest, size, key) (self)->f->bLMakeKey(self, dest, size, key)
8887 #define bLMakeKeyG bLMakeKeyO
8888 
8889 #define makeKeyLenO(self, key) (self)->f->makeKeyLen(self, key)
8890 #define makeKeyLenG makeKeyLenO
8891 
8892 #define mergeDictO(self, smallDict) (self)->f->mergeDict(self, smallDict)
8893 #define mergeDictG mergeDictO
8894 
8895 #define mergeDictNSmashO(self, smallDict) (self)->f->mergeDictNSmash(self, smallDict)
8896 #define mergeDictNSmashG mergeDictNSmashO
8897 
8898 #define addJsonO(self, array) (self)->f->addJson(self, array)
8899 #define addJsonG addJsonO
8900 
8901 #define cropSO(self, start, end) (self)->f->cropS(self, start, end)
8902 #define cropSG cropSO
8903 
8904 #define cropElemAtO(self, index) (self)->f->cropElemAt(self, index)
8905 #define cropElemAtG cropElemAtO
8906 
8907 #define cropElemAtUndefinedO(self, index) (self)->f->cropElemAtUndefined(self, index)
8908 #define cropElemAtUndefinedG cropElemAtUndefinedO
8909 
8910 #define cropElemAtBoolO(self, index) (self)->f->cropElemAtBool(self, index)
8911 #define cropElemAtBoolG cropElemAtBoolO
8912 
8913 #define cropElemAtDoubleO(self, index) (self)->f->cropElemAtDouble(self, index)
8914 #define cropElemAtDoubleG cropElemAtDoubleO
8915 
8916 #define cropElemAtIntO(self, index) (self)->f->cropElemAtInt(self, index)
8917 #define cropElemAtIntG cropElemAtIntO
8918 
8919 #define cropElemAtInt32O(self, index) (self)->f->cropElemAtInt32(self, index)
8920 #define cropElemAtInt32G cropElemAtInt32O
8921 
8922 #define cropElemAtUintO(self, index) (self)->f->cropElemAtUint(self, index)
8923 #define cropElemAtUintG cropElemAtUintO
8924 
8925 #define cropElemAtUint32O(self, index) (self)->f->cropElemAtUint32(self, index)
8926 #define cropElemAtUint32G cropElemAtUint32O
8927 
8928 #define cropElemAtSO(self, index) (self)->f->cropElemAtS(self, index)
8929 #define cropElemAtSG cropElemAtSO
8930 
8931 #define cropElemAtCharO(self, index) (self)->f->cropElemAtChar(self, index)
8932 #define cropElemAtCharG cropElemAtCharO
8933 
8934 #define cropElemAtDictO(self, index) (self)->f->cropElemAtDict(self, index)
8935 #define cropElemAtDictG cropElemAtDictO
8936 
8937 #define cropElemAtArrayO(self, index) (self)->f->cropElemAtArray(self, index)
8938 #define cropElemAtArrayG cropElemAtArrayO
8939 
8940 #define cropElemAtSmallBoolO(self, index) (self)->f->cropElemAtSmallBool(self, index)
8941 #define cropElemAtSmallBoolG cropElemAtSmallBoolO
8942 
8943 #define cropElemAtSmallBytesO(self, index) (self)->f->cropElemAtSmallBytes(self, index)
8944 #define cropElemAtSmallBytesG cropElemAtSmallBytesO
8945 
8946 #define cropElemAtSmallDoubleO(self, index) (self)->f->cropElemAtSmallDouble(self, index)
8947 #define cropElemAtSmallDoubleG cropElemAtSmallDoubleO
8948 
8949 #define cropElemAtSmallIntO(self, index) (self)->f->cropElemAtSmallInt(self, index)
8950 #define cropElemAtSmallIntG cropElemAtSmallIntO
8951 
8952 #define cropElemAtSmallStringO(self, index) (self)->f->cropElemAtSmallString(self, index)
8953 #define cropElemAtSmallStringG cropElemAtSmallStringO
8954 
8955 #define cropElemAtVoidO(self, index) (self)->f->cropElemAtVoid(self, index)
8956 #define cropElemAtVoidG cropElemAtVoidO
8957 
8958 #define cropElemAtSmallContainerO(self, index) (self)->f->cropElemAtSmallContainer(self, index)
8959 #define cropElemAtSmallContainerG cropElemAtSmallContainerO
8960 
8961 #define cropElemKeyO(self, key) (self)->f->cropElemKey(self, key)
8962 #define cropElemKeyG cropElemKeyO
8963 
8964 #define cropElemKeyUndefinedO(self, key) (self)->f->cropElemKeyUndefined(self, key)
8965 #define cropElemKeyUndefinedG cropElemKeyUndefinedO
8966 
8967 #define cropElemKeyBoolO(self, key) (self)->f->cropElemKeyBool(self, key)
8968 #define cropElemKeyBoolG cropElemKeyBoolO
8969 
8970 #define cropElemKeyDoubleO(self, key) (self)->f->cropElemKeyDouble(self, key)
8971 #define cropElemKeyDoubleG cropElemKeyDoubleO
8972 
8973 #define cropElemKeyIntO(self, key) (self)->f->cropElemKeyInt(self, key)
8974 #define cropElemKeyIntG cropElemKeyIntO
8975 
8976 #define cropElemKeyInt32O(self, key) (self)->f->cropElemKeyInt32(self, key)
8977 #define cropElemKeyInt32G cropElemKeyInt32O
8978 
8979 #define cropElemKeyUintO(self, key) (self)->f->cropElemKeyUint(self, key)
8980 #define cropElemKeyUintG cropElemKeyUintO
8981 
8982 #define cropElemKeyUint32O(self, key) (self)->f->cropElemKeyUint32(self, key)
8983 #define cropElemKeyUint32G cropElemKeyUint32O
8984 
8985 #define cropElemKeySO(self, key) (self)->f->cropElemKeyS(self, key)
8986 #define cropElemKeySG cropElemKeySO
8987 
8988 #define cropElemKeyDictO(self, key) (self)->f->cropElemKeyDict(self, key)
8989 #define cropElemKeyDictG cropElemKeyDictO
8990 
8991 #define cropElemKeyArrayO(self, key) (self)->f->cropElemKeyArray(self, key)
8992 #define cropElemKeyArrayG cropElemKeyArrayO
8993 
8994 #define cropElemKeySmallBoolO(self, key) (self)->f->cropElemKeySmallBool(self, key)
8995 #define cropElemKeySmallBoolG cropElemKeySmallBoolO
8996 
8997 #define cropElemKeySmallBytesO(self, key) (self)->f->cropElemKeySmallBytes(self, key)
8998 #define cropElemKeySmallBytesG cropElemKeySmallBytesO
8999 
9000 #define cropElemKeySmallDoubleO(self, key) (self)->f->cropElemKeySmallDouble(self, key)
9001 #define cropElemKeySmallDoubleG cropElemKeySmallDoubleO
9002 
9003 #define cropElemKeySmallIntO(self, key) (self)->f->cropElemKeySmallInt(self, key)
9004 #define cropElemKeySmallIntG cropElemKeySmallIntO
9005 
9006 #define cropElemKeySmallStringO(self, key) (self)->f->cropElemKeySmallString(self, key)
9007 #define cropElemKeySmallStringG cropElemKeySmallStringO
9008 
9009 #define cropElemKeyVoidO(self, key) (self)->f->cropElemKeyVoid(self, key)
9010 #define cropElemKeyVoidG cropElemKeyVoidO
9011 
9012 #define cropElemKeySmallContainerO(self, key) (self)->f->cropElemKeySmallContainer(self, key)
9013 #define cropElemKeySmallContainerG cropElemKeySmallContainerO
9014 
9015 #define insertStringO(self, index, toInsert) (self)->f->insertString(self, index, toInsert)
9016 #define insertStringG insertStringO
9017 
9018 #define insertSO(self, index, toInsert) (self)->f->insertS(self, index, toInsert)
9019 #define insertSG insertSO
9020 
9021 #define insertNFreeStringO(self, index, toInsert) (self)->f->insertNFreeString(self, index, toInsert)
9022 #define insertNFreeStringG insertNFreeStringO
9023 
9024 #define insertSNFreeO(self, index, toInsert) (self)->f->insertSNFree(self, index, toInsert)
9025 #define insertSNFreeG insertSNFreeO
9026 
9027 #define uniqCharO(self, c) (self)->f->uniqChar(self, c)
9028 #define uniqCharG uniqCharO
9029 
9030 #define icUniqCharO(self, c) (self)->f->icUniqChar(self, c)
9031 #define icUniqCharG icUniqCharO
9032 
9033 #define findCharO(self, c) (self)->f->findChar(self, c)
9034 #define findCharG findCharO
9035 
9036 #define findJsonO(self, needle) (self)->f->findJson(self, needle)
9037 #define findJsonG findJsonO
9038 
9039 #define icFindCharO(self, c) (self)->f->icFindChar(self, c)
9040 #define icFindCharG icFindCharO
9041 
9042 #define icFindJsonO(self, needle) (self)->f->icFindJson(self, needle)
9043 #define icFindJsonG icFindJsonO
9044 
9045 #define replaceCharSO(self, olds, news, max) (self)->f->replaceCharS(self, olds, news, max)
9046 #define replaceCharSG replaceCharSO
9047 
9048 #define replaceSCharO(self, olds, news, max) (self)->f->replaceSChar(self, olds, news, max)
9049 #define replaceSCharG replaceSCharO
9050 
9051 #define replaceCharCharO(self, olds, news, max) (self)->f->replaceCharChar(self, olds, news, max)
9052 #define replaceCharCharG replaceCharCharO
9053 
9054 #define replaceSmallStringSmallStringO(self, olds, news, max) (self)->f->replaceSmallStringSmallString(self, olds, news, max)
9055 #define replaceSmallStringSmallStringG replaceSmallStringSmallStringO
9056 
9057 #define replaceSmallStringSO(self, olds, news, max) (self)->f->replaceSmallStringS(self, olds, news, max)
9058 #define replaceSmallStringSG replaceSmallStringSO
9059 
9060 #define replaceSmallStringCharO(self, olds, news, max) (self)->f->replaceSmallStringChar(self, olds, news, max)
9061 #define replaceSmallStringCharG replaceSmallStringCharO
9062 
9063 #define replaceSSmallStringO(self, olds, news, max) (self)->f->replaceSSmallString(self, olds, news, max)
9064 #define replaceSSmallStringG replaceSSmallStringO
9065 
9066 #define replaceCharSmallStringO(self, olds, news, max) (self)->f->replaceCharSmallString(self, olds, news, max)
9067 #define replaceCharSmallStringG replaceCharSmallStringO
9068 
9069 #define replaceJsonJsonO(self, olds, news, max) (self)->f->replaceJsonJson(self, olds, news, max)
9070 #define replaceJsonJsonG replaceJsonJsonO
9071 
9072 #define replaceJsonSmallStringO(self, olds, news, max) (self)->f->replaceJsonSmallString(self, olds, news, max)
9073 #define replaceJsonSmallStringG replaceJsonSmallStringO
9074 
9075 #define replaceJsonSO(self, olds, news, max) (self)->f->replaceJsonS(self, olds, news, max)
9076 #define replaceJsonSG replaceJsonSO
9077 
9078 #define replaceJsonCharO(self, olds, news, max) (self)->f->replaceJsonChar(self, olds, news, max)
9079 #define replaceJsonCharG replaceJsonCharO
9080 
9081 #define replaceSmallStringJsonO(self, olds, news, max) (self)->f->replaceSmallStringJson(self, olds, news, max)
9082 #define replaceSmallStringJsonG replaceSmallStringJsonO
9083 
9084 #define replaceSJsonO(self, olds, news, max) (self)->f->replaceSJson(self, olds, news, max)
9085 #define replaceSJsonG replaceSJsonO
9086 
9087 #define replaceCharJsonO(self, olds, news, max) (self)->f->replaceCharJson(self, olds, news, max)
9088 #define replaceCharJsonG replaceCharJsonO
9089 
9090 #define icReplaceCharSO(self, olds, news, max) (self)->f->icReplaceCharS(self, olds, news, max)
9091 #define icReplaceCharSG icReplaceCharSO
9092 
9093 #define icReplaceSCharO(self, olds, news, max) (self)->f->icReplaceSChar(self, olds, news, max)
9094 #define icReplaceSCharG icReplaceSCharO
9095 
9096 #define icReplaceCharCharO(self, olds, news, max) (self)->f->icReplaceCharChar(self, olds, news, max)
9097 #define icReplaceCharCharG icReplaceCharCharO
9098 
9099 #define icReplaceSmallStringSmallStringO(self, olds, news, max) (self)->f->icReplaceSmallStringSmallString(self, olds, news, max)
9100 #define icReplaceSmallStringSmallStringG icReplaceSmallStringSmallStringO
9101 
9102 #define icReplaceSmallStringSO(self, olds, news, max) (self)->f->icReplaceSmallStringS(self, olds, news, max)
9103 #define icReplaceSmallStringSG icReplaceSmallStringSO
9104 
9105 #define icReplaceSmallStringCharO(self, olds, news, max) (self)->f->icReplaceSmallStringChar(self, olds, news, max)
9106 #define icReplaceSmallStringCharG icReplaceSmallStringCharO
9107 
9108 #define icReplaceSSmallStringO(self, olds, news, max) (self)->f->icReplaceSSmallString(self, olds, news, max)
9109 #define icReplaceSSmallStringG icReplaceSSmallStringO
9110 
9111 #define icReplaceCharSmallStringO(self, olds, news, max) (self)->f->icReplaceCharSmallString(self, olds, news, max)
9112 #define icReplaceCharSmallStringG icReplaceCharSmallStringO
9113 
9114 #define icReplaceJsonJsonO(self, olds, news, max) (self)->f->icReplaceJsonJson(self, olds, news, max)
9115 #define icReplaceJsonJsonG icReplaceJsonJsonO
9116 
9117 #define icReplaceJsonSmallStringO(self, olds, news, max) (self)->f->icReplaceJsonSmallString(self, olds, news, max)
9118 #define icReplaceJsonSmallStringG icReplaceJsonSmallStringO
9119 
9120 #define icReplaceJsonSO(self, olds, news, max) (self)->f->icReplaceJsonS(self, olds, news, max)
9121 #define icReplaceJsonSG icReplaceJsonSO
9122 
9123 #define icReplaceJsonCharO(self, olds, news, max) (self)->f->icReplaceJsonChar(self, olds, news, max)
9124 #define icReplaceJsonCharG icReplaceJsonCharO
9125 
9126 #define icReplaceSmallStringJsonO(self, olds, news, max) (self)->f->icReplaceSmallStringJson(self, olds, news, max)
9127 #define icReplaceSmallStringJsonG icReplaceSmallStringJsonO
9128 
9129 #define icReplaceSJsonO(self, olds, news, max) (self)->f->icReplaceSJson(self, olds, news, max)
9130 #define icReplaceSJsonG icReplaceSJsonO
9131 
9132 #define icReplaceCharJsonO(self, olds, news, max) (self)->f->icReplaceCharJson(self, olds, news, max)
9133 #define icReplaceCharJsonG icReplaceCharJsonO
9134 
9135 #define icEqualSmallStringO(self, string) (self)->f->icEqualSmallString(self, string)
9136 #define icEqualSmallStringG icEqualSmallStringO
9137 
9138 #define icEqualSO(self, string) (self)->f->icEqualS(self, string)
9139 #define icEqualSG icEqualSO
9140 
9141 #define icEqualCharO(self, c) (self)->f->icEqualChar(self, c)
9142 #define icEqualCharG icEqualCharO
9143 
9144 #define equalISO(self, string, index) (self)->f->equalIS(self, string, index)
9145 #define equalISG equalISO
9146 
9147 #define equalICharO(self, c, index) (self)->f->equalIChar(self, c, index)
9148 #define equalICharG equalICharO
9149 
9150 #define equalIJsonO(self, string, index) (self)->f->equalIJson(self, string, index)
9151 #define equalIJsonG equalIJsonO
9152 
9153 #define equalISmallStringO(self, string, index) (self)->f->equalISmallString(self, string, index)
9154 #define equalISmallStringG equalISmallStringO
9155 
9156 #define startsWithSO(self, string) (self)->f->startsWithS(self, string)
9157 #define startsWithSG startsWithSO
9158 
9159 #define startsWithCharO(self, c) (self)->f->startsWithChar(self, c)
9160 #define startsWithCharG startsWithCharO
9161 
9162 #define startsWithSmallStringO(self, string) (self)->f->startsWithSmallString(self, string)
9163 #define startsWithSmallStringG startsWithSmallStringO
9164 
9165 #define startsWithJsonO(self, string) (self)->f->startsWithJson(self, string)
9166 #define startsWithJsonG startsWithJsonO
9167 
9168 #define endsWithSO(self, string) (self)->f->endsWithS(self, string)
9169 #define endsWithSG endsWithSO
9170 
9171 #define endsWithCharO(self, c) (self)->f->endsWithChar(self, c)
9172 #define endsWithCharG endsWithCharO
9173 
9174 #define endsWithSmallStringO(self, string) (self)->f->endsWithSmallString(self, string)
9175 #define endsWithSmallStringG endsWithSmallStringO
9176 
9177 #define endsWithJsonO(self, string) (self)->f->endsWithJson(self, string)
9178 #define endsWithJsonG endsWithJsonO
9179 
9180 #define countSO(self, string) (self)->f->countS(self, string)
9181 #define countSG countSO
9182 
9183 #define countCharO(self, c) (self)->f->countChar(self, c)
9184 #define countCharG countCharO
9185 
9186 #define countSmallStringO(self, string) (self)->f->countSmallString(self, string)
9187 #define countSmallStringG countSmallStringO
9188 
9189 #define countJsonO(self, string) (self)->f->countJson(self, string)
9190 #define countJsonG countJsonO
9191 
9192 #define icStartsWithSO(self, string) (self)->f->icStartsWithS(self, string)
9193 #define icStartsWithSG icStartsWithSO
9194 
9195 #define icStartsWithCharO(self, c) (self)->f->icStartsWithChar(self, c)
9196 #define icStartsWithCharG icStartsWithCharO
9197 
9198 #define icStartsWithSmallStringO(self, string) (self)->f->icStartsWithSmallString(self, string)
9199 #define icStartsWithSmallStringG icStartsWithSmallStringO
9200 
9201 #define icStartsWithJsonO(self, string) (self)->f->icStartsWithJson(self, string)
9202 #define icStartsWithJsonG icStartsWithJsonO
9203 
9204 #define icEndsWithSO(self, string) (self)->f->icEndsWithS(self, string)
9205 #define icEndsWithSG icEndsWithSO
9206 
9207 #define icEndsWithCharO(self, c) (self)->f->icEndsWithChar(self, c)
9208 #define icEndsWithCharG icEndsWithCharO
9209 
9210 #define icEndsWithSmallStringO(self, string) (self)->f->icEndsWithSmallString(self, string)
9211 #define icEndsWithSmallStringG icEndsWithSmallStringO
9212 
9213 #define icEndsWithJsonO(self, string) (self)->f->icEndsWithJson(self, string)
9214 #define icEndsWithJsonG icEndsWithJsonO
9215 
9216 #define icCountSO(self, string) (self)->f->icCountS(self, string)
9217 #define icCountSG icCountSO
9218 
9219 #define icCountCharO(self, c) (self)->f->icCountChar(self, c)
9220 #define icCountCharG icCountCharO
9221 
9222 #define icCountSmallStringO(self, string) (self)->f->icCountSmallString(self, string)
9223 #define icCountSmallStringG icCountSmallStringO
9224 
9225 #define icCountJsonO(self, string) (self)->f->icCountJson(self, string)
9226 #define icCountJsonG icCountJsonO
9227 
9228 #define enumerateDictO(self, closure, funcElem) (self)->f->enumerateDict(self, closure, funcElem)
9229 #define enumerateDictG enumerateDictO
9230 
9231 #define splitCharO(self, c) (self)->f->splitChar(self, c)
9232 #define splitCharG splitCharO
9233 
9234 #define splitSO(self, delim) (self)->f->splitS(self, delim)
9235 #define splitSG splitSO
9236 
9237 #define splitCharSO(self, c) (self)->f->splitCharS(self, c)
9238 #define splitCharSG splitCharSO
9239 
9240 #define splitSmallStringSO(self, delim) (self)->f->splitSmallStringS(self, delim)
9241 #define splitSmallStringSG splitSmallStringSO
9242 
9243 #define extractCharSO(self, delim1, delim2) (self)->f->extractCharS(self, delim1, delim2)
9244 #define extractCharSG extractCharSO
9245 
9246 #define extractSCharO(self, delim1, delim2) (self)->f->extractSChar(self, delim1, delim2)
9247 #define extractSCharG extractSCharO
9248 
9249 #define extractCharCharO(self, delim1, delim2) (self)->f->extractCharChar(self, delim1, delim2)
9250 #define extractCharCharG extractCharCharO
9251 
9252 #define extractSmallJsonSmallJsonO(self, delim1, delim2) (self)->f->extractSmallJsonSmallJson(self, delim1, delim2)
9253 #define extractSmallJsonSmallJsonG extractSmallJsonSmallJsonO
9254 
9255 #define extractSmallStringSmallJsonO(self, delim1, delim2) (self)->f->extractSmallStringSmallJson(self, delim1, delim2)
9256 #define extractSmallStringSmallJsonG extractSmallStringSmallJsonO
9257 
9258 #define extractSSmallJsonO(self, delim1, delim2) (self)->f->extractSSmallJson(self, delim1, delim2)
9259 #define extractSSmallJsonG extractSSmallJsonO
9260 
9261 #define extractCharSmallJsonO(self, delim1, delim2) (self)->f->extractCharSmallJson(self, delim1, delim2)
9262 #define extractCharSmallJsonG extractCharSmallJsonO
9263 
9264 #define extractSmallStringSmallStringO(self, delim1, delim2) (self)->f->extractSmallStringSmallString(self, delim1, delim2)
9265 #define extractSmallStringSmallStringG extractSmallStringSmallStringO
9266 
9267 #define extractSmallStringSO(self, delim1, delim2) (self)->f->extractSmallStringS(self, delim1, delim2)
9268 #define extractSmallStringSG extractSmallStringSO
9269 
9270 #define extractSmallStringCharO(self, delim1, delim2) (self)->f->extractSmallStringChar(self, delim1, delim2)
9271 #define extractSmallStringCharG extractSmallStringCharO
9272 
9273 #define extractSSmallStringO(self, delim1, delim2) (self)->f->extractSSmallString(self, delim1, delim2)
9274 #define extractSSmallStringG extractSSmallStringO
9275 
9276 #define extractCharSmallStringO(self, delim1, delim2) (self)->f->extractCharSmallString(self, delim1, delim2)
9277 #define extractCharSmallStringG extractCharSmallStringO
9278 
9279 #define icSplitCharO(self, c) (self)->f->icSplitChar(self, c)
9280 #define icSplitCharG icSplitCharO
9281 
9282 #define icSplitSO(self, delim) (self)->f->icSplitS(self, delim)
9283 #define icSplitSG icSplitSO
9284 
9285 #define icSplitCharSO(self, c) (self)->f->icSplitCharS(self, c)
9286 #define icSplitCharSG icSplitCharSO
9287 
9288 #define icSplitSmallStringSO(self, delim) (self)->f->icSplitSmallStringS(self, delim)
9289 #define icSplitSmallStringSG icSplitSmallStringSO
9290 
9291 #define icExtractCharSO(self, delim1, delim2) (self)->f->icExtractCharS(self, delim1, delim2)
9292 #define icExtractCharSG icExtractCharSO
9293 
9294 #define icExtractSCharO(self, delim1, delim2) (self)->f->icExtractSChar(self, delim1, delim2)
9295 #define icExtractSCharG icExtractSCharO
9296 
9297 #define icExtractCharCharO(self, delim1, delim2) (self)->f->icExtractCharChar(self, delim1, delim2)
9298 #define icExtractCharCharG icExtractCharCharO
9299 
9300 #define icExtractSmallJsonSmallJsonO(self, delim1, delim2) (self)->f->icExtractSmallJsonSmallJson(self, delim1, delim2)
9301 #define icExtractSmallJsonSmallJsonG icExtractSmallJsonSmallJsonO
9302 
9303 #define icExtractSmallStringSmallJsonO(self, delim1, delim2) (self)->f->icExtractSmallStringSmallJson(self, delim1, delim2)
9304 #define icExtractSmallStringSmallJsonG icExtractSmallStringSmallJsonO
9305 
9306 #define icExtractSSmallJsonO(self, delim1, delim2) (self)->f->icExtractSSmallJson(self, delim1, delim2)
9307 #define icExtractSSmallJsonG icExtractSSmallJsonO
9308 
9309 #define icExtractCharSmallJsonO(self, delim1, delim2) (self)->f->icExtractCharSmallJson(self, delim1, delim2)
9310 #define icExtractCharSmallJsonG icExtractCharSmallJsonO
9311 
9312 #define icExtractSmallStringSmallStringO(self, delim1, delim2) (self)->f->icExtractSmallStringSmallString(self, delim1, delim2)
9313 #define icExtractSmallStringSmallStringG icExtractSmallStringSmallStringO
9314 
9315 #define icExtractSmallStringSO(self, delim1, delim2) (self)->f->icExtractSmallStringS(self, delim1, delim2)
9316 #define icExtractSmallStringSG icExtractSmallStringSO
9317 
9318 #define icExtractSmallStringCharO(self, delim1, delim2) (self)->f->icExtractSmallStringChar(self, delim1, delim2)
9319 #define icExtractSmallStringCharG icExtractSmallStringCharO
9320 
9321 #define icExtractSSmallStringO(self, delim1, delim2) (self)->f->icExtractSSmallString(self, delim1, delim2)
9322 #define icExtractSSmallStringG icExtractSSmallStringO
9323 
9324 #define icExtractCharSmallStringO(self, delim1, delim2) (self)->f->icExtractCharSmallString(self, delim1, delim2)
9325 #define icExtractCharSmallStringG icExtractCharSmallStringO
9326 
9327 #define colorO(self, colr) (self)->f->color(self, colr)
9328 #define colorG colorO
9329 
9330 #define colordO(self, color) (self)->f->colord(self, color)
9331 #define colordG colordO
9332 
9333 #define getNumAtO(self, index) (self)->f->getNumAt(self, index)
9334 #define getNumAtG getNumAtO
9335 
9336 #define delElemIndexO(self, index) (self)->f->delElemIndex(self, index)
9337 #define delElemIndexG delElemIndexO
9338 
9339 #define removeElemIndexO(self, index) (self)->f->removeElemIndex(self, index)
9340 #define removeElemIndexG removeElemIndexO
9341 
9342 #define stringifyO(self, indent) (self)->f->stringify(self, indent)
9343 #define stringifyG stringifyO
9344 
9345 #define stringifySmallStringO(self, indent) (self)->f->stringifySmallString(self, indent)
9346 #define stringifySmallStringG stringifySmallStringO
9347 
9348 #define toYMLO(self, indent) (self)->f->toYML(self, indent)
9349 #define toYMLG toYMLO
9350 
9351 #define toYMLSmallStringO(self, indent) (self)->f->toYMLSmallString(self, indent)
9352 #define toYMLSmallStringG toYMLSmallStringO
9353 
9354 #define parseSmallStringO(self, input) (self)->f->parseSmallString(self, input)
9355 #define parseSmallStringG parseSmallStringO
9356 
9357 #define parseYMLSmallStringO(self, input) (self)->f->parseYMLSmallString(self, input)
9358 #define parseYMLSmallStringG parseYMLSmallStringO
9359 
9360 #define serialO(self) (self)->f->serial(self)
9361 #define serialG serialO
9362 
9363 #define deserialO(self, data) (self)->f->deserial(self, data)
9364 #define deserialG deserialO
9365 
9366 #define readFileJsonO(self, filePath) (self)->f->readFileJson(self, filePath)
9367 #define readFileJsonG readFileJsonO
9368 
9369 #define writeFileJsonO(self, filePath) (self)->f->writeFileJson(self, filePath)
9370 #define writeFileJsonG writeFileJsonO
9371 
9372 #define appendFileJsonO(self, filePath) (self)->f->appendFileJson(self, filePath)
9373 #define appendFileJsonG appendFileJsonO
9374 
9375 #define readTextJsonO(self, filePath) (self)->f->readTextJson(self, filePath)
9376 #define readTextJsonG readTextJsonO
9377 
9378 #define writeTextJsonO(self, filePath) (self)->f->writeTextJson(self, filePath)
9379 #define writeTextJsonG writeTextJsonO
9380 
9381 #define appendTextJsonO(self, filePath) (self)->f->appendTextJson(self, filePath)
9382 #define appendTextJsonG appendTextJsonO
9383 
9384 #define typeAtStringO(self, index) (self)->f->typeAtString(self, index)
9385 #define typeAtStringG typeAtStringO
9386 
9387 #define typeAtSmallStringO(self, index) (self)->f->typeAtSmallString(self, index)
9388 #define typeAtSmallStringG typeAtSmallStringO
9389 
9390 #define typeAtO(self, index) (self)->f->typeAt(self, index)
9391 #define typeAtG typeAtO
9392 
9393 #define isETypeAtO(self, index, type) (self)->f->isETypeAt(self, index, type)
9394 #define isETypeAtG isETypeAtO
9395 
9396 #define isEUndefinedAtO(self, index) (self)->f->isEUndefinedAt(self, index)
9397 #define isEUndefinedAtG isEUndefinedAtO
9398 
9399 #define isEBoolAtO(self, index) (self)->f->isEBoolAt(self, index)
9400 #define isEBoolAtG isEBoolAtO
9401 
9402 #define isEContainerAtO(self, index) (self)->f->isEContainerAt(self, index)
9403 #define isEContainerAtG isEContainerAtO
9404 
9405 #define isEDictAtO(self, index) (self)->f->isEDictAt(self, index)
9406 #define isEDictAtG isEDictAtO
9407 
9408 #define isEDoubleAtO(self, index) (self)->f->isEDoubleAt(self, index)
9409 #define isEDoubleAtG isEDoubleAtO
9410 
9411 #define isEIntAtO(self, index) (self)->f->isEIntAt(self, index)
9412 #define isEIntAtG isEIntAtO
9413 
9414 #define isEStringAtO(self, index) (self)->f->isEStringAt(self, index)
9415 #define isEStringAtG isEStringAtO
9416 
9417 #define isEFaststringAtO(self, index) (self)->f->isEFaststringAt(self, index)
9418 #define isEFaststringAtG isEFaststringAtO
9419 
9420 #define isEArrayAtO(self, index) (self)->f->isEArrayAt(self, index)
9421 #define isEArrayAtG isEArrayAtO
9422 
9423 #define isEBytesAtO(self, index) (self)->f->isEBytesAt(self, index)
9424 #define isEBytesAtG isEBytesAtO
9425 
9426 #define setSmallArrayO(self, p2) (self)->f->setSmallArray(self, p2)
9427 #define setSmallArrayG setSmallArrayO
9428 
9429 #define setFromSmallDictO(self, p2) (self)->f->setFromSmallDict(self, p2)
9430 #define setFromSmallDictG setFromSmallDictO
9431 
9432 #define setFromSmallJsonO(self, p2) (self)->f->setFromSmallJson(self, p2)
9433 #define setFromSmallJsonG setFromSmallJsonO
9434 
9435 #define appendCharO(self, c) (self)->f->appendChar(self, c)
9436 #define appendCharG appendCharO
9437 
9438 #define appendNSmashSO(self, string) (self)->f->appendNSmashS(self, string)
9439 #define appendNSmashSG appendNSmashSO
9440 
9441 #define prependNSmashSmallJsonO(self, json) (self)->f->prependNSmashSmallJson(self, json)
9442 #define prependNSmashSmallJsonG prependNSmashSmallJsonO
9443 
9444 #define prependNSmashSO(self, string) (self)->f->prependNSmashS(self, string)
9445 #define prependNSmashSG prependNSmashSO
9446 
9447 #define replaceSmallJsonSmallJsonO(self, olds, news, max) (self)->f->replaceSmallJsonSmallJson(self, olds, news, max)
9448 #define replaceSmallJsonSmallJsonG replaceSmallJsonSmallJsonO
9449 
9450 #define replaceSmallJsonSmallStringO(self, olds, news, max) (self)->f->replaceSmallJsonSmallString(self, olds, news, max)
9451 #define replaceSmallJsonSmallStringG replaceSmallJsonSmallStringO
9452 
9453 #define replaceSmallJsonSO(self, olds, news, max) (self)->f->replaceSmallJsonS(self, olds, news, max)
9454 #define replaceSmallJsonSG replaceSmallJsonSO
9455 
9456 #define replaceSmallJsonCharO(self, olds, news, max) (self)->f->replaceSmallJsonChar(self, olds, news, max)
9457 #define replaceSmallJsonCharG replaceSmallJsonCharO
9458 
9459 #define replaceSSmallJsonO(self, olds, news, max) (self)->f->replaceSSmallJson(self, olds, news, max)
9460 #define replaceSSmallJsonG replaceSSmallJsonO
9461 
9462 #define replaceCharSmallJsonO(self, olds, news, max) (self)->f->replaceCharSmallJson(self, olds, news, max)
9463 #define replaceCharSmallJsonG replaceCharSmallJsonO
9464 
9465 #define icReplaceSmallJsonSmallJsonO(self, olds, news, max) (self)->f->icReplaceSmallJsonSmallJson(self, olds, news, max)
9466 #define icReplaceSmallJsonSmallJsonG icReplaceSmallJsonSmallJsonO
9467 
9468 #define icReplaceSmallJsonSmallStringO(self, olds, news, max) (self)->f->icReplaceSmallJsonSmallString(self, olds, news, max)
9469 #define icReplaceSmallJsonSmallStringG icReplaceSmallJsonSmallStringO
9470 
9471 #define icReplaceSmallJsonSO(self, olds, news, max) (self)->f->icReplaceSmallJsonS(self, olds, news, max)
9472 #define icReplaceSmallJsonSG icReplaceSmallJsonSO
9473 
9474 #define icReplaceSmallJsonCharO(self, olds, news, max) (self)->f->icReplaceSmallJsonChar(self, olds, news, max)
9475 #define icReplaceSmallJsonCharG icReplaceSmallJsonCharO
9476 
9477 #define icReplaceSSmallJsonO(self, olds, news, max) (self)->f->icReplaceSSmallJson(self, olds, news, max)
9478 #define icReplaceSSmallJsonG icReplaceSSmallJsonO
9479 
9480 #define icReplaceCharSmallJsonO(self, olds, news, max) (self)->f->icReplaceCharSmallJson(self, olds, news, max)
9481 #define icReplaceCharSmallJsonG icReplaceCharSmallJsonO
9482 
9483 #define equalSO(self, string) (self)->f->equalS(self, string)
9484 #define equalSG equalSO
9485 
9486 #define equalISmallJsonO(self, string, index) (self)->f->equalISmallJson(self, string, index)
9487 #define equalISmallJsonG equalISmallJsonO
9488 
9489 #define startsWithSmallJsonO(self, string) (self)->f->startsWithSmallJson(self, string)
9490 #define startsWithSmallJsonG startsWithSmallJsonO
9491 
9492 #define endsWithSmallJsonO(self, string) (self)->f->endsWithSmallJson(self, string)
9493 #define endsWithSmallJsonG endsWithSmallJsonO
9494 
9495 #define countSmallJsonO(self, string) (self)->f->countSmallJson(self, string)
9496 #define countSmallJsonG countSmallJsonO
9497 
9498 #define icStartsWithSmallJsonO(self, string) (self)->f->icStartsWithSmallJson(self, string)
9499 #define icStartsWithSmallJsonG icStartsWithSmallJsonO
9500 
9501 #define icEndsWithSmallJsonO(self, string) (self)->f->icEndsWithSmallJson(self, string)
9502 #define icEndsWithSmallJsonG icEndsWithSmallJsonO
9503 
9504 #define icCountSmallJsonO(self, string) (self)->f->icCountSmallJson(self, string)
9505 #define icCountSmallJsonG icCountSmallJsonO
9506 
9507 #define splitSmallJsonSO(self, delim) (self)->f->splitSmallJsonS(self, delim)
9508 #define splitSmallJsonSG splitSmallJsonSO
9509 
9510 #define splitSSmallStringO(self, delim) (self)->f->splitSSmallString(self, delim)
9511 #define splitSSmallStringG splitSSmallStringO
9512 
9513 #define extractSmallJsonSmallStringO(self, delim1, delim2) (self)->f->extractSmallJsonSmallString(self, delim1, delim2)
9514 #define extractSmallJsonSmallStringG extractSmallJsonSmallStringO
9515 
9516 #define extractSmallJsonSO(self, delim1, delim2) (self)->f->extractSmallJsonS(self, delim1, delim2)
9517 #define extractSmallJsonSG extractSmallJsonSO
9518 
9519 #define extractSmallJsonCharO(self, delim1, delim2) (self)->f->extractSmallJsonChar(self, delim1, delim2)
9520 #define extractSmallJsonCharG extractSmallJsonCharO
9521 
9522 #define icSplitSmallJsonSO(self, delim) (self)->f->icSplitSmallJsonS(self, delim)
9523 #define icSplitSmallJsonSG icSplitSmallJsonSO
9524 
9525 #define icSplitSSmallStringO(self, delim) (self)->f->icSplitSSmallString(self, delim)
9526 #define icSplitSSmallStringG icSplitSSmallStringO
9527 
9528 #define icExtractSmallJsonSmallStringO(self, delim1, delim2) (self)->f->icExtractSmallJsonSmallString(self, delim1, delim2)
9529 #define icExtractSmallJsonSmallStringG icExtractSmallJsonSmallStringO
9530 
9531 #define icExtractSmallJsonSO(self, delim1, delim2) (self)->f->icExtractSmallJsonS(self, delim1, delim2)
9532 #define icExtractSmallJsonSG icExtractSmallJsonSO
9533 
9534 #define icExtractSmallJsonCharO(self, delim1, delim2) (self)->f->icExtractSmallJsonChar(self, delim1, delim2)
9535 #define icExtractSmallJsonCharG icExtractSmallJsonCharO
9536 
9537 // generated with utils/oGMacros END
9538 
9539 
9540 // Class base
9541 
9545 typedef struct base baset;
9546 
9547 // for object inheriting baset, cast to baset to be able to use this class functions and generics
9548 #define cBa(self) ( (baset*) self )
9549 
9550 // Functions
9551 
9555 typedef void (*freeBaseFt)(baset *self);
9556 
9560 typedef void (*terminateBaseFt)(baset **self);
9561 
9565 typedef char* (*toStringBaseFt)(baset *self);
9566 
9570 typedef baset* (*duplicateBaseFt)(baset *self);
9571 
9575 typedef void (*smashBaseFt)(baset **self);
9576 
9580 typedef void (*finishBaseFt)(baset **self);
9581 
9585 typedef struct {
9586  freeBaseFt free;
9587  terminateBaseFt terminate;
9588  toStringBaseFt toString;
9589  duplicateBaseFt duplicate;
9590  smashBaseFt smash;
9591  finishBaseFt finish;
9592 } baseFunctionst;
9593 
9597 struct base {
9598  const char *type;
9599  baseFunctionst *f;
9600 };
9601 
9602 // terminate baset val when it is out of scope
9603 void cleanUpBaseTerminateG(baset **val);
9604 
9605 // free baset val when it is out of scope
9606 void cleanUpBaseFreeG(baset **val);
9607 
9608 // finish baset val when it is out of scope
9609 void cleanUpBaseFinishG(baset **val);
9610 
9611 // smash baset val when it is out of scope
9612 void cleanUpBaseSmashG(baset **val);
9613 
9617 #define cleanBaseP(name) baset *name CLEANUP(cleanUpBaseTerminateG)
9618 
9622 #define cleanFreeBase(name) baset *name CLEANUP(cleanUpBaseFreeG)
9623 
9627 #define cleanFinishBaseP(name) baset *name CLEANUP(cleanUpBaseFinishG)
9628 
9632 #define cleanSmashBaseP(name) baset *name CLEANUP(cleanUpBaseSmashG)
9633 
9634 // end class base
9635 
9639 typedef struct undefined undefinedt;
9640 
9644 typedef struct smallJson smallJsont;
9645 
9649 typedef struct smallDict smallDictt;
9650 
9654 typedef struct smallArray smallArrayt;
9655 
9659 typedef struct smallBytes smallBytest;
9660 
9664 typedef struct smallBool smallBoolt;
9665 
9669 typedef struct smallContainer smallContainert;
9670 
9674 typedef struct smallDouble smallDoublet;
9675 
9679 typedef struct smallInt smallIntt;
9680 
9684 typedef struct smallString smallStringt;
9685 
9686 #include "json/libsheepyCUndefined.h"
9687 #include "json/libsheepyCSmallDict.h"
9688 #include "json/libsheepyCSmallArray.h"
9689 #include "json/libsheepyCSmallJson.h"
9690 #include "json/libsheepyCSmallBytes.h"
9691 #include "json/libsheepyCSmallBool.h"
9692 #include "json/libsheepyCSmallContainer.h"
9693 #include "json/libsheepyCSmallDouble.h"
9694 #include "json/libsheepyCSmallInt.h"
9695 #include "json/libsheepyCSmallString.h"
9696 
9701 extern undefinedt* undefined;
9702 
9707 extern baset* rtBaset;
9708 extern undefinedt* rtUndefinedt;
9709 extern bool rtBool;
9710 extern bool* rtBoolP;
9711 extern double rtDouble;
9712 extern double* rtDoubleP;
9713 extern int64_t rtInt64_t;
9714 extern int64_t* rtInt64_tP;
9715 extern int32_t rtInt32_t;
9716 extern int32_t* rtInt32_tP;
9717 extern uint64_t rtUint64_t;
9718 extern uint64_t* rtUint64_tP;
9719 extern uint32_t rtUint32_t;
9720 extern uint32_t* rtUint32_tP;
9721 extern float rtF32;
9722 extern double rtF64;
9723 extern double* rtF64P;
9724 extern int64_t rtI64;
9725 extern int64_t* rtI64P;
9726 extern int32_t rtI32;
9727 extern int32_t* rtI32P;
9728 extern uint64_t rtU64;
9729 extern uint64_t* rtU64P;
9730 extern uint32_t rtU32;
9731 extern uint32_t* rtU32P;
9732 extern uint8_t rtU8;
9733 extern uint16_t rtU16;
9734 extern char* rtChar;
9735 extern smallArrayt* rtSmallArrayt;
9736 extern smallBoolt* rtSmallBoolt;
9737 extern smallBytest* rtSmallBytest;
9738 extern smallDictt* rtSmallDictt;
9739 extern smallDoublet* rtSmallDoublet;
9740 extern smallIntt* rtSmallIntt;
9741 extern smallJsont* rtSmallJsont;
9742 extern smallStringt* rtSmallStringt;
9743 extern void* rtVoid;
9744 extern smallContainert* rtSmallContainert;
9745 
9746 // thread pool
9747 #include "tpool.h"
9748 
9749 // Reference SKIP END
9750 
9754 #define unusedV 0
9755 
9767 #define toUnsignedType(var) typeof(convertToUnsignedType(var))
9768 #define convertToUnsignedType(var) _Generic(var,\
9769  int8_t: rtU8,\
9770  int16_t: rtU16,\
9771  int32_t: rtU32,\
9772  int64_t: rtU64,\
9773  uint8_t: rtU8,\
9774  uint16_t: rtU16,\
9775  uint32_t: rtU32,\
9776  uint64_t: rtU64,\
9777  float: rtF32,/* it is useful to support float even as there is no unsigned float */\
9778  double: rtF64)
9779 
9783 #define castS(casted, toCast) \
9784  ;smallStringt *casted;\
9785  if (checkObjectTypes && toCast && !isOSmallString(toCast))\
9786  casted = NULL;\
9787  else\
9788  casted = (smallStringt *) (toCast);
9789 
9796 #define _ "\""
9797 
9799 #define BSLH "\\"
9800 
9808 #define ssGet(obj) ((smallStringt*)(obj))->f->get((smallStringt*)(obj))
9809 
9817 #define sjGet(obj) ((smallJsont*)(obj))->f->getTopS((smallJsont*)(obj))
9818 
9823 #define replaceSO_max(obj,olds,news) (obj)->f->replace(obj,olds,news, 0)
9824 
9829 #define replaceManyO(self, olds, ...) (self)->f->replaceMany(self, olds, __VA_ARGS__, NULL)
9830 #define replaceManyG replaceManyO
9831 
9836 #define icReplaceSO_max(obj,olds,news) (obj)->f->replace(obj,olds,news, 0)
9837 
9842 #define icReplaceManyO(self, olds, ...) (self)->f->icReplaceMany(self, olds, __VA_ARGS__, NULL)
9843 #define icReplaceManyG icReplaceManyO
9844 
9855 smallDictt *shSysinfo(void);
9856 
9857 baset *duplicateBaseG(baset *self);
9858 
9867 smallJsont *getProgPathJO(void);
9868 smallStringt *getProgPathO(void);
9869 
9877 smallJsont *getRealProgPathJO(void);
9878 smallStringt *getRealProgPathO(void);
9879 
9883 int systemJO(smallJsont *command);
9884 int systemO(smallStringt *command);
9885 
9893 #define systemNFreeOJ(command) systemNFreeJOF(command, __LINE__, __func__, __FILE__);
9894 int systemNFreeJOF(smallJsont *command, int line, const char *thisFunc, const char *thisFileName);
9895 #define systemNFreeO(command) systemNFreeOF(command, __LINE__, __func__, __FILE__);
9896 int systemNFreeOF(smallStringt *command, int line, const char *thisFunc, const char *thisFileName);
9897 
9901 char *toStringOF(baset* object);
9902 char *toStringUndefinedGF(undefinedt* object);
9903 char *toStringBoolGF(bool object);
9904 char *toStringBoolPGF(bool* object);
9905 char *toStringFloatGF(float object);
9906 char *toStringFloatPGF(float* object);
9907 char *toStringDoubleGF(double object);
9908 char *toStringDoublePGF(double* object);
9909 char *toStringIntGF(int64_t object);
9910 char *toStringIntPGF(int64_t* object);
9911 char *toStringInt32GF(int32_t object);
9912 char *toStringInt32PGF(int32_t* object);
9913 char *toStringInt16GF(int16_t object);
9914 char *toStringInt16PGF(int16_t* object);
9915 char *toStringUintGF(uint64_t object);
9916 char *toStringUintPGF(uint64_t* object);
9917 char *toStringUint32GF(uint32_t object);
9918 char *toStringUint32PGF(uint32_t* object);
9919 char *toStringUint16GF(uint16_t object);
9920 char *toStringUint16PGF(uint16_t* object);
9921 char *toStringUint8GF(uint8_t object);
9922 char *toStringUint8PGF(uint8_t* object);
9923 char *toStringCharGF(char object);
9924 char *toStringSGF(const char* object);
9925 char *toStringListSGF(char** object);
9926 char *toStringListCSGF(const char** object);
9927 char *toStringDictGF(smallDictt* object);
9928 char *toStringArrayGF(smallArrayt* object);
9929 char *toStringSmallBoolGF(smallBoolt* object);
9930 char *toStringSmallBytesGF(smallBytest* object);
9931 char *toStringSmallDoubleGF(smallDoublet* object);
9932 char *toStringSmallIntGF(smallIntt* object);
9933 char *toStringSmallStringGF(smallStringt* object);
9934 char *toStringVoidGF(void* object);
9935 char *toStringSmallContainerGF(smallContainert* object);
9936 char *toStringSmallJsonGF(smallJsont* object);
9937 #define toStringG(obj) _Generic((obj), \
9938  baset*: toStringOF, \
9939  undefinedt*: toStringUndefinedGF, \
9940  bool: toStringBoolGF, \
9941  bool*: toStringBoolPGF, \
9942  float: toStringFloatGF, \
9943  float*: toStringFloatPGF, \
9944  double: toStringDoubleGF, \
9945  double*: toStringDoublePGF, \
9946  int64_t: toStringIntGF, \
9947  int64_t*: toStringIntPGF, \
9948  int32_t: toStringInt32GF, \
9949  int32_t*: toStringInt32PGF, \
9950  int16_t: toStringInt16GF, \
9951  int16_t*: toStringInt16PGF, \
9952  uint64_t: toStringUintGF, \
9953  uint64_t*: toStringUintPGF, \
9954  uint32_t: toStringUint32GF, \
9955  uint32_t*: toStringUint32PGF, \
9956  uint16_t: toStringUint16GF, \
9957  uint16_t*: toStringUint16PGF, \
9958  uint8_t: toStringUint8GF, \
9959  uint8_t*: toStringUint8PGF, \
9960  char: toStringCharGF, \
9961  char*: toStringSGF, \
9962  const char*: toStringSGF, \
9963  char**: toStringListSGF, \
9964  const char**: toStringListCSGF, \
9965  smallDictt*: toStringDictGF, \
9966  smallArrayt*: toStringArrayGF, \
9967  smallBoolt*: toStringSmallBoolGF, \
9968  smallBytest*: toStringSmallBytesGF, \
9969  smallDoublet*: toStringSmallDoubleGF, \
9970  smallIntt*: toStringSmallIntGF, \
9971  smallStringt*: toStringSmallStringGF, \
9972  void*: toStringVoidGF, \
9973  smallContainert*: toStringSmallContainerGF, \
9974  smallJsont*: toStringSmallJsonGF, \
9975  default: toStringVoidGF \
9976  )(obj)
9977 
9985 char *otos(void *basetObj);
9986 
9990 void putsOF(baset* object);
9991 #define putsO(obj) putsOF((baset *)(obj))
9992 void putsUndefinedGF(undefinedt* object);
9993 void putsBoolGF(bool object);
9994 void putsBoolPGF(bool* object);
9995 void putsDoubleGF(double object);
9996 void putsDoublePGF(double* object);
9997 void putsIntGF(int64_t object);
9998 void putsIntPGF(int64_t* object);
9999 void putsInt32GF(int32_t object);
10000 void putsInt32PGF(int32_t* object);
10001 void putsUintGF(uint64_t object);
10002 void putsUintPGF(uint64_t* object);
10003 void putsUint32GF(uint32_t object);
10004 void putsUint32PGF(uint32_t* object);
10005 void putsSGF(const char* object);
10006 void putsListSGF(char** object);
10007 void putsListCSGF(const char** object);
10008 void putsDictGF(smallDictt* object);
10009 void putsJsonGF(smallJsont* object);
10010 void putsArrayGF(smallArrayt* object);
10011 void putsSmallBoolGF(smallBoolt* object);
10012 void putsSmallBytesGF(smallBytest* object);
10013 void putsSmallDoubleGF(smallDoublet* object);
10014 void putsSmallIntGF(smallIntt* object);
10015 void putsSmallStringGF(smallStringt* object);
10016 void putsVoidGF(void* object);
10017 void putsSmallContainerGF(smallContainert* object);
10018 #define putsG(obj) _Generic((obj), \
10019  baset*: putsOF, \
10020  undefinedt*: putsUndefinedGF, \
10021  bool: putsBoolGF, \
10022  bool*: putsBoolPGF, \
10023  double: putsDoubleGF, \
10024  double*: putsDoublePGF, \
10025  int64_t: putsIntGF, \
10026  int64_t*: putsIntPGF, \
10027  int32_t: putsInt32GF, \
10028  int32_t*: putsInt32PGF, \
10029  uint64_t: putsUintGF, \
10030  uint64_t*: putsUintPGF, \
10031  uint32_t: putsUint32GF, \
10032  uint32_t*: putsUint32PGF, \
10033  char*: putsSGF, \
10034  const char*: putsSGF, \
10035  char**: putsListSGF, \
10036  const char**: putsListCSGF, \
10037  smallDictt*: putsDictGF, \
10038  smallJsont*: putsJsonGF, \
10039  smallArrayt*: putsArrayGF, \
10040  smallBoolt*: putsSmallBoolGF, \
10041  smallBytest*: putsSmallBytesGF, \
10042  smallDoublet*: putsSmallDoubleGF, \
10043  smallIntt*: putsSmallIntGF, \
10044  smallStringt*: putsSmallStringGF, \
10045  void*: putsVoidGF, \
10046  smallContainert*: putsSmallContainerGF, \
10047  default: putsVoidGF \
10048  )(obj)
10049 
10059 smallStringt *formatO(const char *fmt, ...);
10060 
10077 int execO(const char *cmd, smallArrayt *out, smallArrayt *err);
10078 int execSmallJsonO(smallJsont *cmd, smallArrayt *out, smallArrayt *err);
10079 int execSmallStringO(smallStringt *cmd, smallArrayt *out, smallArrayt *err);
10080 
10091 smallArrayt *walkDirO(const char* dirPath);
10092 smallArrayt *walkDirSmallJsonO(smallJsont* dirPath);
10093 smallArrayt *walkDirSmallStringO(smallStringt* dirPath);
10094 
10107 smallArrayt *walkDirDirO(const char* dirPath);
10108 smallArrayt *walkDirDirSmallJsonO(smallJsont* dirPath);
10109 smallArrayt *walkDirDirSmallStringO(smallStringt* dirPath);
10110 
10123 smallArrayt *readDirO(const char *dirPath);
10124 smallArrayt *readDirSmallJsonO(smallJsont *dirPath);
10125 smallArrayt *readDirSmallStringO(smallStringt *dirPath);
10126 
10139 smallArrayt *readDirDirO(const char *dirPath);
10140 smallArrayt *readDirDirSmallJsonO(smallJsont *dirPath);
10141 smallArrayt *readDirDirSmallStringO(smallStringt *dirPath);
10142 
10153 smallArrayt *walkDirAllO(const char* dirPath);
10154 smallArrayt *walkDirAllSmallJsonO(smallJsont* dirPath);
10155 smallArrayt *walkDirAllSmallStringO(smallStringt* dirPath);
10156 
10169 smallArrayt *readDirAllO(const char *dirPath);
10170 smallArrayt *readDirAllSmallJsonO(smallJsont *dirPath);
10171 smallArrayt *readDirAllSmallStringO(smallStringt *dirPath);
10172 
10182 time_t getModificationTimeJO(smallJsont *path);
10183 time_t getModificationTimeO(smallStringt *path);
10184 
10196 int setModificationTimeJO(smallJsont *path, time_t mtime);
10197 int setModificationTimeO(smallStringt *path, time_t mtime);
10198 
10210 bool equalModificationTimesJO(smallJsont *path1, smallJsont *path2);
10211 bool equalModificationTimesSJO(const char *path1, smallJsont *path2);
10212 bool equalModificationTimesJOS(smallJsont *path1, const char *path2);
10213 bool equalModificationTimesJOO(smallJsont *path1, smallStringt *path2);
10214 bool equalModificationTimesOJO(smallStringt *path1, smallJsont *path2);
10215 bool equalModificationTimesO(smallStringt *path1, smallStringt *path2);
10216 bool equalModificationTimesSO(const char *path1, smallStringt *path2);
10217 bool equalModificationTimesOS(smallStringt *path1, const char *path2);
10218 
10229 smallJsont *timeToJO(const time_t t);
10230 smallStringt *timeToSO(const time_t t);
10231 
10242 smallJsont *shDirnameJO(smallJsont *path);
10243 smallStringt *shDirnameO(smallStringt *path);
10244 
10254 smallJsont *expandHomeJO(smallJsont *path);
10255 smallStringt *expandHomeO(smallStringt *path);
10256 
10272 smallJsont *normalizePathJO(smallJsont *path);
10273 smallStringt *normalizePathO(smallStringt *path);
10274 
10281 smallJsont *getCwdJO(void);
10282 smallStringt *getCwdO(void);
10283 
10293 int chDirJO(smallJsont *path);
10294 int chDirO(smallStringt *path);
10295 
10305 bool isDirJO(smallJsont *path);
10306 bool isDirO(smallStringt *path);
10307 
10317 bool isLinkJO(smallJsont *path);
10318 bool isLinkO(smallStringt *path);
10319 
10330 bool fileExistsJO(smallJsont *filePath);
10331 bool fileExistsO(smallStringt *filePath);
10332 
10343 bool fileChmodJO(smallJsont *filePath, mode_t mode);
10344 bool fileChmodO(smallStringt *filePath, mode_t mode);
10345 
10355 ssize_t fileSizeJO(smallJsont *filePath);
10356 ssize_t fileSizeO(smallStringt *filePath);
10357 
10361 void *readFileToNewG(void *none UNUSED, const char *filePath);
10362 void *readStreamToNewG(void *none UNUSED, FILE *fp);
10363 char *readFileToG(char **string, const char *filePath);
10364 char *readStreamToG(char **string, FILE *fp);
10365 
10366 void readTextSmallJsonNotSupported(char ***self UNUSED, smallJsont *path UNUSED);
10367 void readTextSmallStringNotSupported(char ***self UNUSED, smallStringt *path UNUSED);
10368 void readToFileSmallJsonNotSupported(void *self UNUSED, smallJsont *path UNUSED);
10369 void readToFileSmallStringNotSupported(void *self UNUSED, smallStringt *path UNUSED);
10370 
10375 int writeFileFromG(const char *string, const char *filePath);
10376 int writeStreamFromG(const char *string, FILE *fp);
10377 
10378 int writeTextSmallJsonNotSupported(char **self UNUSED, smallJsont *path UNUSED);
10379 int writeTextSmallStringNotSupported(char **self UNUSED, smallStringt *path UNUSED);
10380 int writeTextCCSmallJsonNotSupported(const char **self UNUSED, smallJsont *path UNUSED);
10381 int writeTextCCSmallStringNotSupported(const char **self UNUSED, smallStringt *path UNUSED);
10382 
10386 char **readTextSG(char ***list, const char *filePath);
10387 char **readTextStreamG(char ***list, FILE *fp);
10388 
10393 bool writeTextSG(char **list, const char *filePath);
10394 bool writeTextStreamG(char **list, FILE *fp);
10395 bool writeTextCG(const char **list, const char *filePath);
10396 bool writeTextStreamCG(const char **list, FILE *fp);
10397 
10402 bool appendFileSG(const char *string, const char *filePath);
10403 
10408 bool appendTextSG(char **list, const char *filePath);
10409 bool appendTextCG(const char **list, const char *filePath);
10410 
10420 int mkdirParentsSmallJsonO(smallJsont* path);
10421 int mkdirParentsO(smallStringt* path);
10422 
10433 int rmAllSmallJsonO(smallJsont* path);
10434 int rmAllO(smallStringt* path);
10435 
10446 int copyO(smallStringt* src, smallStringt* dst);
10447 int copySSmallJsonO(const char* src, smallJsont* dst);
10448 int copySO(const char* src, smallStringt* dst);
10449 int copySmallJsonOS(smallJsont* src, const char* dst);
10450 int copySmallJsonSmallJson(smallJsont* src, smallJsont* dst);
10451 int copySmallJsonO(smallJsont* src, smallStringt* dst);
10452 int copyOS(smallStringt* src, const char* dst);
10453 int copyOSmallJson(smallStringt* src, smallJsont* dst);
10454 
10465 int renameSmallJsonO(smallJsont* src, smallStringt* dst);
10466 int renameSmallJsonSmallJson(smallJsont* src, smallJsont* dst);
10467 int renameSmallJsonOS(smallJsont* src, const char* dst);
10468 int renameO(smallStringt* src, smallStringt* dst);
10469 int renameOSmallJson(smallStringt* src, smallJsont* dst);
10470 int renameSSmallJsonO(const char* src, smallJsont* dst);
10471 int renameSO(const char* src, smallStringt* dst);
10472 int renameOS(smallStringt* src, const char* dst);
10473 
10486 int moveSmallJsonO(smallJsont* src, smallStringt* dst);
10487 int moveSmallJsonSmallJson(smallJsont* src, smallJsont* dst);
10488 int moveSmallJsonOS(smallJsont* src, const char* dst);
10489 int moveO(smallStringt* src, smallStringt* dst);
10490 int moveOSmallJson(smallStringt* src, smallJsont* dst);
10491 int moveSSmallJsonO(const char* src, smallJsont* dst);
10492 int moveSO(const char* src, smallStringt* dst);
10493 int moveOS(smallStringt* src, const char* dst);
10494 
10507 smallJsont *randomSmallJsonO(uint64_t length);
10508 smallStringt *randomSO(uint64_t length);
10509 
10522 smallJsont *randomAlphaNumSmallJsonO(uint64_t length);
10523 smallStringt *randomAlphaNumSO(uint64_t length);
10524 
10533 smallJsont *readSmallJsonO(void);
10534 smallStringt *readO(void);
10535 
10547 smallJsont *readLineSmallJsonO(FILE *fp);
10548 smallStringt *readLineO(FILE *fp);
10549 
10553 char *intToSG(char *retType UNUSED, int64_t n);
10554 
10558 char *doubleToSG(char *retType UNUSED, double n);
10559 
10563 char **iListUniqG(char ***list, int dum UNUSED);
10564 
10568 char **iicListUniqG(char ***list, int dum UNUSED);
10569 
10573 char **listFromArrayG(char **retType UNUSED, char **array, size_t size);
10574 char **listFromCArrayG(char **retType UNUSED, const char **array, size_t size);
10575 
10579 char getSG(const char *string, int retType UNUSED, int64_t index);
10580 
10584 char *listGetG(char **list, int retType UNUSED, int64_t index);
10585 char *listGetCG(const char **list, int retType UNUSED, int64_t index);
10586 
10590 char *iListGetG(char **list, int retType UNUSED, int64_t index);
10591 const char *iListGetCG(const char **list, int retType UNUSED, int64_t index);
10592 
10596 char *listPopG(char ***list, int retType UNUSED);
10597 
10601 char *listDequeueG(char ***list, int retType UNUSED);
10602 
10603 char **listDupCG(const char **list);
10604 
10605 bool listEqCG(char **list1, const char **list2);
10606 bool listEqC1G(const char **list1, char **list2);
10607 bool listEqCCG(const char **list1, const char **list2);
10608 bool icListEqCG(char **list1, const char **list2);
10609 bool icListEqC1G(const char **list1, char **list2);
10610 bool icListEqCCG(const char **list1, const char **list2);
10611 
10612 size_t listLengthCG(const char **list);
10613 
10614 ssize_t listIndexOfCG(const char **list, const char *string);
10615 ssize_t listIndexOfCharCG(const char **list, char c);
10616 ssize_t icListIndexOfCG(const char **list, const char *string);
10617 ssize_t icListIndexOfCharCG(const char **list, char c);
10618 
10619 bool listHasCG(const char **list, const char *string);
10620 bool listHasCharCG(const char **list, char c);
10621 bool icListHasCG(const char **list, const char *string);
10622 bool icListHasCharCG(const char **list, char c);
10623 
10624 char *joinCG(const char **list, const char* delim);
10625 char *joinCharCG(const char **list, char delim);
10626 
10627 char **listAddCG(char **list1, const char **list2);
10628 
10629 int listPrintCG(const char **list);
10630 
10631 
10635 bool eqCharChar(char c, char value);
10636 bool equalChaOG(char c, baset* value);
10637 bool equalChaBoolG(char c UNUSED, bool value UNUSED);
10638 bool equalChaDoubleG(char c, double value);
10639 bool equalChaInt64G(char c, int64_t value);
10640 bool equalChaInt32G(char c, int32_t value);
10641 bool equalChaUint32G(char c, uint32_t value);
10642 bool equalChaUint64G(char c, uint64_t value);
10643 bool equalChaSmallBytesG(char c, smallBytest* value);
10644 bool equalChaSmallDoubleG(char c, smallDoublet* value);
10645 bool equalChaSmallIntG(char c, smallIntt* value);
10646 bool equalChaSmallJsonG(char c, smallJsont* value);
10647 bool equalChaSmallStringG(char c, smallStringt* value);
10648 bool equalCharOG(const char *s, baset* value);
10649 bool equalCharBoolG(const char *s, bool value);
10650 bool equalCharDoubleG(const char *s, double value);
10651 bool equalCharInt64G(const char *s, int64_t value);
10652 bool equalCharInt32G(const char *s, int32_t value);
10653 bool equalCharUint32G(const char *s, uint32_t value);
10654 bool equalCharUint64G(const char *s, uint64_t value);
10655 bool equalCharSmallBoolG(const char *s, smallBoolt* value);
10656 bool equalCharSmallBytesG(const char *s, smallBytest* value);
10657 bool equalCharSmallDoubleG(const char *s, smallDoublet* value);
10658 bool equalCharSmallIntG(const char *s, smallIntt* value);
10659 bool equalCharPSmallJsonG(const char *s, smallJsont* value);
10660 bool equalCharPSmallStringG(const char *s, smallStringt* value);
10661 bool equalArrayOG(char ** p1, baset* p2);
10662 bool equalCArrayOG(const char ** p1, baset* p2);
10663 bool equalArraySmallJsonG(char ** p1, smallJsont* p2);
10664 bool equalArraySmallArrayG(char ** p1, smallArrayt* p2);
10665 bool equalCArraySmallJsonG(const char ** p1, smallJsont* p2);
10666 bool equalCArraySmallArrayG(const char ** p1, smallArrayt* p2);
10667 bool equalOChaG(baset* p1, char p2);
10668 bool equalOCharG(baset* p1, const char * p2);
10669 bool equalOArrayG(baset* p1, char ** p2);
10670 bool equalOCArrayG(baset* p1, const char ** p2);
10671 bool equalOOG(baset* p1, baset* p2);
10672 bool equalOBoolG(baset* p1, bool p2);
10673 bool equalODoubleG(baset* p1, double p2);
10674 bool equalOInt64G(baset* p1, int64_t p2);
10675 bool equalOInt32G(baset* p1, int32_t p2);
10676 bool equalOUint32G(baset* p1, uint32_t p2);
10677 bool equalOUint64G(baset* p1, uint64_t p2);
10678 bool equalOSmallArrayG(baset* p1, smallArrayt* p2);
10679 bool equalOSmallBoolG(baset* p1, smallBoolt* p2);
10680 bool equalOSmallBytesG(baset* p1, smallBytest* p2);
10681 bool equalOSmallDoubleG(baset* p1, smallDoublet* p2);
10682 bool equalOSmallDictG(baset* p1, smallDictt* p2);
10683 bool equalOSmallIntG(baset* p1, smallIntt* p2);
10684 bool equalOSmallJsonG(baset* p1, smallJsont* p2);
10685 bool equalOSmallStringG(baset* p1, smallStringt* p2);
10686 bool equalBoolChaG(bool p1 UNUSED, char p2 UNUSED);
10687 bool equalBoolCharG(bool p1, const char * p2);
10688 bool equalBoolOG(bool p1, baset* p2);
10689 bool equalBoolFG(bool p1, bool p2);
10690 bool equalBoolDoubleG(bool p1, double p2);
10691 bool equalBoolInt64G(bool p1, int64_t p2);
10692 bool equalBoolInt32G(bool p1, int32_t p2);
10693 bool equalBoolUint32G(bool p1, uint32_t p2);
10694 bool equalBoolUint64G(bool p1, uint64_t p2);
10695 bool equalBoolSmallBoolG(bool p1, smallBoolt* p2);
10696 bool equalBoolSmallBytesG(bool p1, smallBytest* p2);
10697 bool equalBoolSmallDoubleG(bool p1, smallDoublet* p2);
10698 bool equalBoolSmallIntG(bool p1, smallIntt* p2);
10699 bool equalBoolSmallJsonG(bool p1, smallJsont* p2);
10700 bool equalBoolSmallStringG(bool p1, smallStringt* p2);
10701 bool equalDoubleChaG(double p1, char p2);
10702 bool equalDoubleCharG(double p1, const char * p2);
10703 bool equalDoubleBaseG(double p1, baset* p2);
10704 bool equalDoubleBoolG(double p1, bool p2);
10705 bool equalDoubleFG(double p1, double p2);
10706 bool equalDoubleInt64G(double p1, int64_t p2);
10707 bool equalDoubleInt32G(double p1, int32_t p2);
10708 bool equalDoubleUint32G(double p1, uint32_t p2);
10709 bool equalDoubleUint64G(double p1, uint64_t p2);
10710 bool equalDoubleSmallBoolG(double p1, smallBoolt* p2);
10711 bool equalDoubleSmallBytesG(double p1, smallBytest* p2);
10712 bool equalDoubleSmallDoubleG(double p1, smallDoublet* p2);
10713 bool equalDoubleSmallIntG(double p1, smallIntt* p2);
10714 bool equalDoubleSmallJsonG(double p1, smallJsont* p2);
10715 bool equalDoubleSmallStringG(double p1, smallStringt* p2);
10716 bool equalInt64ChaG(int64_t p1, char p2);
10717 bool equalInt64CharG(int64_t p1, const char * p2);
10718 bool equalInt64BaseG(int64_t p1, baset* p2);
10719 bool equalInt64BoolG(int64_t p1, bool p2);
10720 bool equalInt64DoubleG(int64_t p1, double p2);
10721 bool equalInt64FG(int64_t p1, int64_t p2);
10722 bool equalInt64Int32G(int64_t p1, int32_t p2);
10723 bool equalInt64Uint32G(int64_t p1, uint32_t p2);
10724 bool equalInt64Uint64G(int64_t p1, uint64_t p2);
10725 bool equalInt64SmallBoolG(int64_t p1, smallBoolt* p2);
10726 bool equalInt64SmallBytesG(int64_t p1, smallBytest* p2);
10727 bool equalInt64SmallDoubleG(int64_t p1, smallDoublet* p2);
10728 bool equalInt64SmallIntG(int64_t p1, smallIntt* p2);
10729 bool equalInt64SmallJsonG(int64_t p1, smallJsont* p2);
10730 bool equalInt64SmallStringG(int64_t p1, smallStringt* p2);
10731 bool equalInt32ChaG(int32_t p1, char p2);
10732 bool equalInt32CharG(int32_t p1, const char * p2);
10733 bool equalInt32BaseG(int32_t p1, baset* p2);
10734 bool equalInt32BoolG(int32_t p1, bool p2);
10735 bool equalInt32DoubleG(int32_t p1, double p2);
10736 bool equalInt32Int64G(int32_t p1, int64_t p2);
10737 bool equalInt32FG(int32_t p1, int32_t p2);
10738 bool equalInt32Uint32G(int32_t p1, uint32_t p2);
10739 bool equalInt32Uint64G(int32_t p1, uint64_t p2);
10740 bool equalInt32SmallBoolG(int32_t p1, smallBoolt* p2);
10741 bool equalInt32SmallBytesG(int32_t p1, smallBytest* p2);
10742 bool equalInt32SmallDoubleG(int32_t p1, smallDoublet* p2);
10743 bool equalInt32SmallIntG(int32_t p1, smallIntt* p2);
10744 bool equalInt32SmallJsonG(int32_t p1, smallJsont* p2);
10745 bool equalInt32SmallStringG(int32_t p1, smallStringt* p2);
10746 bool equalUint32ChaG(uint32_t p1, char p2);
10747 bool equalUint32CharG(uint32_t p1, const char * p2);
10748 bool equalUint32BaseG(uint32_t p1, baset* p2);
10749 bool equalUint32BoolG(uint32_t p1, bool p2);
10750 bool equalUint32DoubleG(uint32_t p1, double p2);
10751 bool equalUint32Int64G(uint32_t p1, int64_t p2);
10752 bool equalUint32Int32G(uint32_t p1, int32_t p2);
10753 bool equalUint32FG(uint32_t p1, uint32_t p2);
10754 bool equalUint32Uint64G(uint32_t p1, uint64_t p2);
10755 bool equalUint32SmallBoolG(uint32_t p1, smallBoolt* p2);
10756 bool equalUint32SmallBytesG(uint32_t p1, smallBytest* p2);
10757 bool equalUint32SmallDoubleG(uint32_t p1, smallDoublet* p2);
10758 bool equalUint32SmallIntG(uint32_t p1, smallIntt* p2);
10759 bool equalUint32SmallJsonG(uint32_t p1, smallJsont* p2);
10760 bool equalUint32SmallStringG(uint32_t p1, smallStringt* p2);
10761 bool equalUint64ChaG(uint64_t p1, char p2);
10762 bool equalUint64CharG(uint64_t p1, const char * p2);
10763 bool equalUint64BaseG(uint64_t p1, baset* p2);
10764 bool equalUint64BoolG(uint64_t p1, bool p2);
10765 bool equalUint64DoubleG(uint64_t p1, double p2);
10766 bool equalUint64Int64G(uint64_t p1, int64_t p2);
10767 bool equalUint64Int32G(uint64_t p1, int32_t p2);
10768 bool equalUint64Uint32G(uint64_t p1, uint32_t p2);
10769 bool equalUint64FG(uint64_t p1, uint64_t p2);
10770 bool equalUint64SmallBoolG(uint64_t p1, smallBoolt* p2);
10771 bool equalUint64SmallBytesG(uint64_t p1, smallBytest* p2);
10772 bool equalUint64SmallDoubleG(uint64_t p1, smallDoublet* p2);
10773 bool equalUint64SmallIntG(uint64_t p1, smallIntt* p2);
10774 bool equalUint64SmallJsonG(uint64_t p1, smallJsont* p2);
10775 bool equalUint64SmallStringG(uint64_t p1, smallStringt* p2);
10776 
10780 bool notEqualCharG(char c UNUSED, void *value UNUSED);
10781 bool notEqualOCharG(void *a UNUSED, char c UNUSED);
10782 bool notEqualOG(void *a UNUSED, void *b UNUSED);
10783 bool notEqualCCOG(const char *a UNUSED, void *b UNUSED);
10784 bool notEqualBoolOG(bool p1 UNUSED, void *p2 UNUSED);
10785 bool notEqualDoubleOG(double p1 UNUSED, void *p2 UNUSED);
10786 bool notEqualInt64OG(int64_t p1 UNUSED, void *p2 UNUSED);
10787 bool notEqualInt32OG(int32_t p1 UNUSED, void *p2 UNUSED);
10788 bool notEqualUint32OG(uint32_t p1 UNUSED, void *p2 UNUSED);
10789 bool notEqualUint64OG(uint64_t p1 UNUSED, void *p2 UNUSED);
10790 bool notEqualOBoolG(void *p1 UNUSED, bool p2 UNUSED);
10791 bool notEqualDoubleG(void *p1 UNUSED, double p2 UNUSED);
10792 bool notEqualOInt64G(void *p1 UNUSED, int64_t p2 UNUSED);
10793 bool notEqualOInt32G(void *p1 UNUSED, int32_t p2 UNUSED);
10794 bool notEqualOUint32G(void *p1 UNUSED, uint32_t p2 UNUSED);
10795 bool notEqualOUint64G(void *p1 UNUSED, uint64_t p2 UNUSED);
10796 
10800 bool icEqCharChar(char c, char value);
10801 bool icEqualChaOG(char c, baset* value);
10802 bool icEqualChaSmallJsonG(char c, smallJsont* value);
10803 bool icEqualChaSmallStringG(char c, smallStringt* value);
10804 bool icEqualCharOG(const char *s, baset* value);
10805 bool icEqualCharPSmallJsonG(const char *s, smallJsont* value);
10806 bool icEqualCharPSmallStringG(const char *s, smallStringt* value);
10807 bool icEqualArrayOG(char ** p1, baset* p2);
10808 bool icEqualCArrayOG(const char ** p1, baset* p2);
10809 bool icEqualArraySmallJsonG(char ** p1, smallJsont* p2);
10810 bool icEqualArraySmallArrayG(char ** p1, smallArrayt* p2);
10811 bool icEqualCArraySmallJsonG(const char ** p1, smallJsont* p2);
10812 bool icEqualCArraySmallArrayG(const char ** p1, smallArrayt* p2);
10813 bool icEqualOChaG(baset* p1, char p2);
10814 bool icEqualOCharG(baset* p1, const char * p2);
10815 bool icEqualOArrayG(baset* p1, char ** p2);
10816 bool icEqualOCArrayG(baset* p1, const char ** p2);
10817 bool icEqualOOG(baset* p1, baset* p2);
10818 bool icEqualOSmallArrayG(baset* p1, smallArrayt* p2);
10819 bool icEqualOSmallDictG(baset* p1, smallDictt* p2);
10820 bool icEqualOSmallJsonG(baset* p1, smallJsont* p2);
10821 bool icEqualOSmallStringG(baset* p1, smallStringt* p2);
10822 
10826 smallt *toSmallt(baset *obj);
10827 
10831 baset *toBaset(smallt *obj);
10832 
10838 #define abool atomic_bool
10839 #define aflag atomic_flag
10840 #define ai64 atomic_int_fast64_t
10841 
10842 #define aflagClear(flag) atomic_flag_clear(&(flag))
10843 #define aflagTestNSet(flag) atomic_flag_test_and_set(&(flag))
10844 #define aStore(obj, desired) atomic_store(&(obj), desired)
10845 #define aLoad(obj) atomic_load(&(obj))
10846 #define aCompareExchangeStrong(obj, expected, desired) atomic_compare_exchange_strong(&(obj), &(expected), desired)
10847 #define aFetchAdd(obj, valueToAdd) atomic_fetch_add(&(obj), valueToAdd)
10848 #define aFetchSub(obj, valueToSub) atomic_fetch_sub(&(obj), valueToSub)
10849 
10909 #if (!__OpenBSD__) && ! defined(__TINYC__) && (__GNUC__ > 4)
10910 typedef struct {
10911  i64 last; // last element
10912  i64 head;
10913  i64 maxCount;
10914  bool isEmpty;
10915  /* atomic spinlock */
10916  #if (!__OpenBSD__)
10917  aflag access;
10918  #endif
10919 } aStaticArrayBase;
10920 #endif // (!__OpenBSD__) && ! defined(__TINYC__) && (__GNUC__ > 4)
10921 
10932 #define aStaticArrayT(typeName, element, MAXCOUNT)\
10933  typedef struct {\
10934  i64 last;\
10935  i64 head;\
10936  i64 maxCount;\
10937  bool isEmpty;\
10938  /* atomic spinlock */\
10939  aflag access;\
10940  element list[MAXCOUNT];\
10941  } typeName;
10942 
10949 #define aStaticArrayInit(name)\
10950  do{\
10951  staticArrayInit(name);\
10952  aflagClear((name).access);\
10953  } while(0);
10954 
10959 #define aStaticArrayAcquire(name) while(aflagTestNSet((name).access));
10960 
10965 #define aStaticArrayRelease(name) aflagClear((name).access);
10966 
11026 #define aIndexer aStaticArrayBase
11027 
11032 #define aIndexerT(typeName, INT_TYPE)\
11033  typedef struct {\
11034  INT_TYPE last;\
11035  INT_TYPE head;\
11036  INT_TYPE maxCount;\
11037  abool isEmpty;\
11038  /* atomic spinlock */\
11039  aflag access;\
11040  } typeName;
11041 
11050 #define aIndexerInit(name, MAXCOUNT)\
11051  do{\
11052  indexerInit(name, MAXCOUNT);\
11053  aflagClear((name).access);\
11054  } while(0);
11055 
11060 #define aIndexerAcquire aStaticArrayAcquire
11061 
11066 #define aIndexerRelease aStaticArrayRelease
11067 
11068 
11069 /*
11070  * END - atomic and concurent data structrures
11071  */
11072 
11076 int cpuCount(void);
11077 
11081 typedef void (*recycleContainersFt)(void *arg);
11082 
11087 unsigned registerFinalizeRecycleContainersInThreadPool(recycleContainersFt f);
11088 
11093 void finalizeLibsheepyRecycleContainers(void *arg UNUSED);
11094 
11098 //void finalizeLibsheepy(void);
11099 #define finalizeLibsheepy()
11100 
11110 void finalizeLibsheepyAtExit(void);
11111 
11116 void initLibsheepyObject(void);
11117 
11118 #undef initLibsheepy
11119 #define initLibsheepy(progPath) initLibsheepyF(progPath, initLibsheepyObject)
listAddCG
char ** listAddCG(char **list1, const char **list2)
Definition: libsheepyObject.c:3569
notEqualUint32OG
bool notEqualUint32OG(uint32_t p1 UNUSED, void *p2 UNUSED)
Definition: libsheepyObject.c:5081
getRealProgPathJO
smallJsont * getRealProgPathJO(void)
get real program path The first call allocates libSheepyRealProgPath, it is freed with freeRealProgPa...
Definition: libsheepyObject.c:664
writeFileFromG
int writeFileFromG(const char *string, const char *filePath)
call writeFileS (for writeFileG) (swaps parameters)
Definition: libsheepyObject.c:2623
getCwdJO
smallJsont * getCwdJO(void)
get current working directory
Definition: libsheepyObject.c:2340
cleanUpBaseSmashG
void cleanUpBaseSmashG(baset **val)
Definition: libsheepyObject.c:570
rtF64P
double * rtF64P
Definition: libsheepyObject.c:5728
toStringInt16PGF
char * toStringInt16PGF(int16_t *object)
Definition: libsheepyObject.c:1203
readDirSmallJsonO
smallArrayt * readDirSmallJsonO(smallJsont *dirPath)
Definition: libsheepyObject.c:1664
icListHasCharCG
bool icListHasCharCG(const char **list, char c)
Definition: libsheepyObject.c:3553
equalModificationTimesO
bool equalModificationTimesO(smallStringt *path1, smallStringt *path2)
Definition: libsheepyObject.c:2044
rtU16
uint16_t rtU16
Definition: libsheepyObject.c:5737
moveO
int moveO(smallStringt *src, smallStringt *dst)
Definition: libsheepyObject.c:3173
copySmallJsonSmallJson
int copySmallJsonSmallJson(smallJsont *src, smallJsont *dst)
Definition: libsheepyObject.c:2834
rtSmallBytest
smallBytest * rtSmallBytest
Definition: libsheepyObject.c:5742
putsJsonGF
void putsJsonGF(smallJsont *object)
Definition: libsheepyObject.c:982
s
char * s
Definition: libsheepyObjectTest.c:27
icListEqC1G
bool icListEqC1G(const char **list1, char **list2)
Definition: libsheepyObject.c:3503
equalDoubleFG
bool equalDoubleFG(double p1, double p2)
Definition: libsheepyObject.c:4282
readDirAllO
smallArrayt * readDirAllO(const char *dirPath)
list files in a directory and sort the list
Definition: libsheepyObject.c:1830
writeTextStreamCG
bool writeTextStreamCG(const char **list, FILE *fp)
Definition: libsheepyObject.c:2698
toStringSmallBoolGF
char * toStringSmallBoolGF(smallBoolt *object)
Definition: libsheepyObject.c:1325
execSmallJsonO
int execSmallJsonO(smallJsont *cmd, smallArrayt *out, smallArrayt *err)
Definition: libsheepyObject.c:1445
isDirO
bool isDirO(smallStringt *path)
Definition: libsheepyObject.c:2419
mkdirParentsSmallJsonO
int mkdirParentsSmallJsonO(smallJsont *path)
recursive mkdir
Definition: libsheepyObject.c:2718
copyO
int copyO(smallStringt *src, smallStringt *dst)
copy files recursively
Definition: libsheepyObject.c:2768
equalUint32SmallIntG
bool equalUint32SmallIntG(uint32_t p1, smallIntt *p2)
Definition: libsheepyObject.c:4840
readTextSmallStringNotSupported
void readTextSmallStringNotSupported(char ***self UNUSED, smallStringt *path UNUSED)
Definition: libsheepyObject.c:2602
equalUint32SmallJsonG
bool equalUint32SmallJsonG(uint32_t p1, smallJsont *p2)
Definition: libsheepyObject.c:4849
obj
obj f free & obj
Definition: libsheepyObjectTest.c:265
writeTextCCSmallStringNotSupported
int writeTextCCSmallStringNotSupported(const char **self UNUSED, smallStringt *path UNUSED)
Definition: libsheepyObject.c:2657
freeBaseFt
void(* freeBaseFt)(baset *self)
free buffers in obj
Definition: libsheepyObject.h:9555
listGetG
char * listGetG(char **list, int retType UNUSED, int64_t index)
call listGetS for getG
Definition: libsheepyObject.c:3448
notEqualOInt64G
bool notEqualOInt64G(void *p1 UNUSED, int64_t p2 UNUSED)
Definition: libsheepyObject.c:5101
renameSO
int renameSO(const char *src, smallStringt *dst)
Definition: libsheepyObject.c:3074
readStreamToG
char * readStreamToG(char **string, FILE *fp)
Definition: libsheepyObject.c:2586
equalUint32Int32G
bool equalUint32Int32G(uint32_t p1, int32_t p2)
Definition: libsheepyObject.c:4778
equalCharDoubleG
bool equalCharDoubleG(const char *s, double value)
Definition: libsheepyObject.c:3704
equalBoolSmallJsonG
bool equalBoolSmallJsonG(bool p1, smallJsont *p2)
Definition: libsheepyObject.c:4202
baseFunctionst::duplicate
duplicateBaseFt duplicate
Definition: libsheepyObject.h:9589
walkDirSmallJsonO
smallArrayt * walkDirSmallJsonO(smallJsont *dirPath)
Definition: libsheepyObject.c:1486
equalInt32SmallBoolG
bool equalInt32SmallBoolG(int32_t p1, smallBoolt *p2)
Definition: libsheepyObject.c:4631
systemNFreeOF
int systemNFreeOF(smallStringt *command, int line, const char *thisFunc, const char *thisFileName)
Definition: libsheepyObject.c:727
readTextSmallJsonNotSupported
void readTextSmallJsonNotSupported(char ***self UNUSED, smallJsont *path UNUSED)
Definition: libsheepyObject.c:2595
listLengthCG
size_t listLengthCG(const char **list)
Definition: libsheepyObject.c:3513
equalDoubleSmallDoubleG
bool equalDoubleSmallDoubleG(double p1, smallDoublet *p2)
Definition: libsheepyObject.c:4345
getCwdO
smallStringt * getCwdO(void)
Definition: libsheepyObject.c:2357
equalCArraySmallJsonG
bool equalCArraySmallJsonG(const char **p1, smallJsont *p2)
Definition: libsheepyObject.c:3881
aflag
#define aflag
Definition: libsheepyObject.h:10839
walkDirAllSmallJsonO
smallArrayt * walkDirAllSmallJsonO(smallJsont *dirPath)
Definition: libsheepyObject.c:1772
equalInt64DoubleG
bool equalInt64DoubleG(int64_t p1, double p2)
Definition: libsheepyObject.c:4444
equalModificationTimesJOS
bool equalModificationTimesJOS(smallJsont *path1, const char *path2)
Definition: libsheepyObject.c:1993
toStringListCSGF
char * toStringListCSGF(const char **object)
Definition: libsheepyObject.c:1294
putsArrayGF
void putsArrayGF(smallArrayt *object)
Definition: libsheepyObject.c:995
equalUint64FG
bool equalUint64FG(uint64_t p1, uint64_t p2)
Definition: libsheepyObject.c:4950
rmAllSmallJsonO
int rmAllSmallJsonO(smallJsont *path)
remove all delete recursively files and directories
Definition: libsheepyObject.c:2743
readStreamToNewG
void * readStreamToNewG(void *none UNUSED, FILE *fp)
Definition: libsheepyObject.c:2572
fileExistsJO
bool fileExistsJO(smallJsont *filePath)
detect files and directories
Definition: libsheepyObject.c:2470
rtUint64_tP
uint64_t * rtUint64_tP
Definition: libsheepyObject.c:5723
fileChmodJO
bool fileChmodJO(smallJsont *filePath, mode_t mode)
like chmod in stdlibc but return true/false
Definition: libsheepyObject.c:2499
rtDoubleP
double * rtDoubleP
Definition: libsheepyObject.c:5717
shSysinfo
smallDictt * shSysinfo(void)
sheepy sysinfo
Definition: libsheepyObject.c:526
appendTextCG
bool appendTextCG(const char **list, const char *filePath)
Definition: libsheepyObject.c:2713
timeToSO
smallStringt * timeToSO(const time_t t)
Definition: libsheepyObject.c:2094
rtVoid
void * rtVoid
Definition: libsheepyObject.c:5748
isLinkJO
bool isLinkJO(smallJsont *path)
is symbolic link
Definition: libsheepyObject.c:2437
icEqualOSmallJsonG
bool icEqualOSmallJsonG(baset *p1, smallJsont *p2)
Definition: libsheepyObject.c:5383
equalCharUint64G
bool equalCharUint64G(const char *s, uint64_t value)
Definition: libsheepyObject.c:3724
equalCArraySmallArrayG
bool equalCArraySmallArrayG(const char **p1, smallArrayt *p2)
Definition: libsheepyObject.c:3900
icEqualOSmallDictG
bool icEqualOSmallDictG(baset *p1, smallDictt *p2)
Definition: libsheepyObject.c:5370
mkdirParentsO
int mkdirParentsO(smallStringt *path)
Definition: libsheepyObject.c:2733
equalBoolOG
bool equalBoolOG(bool p1, baset *p2)
Definition: libsheepyObject.c:4110
renameSmallJsonOS
int renameSmallJsonOS(smallJsont *src, const char *dst)
Definition: libsheepyObject.c:2991
appendTextSG
bool appendTextSG(char **list, const char *filePath)
call appendText (for appendFileG) (swaps parameters)
Definition: libsheepyObject.c:2708
equalInt64SmallBoolG
bool equalInt64SmallBoolG(int64_t p1, smallBoolt *p2)
Definition: libsheepyObject.c:4469
readDirDirSmallStringO
smallArrayt * readDirDirSmallStringO(smallStringt *dirPath)
Definition: libsheepyObject.c:1746
systemJO
int systemJO(smallJsont *command)
run system command in a smallString
Definition: libsheepyObject.c:679
rtUint64_t
uint64_t rtUint64_t
Definition: libsheepyObject.c:5722
equalBoolSmallIntG
bool equalBoolSmallIntG(bool p1, smallIntt *p2)
Definition: libsheepyObject.c:4193
toStringInt32GF
char * toStringInt32GF(int32_t object)
Definition: libsheepyObject.c:1185
terminateManyOF
void terminateManyOF(void *paramType,...)
terminate many baset objects
Definition: libsheepyObject.c:595
equalInt64SmallBytesG
bool equalInt64SmallBytesG(int64_t p1, smallBytest *p2)
Definition: libsheepyObject.c:4478
setModificationTimeO
int setModificationTimeO(smallStringt *path, time_t mtime)
Definition: libsheepyObject.c:1941
writeStreamFromG
int writeStreamFromG(const char *string, FILE *fp)
Definition: libsheepyObject.c:2628
writeTextCCSmallJsonNotSupported
int writeTextCCSmallJsonNotSupported(const char **self UNUSED, smallJsont *path UNUSED)
Definition: libsheepyObject.c:2649
equalOCArrayG
bool equalOCArrayG(baset *p1, const char **p2)
Definition: libsheepyObject.c:3928
getSG
char getSG(const char *string, int retType UNUSED, int64_t index)
call getS for getG
Definition: libsheepyObject.c:3443
undefined
undefinedt * undefined
undefined/null object for setting undefined/null in small data structures pushG(a, undefined);
Definition: libsheepyObject.c:5706
notEqualOG
bool notEqualOG(void *a UNUSED, void *b UNUSED)
Definition: libsheepyObject.c:5051
expandHomeJO
smallJsont * expandHomeJO(smallJsont *path)
expands ~/ ($HOME) or ~USER duplicate and expand path.
Definition: libsheepyObject.c:2155
rtUint32_tP
uint32_t * rtUint32_tP
Definition: libsheepyObject.c:5725
fileSizeJO
ssize_t fileSizeJO(smallJsont *filePath)
get file size
Definition: libsheepyObject.c:2529
equalDoubleCharG
bool equalDoubleCharG(double p1, const char *p2)
Definition: libsheepyObject.c:4236
toStringBoolGF
char * toStringBoolGF(bool object)
Definition: libsheepyObject.c:1111
eqCharChar
bool eqCharChar(char c, char value)
equality functions
Definition: libsheepyObject.c:3579
rtF64
double rtF64
Definition: libsheepyObject.c:5727
equalInt64FG
bool equalInt64FG(int64_t p1, int64_t p2)
Definition: libsheepyObject.c:4449
readSmallJsonO
smallJsont * readSmallJsonO(void)
read String read user input (one line) as a string
Definition: libsheepyObject.c:3313
rtInt64_tP
int64_t * rtInt64_tP
Definition: libsheepyObject.c:5719
normalizePathO
smallStringt * normalizePathO(smallStringt *path)
Definition: libsheepyObject.c:2254
equalChaSmallDoubleG
bool equalChaSmallDoubleG(char c, smallDoublet *value)
Definition: libsheepyObject.c:3636
notEqualOInt32G
bool notEqualOInt32G(void *p1 UNUSED, int32_t p2 UNUSED)
Definition: libsheepyObject.c:5106
icListEqCCG
bool icListEqCCG(const char **list1, const char **list2)
Definition: libsheepyObject.c:3508
putsUndefinedGF
void putsUndefinedGF(undefinedt *object)
Definition: libsheepyObject.c:798
smallt
base class for the small objects all small objects have a type
Definition: libsheepySmall.h:67
equalDoubleUint64G
bool equalDoubleUint64G(double p1, uint64_t p2)
Definition: libsheepyObject.c:4302
base::f
baseFunctionst * f
Definition: libsheepyObject.h:9599
baseFunctionst::finish
finishBaseFt finish
Definition: libsheepyObject.h:9591
moveSO
int moveSO(const char *src, smallStringt *dst)
Definition: libsheepyObject.c:3233
toStringDoublePGF
char * toStringDoublePGF(double *object)
Definition: libsheepyObject.c:1161
rtDouble
double rtDouble
Definition: libsheepyObject.c:5716
equalModificationTimesJOO
bool equalModificationTimesJOO(smallJsont *path1, smallStringt *path2)
Definition: libsheepyObject.c:2010
joinCG
char * joinCG(const char **list, const char *delim)
Definition: libsheepyObject.c:3558
rtU32
uint32_t rtU32
Definition: libsheepyObject.c:5735
equalInt32SmallStringG
bool equalInt32SmallStringG(int32_t p1, smallStringt *p2)
Definition: libsheepyObject.c:4700
equalModificationTimesSO
bool equalModificationTimesSO(const char *path1, smallStringt *path2)
Definition: libsheepyObject.c:2061
rtU64
uint64_t rtU64
Definition: libsheepyObject.c:5733
equalOArrayG
bool equalOArrayG(baset *p1, char **p2)
Definition: libsheepyObject.c:3923
listHasCG
bool listHasCG(const char **list, const char *string)
Definition: libsheepyObject.c:3543
listEqC1G
bool listEqC1G(const char **list1, char **list2)
Definition: libsheepyObject.c:3488
toStringUint8GF
char * toStringUint8GF(uint8_t object)
Definition: libsheepyObject.c:1252
fileSizeO
ssize_t fileSizeO(smallStringt *filePath)
Definition: libsheepyObject.c:2544
writeTextSG
bool writeTextSG(char **list, const char *filePath)
call writeText (for writeFileG) (swaps parameters)
Definition: libsheepyObject.c:2683
equalArrayOG
bool equalArrayOG(char **p1, baset *p2)
Definition: libsheepyObject.c:3789
readLineSmallJsonO
smallJsont * readLineSmallJsonO(FILE *fp)
readLine from file stream the fist new line is converted to 0
Definition: libsheepyObject.c:3377
equalBoolSmallDoubleG
bool equalBoolSmallDoubleG(bool p1, smallDoublet *p2)
Definition: libsheepyObject.c:4184
equalCharSmallIntG
bool equalCharSmallIntG(const char *s, smallIntt *value)
Definition: libsheepyObject.c:3753
b
baset * b
Definition: libsheepyObjectTest.c:402
rtBool
bool rtBool
Definition: libsheepyObject.c:5714
equalBoolSmallStringG
bool equalBoolSmallStringG(bool p1, smallStringt *p2)
Definition: libsheepyObject.c:4215
baseFunctionst
base class functions
Definition: libsheepyObject.h:9585
equalUint32FG
bool equalUint32FG(uint32_t p1, uint32_t p2)
Definition: libsheepyObject.c:4783
icListIndexOfCG
ssize_t icListIndexOfCG(const char **list, const char *string)
Definition: libsheepyObject.c:3528
listDequeueG
char * listDequeueG(char ***list, int retType UNUSED)
call listDequeueS for dequeueG
Definition: libsheepyObject.c:3473
getModificationTimeO
time_t getModificationTimeO(smallStringt *path)
Definition: libsheepyObject.c:1912
putsListSGF
void putsListSGF(char **object)
Definition: libsheepyObject.c:959
putsSmallBytesGF
void putsSmallBytesGF(smallBytest *object)
Definition: libsheepyObject.c:1021
getProgPathJO
smallJsont * getProgPathJO(void)
get program path When initLibsheepy is called before this function, it returns the given program path...
Definition: libsheepyObject.c:649
equalInt32Uint32G
bool equalInt32Uint32G(int32_t p1, uint32_t p2)
Definition: libsheepyObject.c:4621
rtUint32_t
uint32_t rtUint32_t
Definition: libsheepyObject.c:5724
baseFunctionst::terminate
terminateBaseFt terminate
Definition: libsheepyObject.h:9587
icEqualOCArrayG
bool icEqualOCArrayG(baset *p1, const char **p2)
Definition: libsheepyObject.c:5333
toStringArrayGF
char * toStringArrayGF(smallArrayt *object)
Definition: libsheepyObject.c:1317
toStringBaseFt
char *(* toStringBaseFt)(baset *self)
convert data in obj to string
Definition: libsheepyObject.h:9565
equalDoubleSmallStringG
bool equalDoubleSmallStringG(double p1, smallStringt *p2)
Definition: libsheepyObject.c:4376
rtSmallArrayt
smallArrayt * rtSmallArrayt
Definition: libsheepyObject.c:5740
walkDirSmallStringO
smallArrayt * walkDirSmallStringO(smallStringt *dirPath)
Definition: libsheepyObject.c:1501
toStringCharGF
char * toStringCharGF(char object)
Definition: libsheepyObject.c:1265
equalInt64ChaG
bool equalInt64ChaG(int64_t p1, char p2)
Definition: libsheepyObject.c:4393
listPopG
char * listPopG(char ***list, int retType UNUSED)
call listPopS for popG
Definition: libsheepyObject.c:3468
toStringSmallContainerGF
char * toStringSmallContainerGF(smallContainert *object)
Definition: libsheepyObject.c:1373
setModificationTimeJO
int setModificationTimeJO(smallJsont *path, time_t mtime)
set modification time for path
Definition: libsheepyObject.c:1924
rtInt32_t
int32_t rtInt32_t
Definition: libsheepyObject.c:5720
toStringUint16GF
char * toStringUint16GF(uint16_t object)
Definition: libsheepyObject.c:1239
listPrintCG
int listPrintCG(const char **list)
Definition: libsheepyObject.c:3574
rtSmallBoolt
smallBoolt * rtSmallBoolt
Definition: libsheepyObject.c:5741
cleanUpBaseTerminateG
void cleanUpBaseTerminateG(baset **val)
Definition: libsheepyObject.c:555
icEqualCharOG
bool icEqualCharOG(const char *s, baset *value)
Definition: libsheepyObject.c:5157
equalModificationTimesJO
bool equalModificationTimesJO(smallJsont *path1, smallJsont *path2)
compare modification times for path1 and path2
Definition: libsheepyObject.c:1953
readToFileSmallJsonNotSupported
void readToFileSmallJsonNotSupported(void *self UNUSED, smallJsont *path UNUSED)
Definition: libsheepyObject.c:2609
equalOInt32G
bool equalOInt32G(baset *p1, int32_t p2)
Definition: libsheepyObject.c:3967
notEqualInt64OG
bool notEqualInt64OG(int64_t p1 UNUSED, void *p2 UNUSED)
Definition: libsheepyObject.c:5071
equalInt32CharG
bool equalInt32CharG(int32_t p1, const char *p2)
Definition: libsheepyObject.c:4560
equalChaInt32G
bool equalChaInt32G(char c, int32_t value)
Definition: libsheepyObject.c:3607
putsDoubleGF
void putsDoubleGF(double object)
Definition: libsheepyObject.c:832
equalUint64ChaG
bool equalUint64ChaG(uint64_t p1, char p2)
Definition: libsheepyObject.c:4879
moveSmallJsonSmallJson
int moveSmallJsonSmallJson(smallJsont *src, smallJsont *dst)
Definition: libsheepyObject.c:3117
notEqualOBoolG
bool notEqualOBoolG(void *p1 UNUSED, bool p2 UNUSED)
Definition: libsheepyObject.c:5091
iicListUniqG
char ** iicListUniqG(char ***list, int dum UNUSED)
call iicListUniqS for icUniqG
Definition: libsheepyObject.c:3428
array
char * array[]
Definition: libsheepyObjectTest.c:1278
equalUint32SmallBoolG
bool equalUint32SmallBoolG(uint32_t p1, smallBoolt *p2)
Definition: libsheepyObject.c:4793
timeToJO
smallJsont * timeToJO(const time_t t)
time To String convert unix time to string (ctime is not used here because it adds at the end of th...
Definition: libsheepyObject.c:2081
walkDirDirSmallJsonO
smallArrayt * walkDirDirSmallJsonO(smallJsont *dirPath)
Definition: libsheepyObject.c:1563
toStringUint32GF
char * toStringUint32GF(uint32_t object)
Definition: libsheepyObject.c:1226
fileExistsO
bool fileExistsO(smallStringt *filePath)
Definition: libsheepyObject.c:2485
appendFileSG
bool appendFileSG(const char *string, const char *filePath)
call appendFileS (for appendFileG) (swaps parameters)
Definition: libsheepyObject.c:2703
equalDoubleBaseG
bool equalDoubleBaseG(double p1, baset *p2)
Definition: libsheepyObject.c:4251
toStringInt16GF
char * toStringInt16GF(int16_t object)
Definition: libsheepyObject.c:1198
equalUint64BaseG
bool equalUint64BaseG(uint64_t p1, baset *p2)
Definition: libsheepyObject.c:4899
equalUint32SmallStringG
bool equalUint32SmallStringG(uint32_t p1, smallStringt *p2)
Definition: libsheepyObject.c:4862
readFileToG
char * readFileToG(char **string, const char *filePath)
Definition: libsheepyObject.c:2577
err
#define err(str)
Definition: tpool.c:35
readDirAllSmallStringO
smallArrayt * readDirAllSmallStringO(smallStringt *dirPath)
Definition: libsheepyObject.c:1887
equalUint32SmallDoubleG
bool equalUint32SmallDoubleG(uint32_t p1, smallDoublet *p2)
Definition: libsheepyObject.c:4831
toStringSmallDoubleGF
char * toStringSmallDoubleGF(smallDoublet *object)
Definition: libsheepyObject.c:1341
rtSmallIntt
smallIntt * rtSmallIntt
Definition: libsheepyObject.c:5745
toStringSmallStringGF
char * toStringSmallStringGF(smallStringt *object)
Definition: libsheepyObject.c:1357
icEqualCharPSmallJsonG
bool icEqualCharPSmallJsonG(const char *s, smallJsont *value)
Definition: libsheepyObject.c:5169
equalOSmallDictG
bool equalOSmallDictG(baset *p1, smallDictt *p2)
Definition: libsheepyObject.c:4034
icEqualCArraySmallArrayG
bool icEqualCArraySmallArrayG(const char **p1, smallArrayt *p2)
Definition: libsheepyObject.c:5305
putsUintPGF
void putsUintPGF(uint64_t *object)
Definition: libsheepyObject.c:914
equalBoolInt64G
bool equalBoolInt64G(bool p1, int64_t p2)
Definition: libsheepyObject.c:4140
equalCharUint32G
bool equalCharUint32G(const char *s, uint32_t value)
Definition: libsheepyObject.c:3719
finishBaseFt
void(* finishBaseFt)(baset **self)
free only baset container and keep the sObject inside
Definition: libsheepyObject.h:9580
equalInt64CharG
bool equalInt64CharG(int64_t p1, const char *p2)
Definition: libsheepyObject.c:4398
equalBoolInt32G
bool equalBoolInt32G(bool p1, int32_t p2)
Definition: libsheepyObject.c:4145
toStringVoidGF
char * toStringVoidGF(void *object)
Definition: libsheepyObject.c:1365
equalCharBoolG
bool equalCharBoolG(const char *s, bool value)
Definition: libsheepyObject.c:3699
equalOInt64G
bool equalOInt64G(baset *p1, int64_t p2)
Definition: libsheepyObject.c:3962
fileChmodO
bool fileChmodO(smallStringt *filePath, mode_t mode)
Definition: libsheepyObject.c:2514
rtBaset
baset * rtBaset
Generic return types getG(dict, rtBool, "a");.
Definition: libsheepyObject.c:5712
readDirDirO
smallArrayt * readDirDirO(const char *dirPath)
list directories in a directory and sort the list
Definition: libsheepyObject.c:1687
cleanUpBaseFinishG
void cleanUpBaseFinishG(baset **val)
Definition: libsheepyObject.c:565
finalizeLibsheepyRecycleContainers
void finalizeLibsheepyRecycleContainers(void *arg UNUSED)
function called automatically (registered in tpool) when a thread exits This function calls all the r...
Definition: libsheepyObject.c:5612
execO
int execO(const char *cmd, smallArrayt *out, smallArrayt *err)
execute command return stdout from cmd in *out
copyOS
int copyOS(smallStringt *src, const char *dst)
Definition: libsheepyObject.c:2894
equalOSmallBytesG
bool equalOSmallBytesG(baset *p1, smallBytest *p2)
Definition: libsheepyObject.c:4008
toStringSmallIntGF
char * toStringSmallIntGF(smallIntt *object)
Definition: libsheepyObject.c:1349
equalUint64DoubleG
bool equalUint64DoubleG(uint64_t p1, double p2)
Definition: libsheepyObject.c:4930
walkDirO
smallArrayt * walkDirO(const char *dirPath)
list all files in a directory recursively the directories are not listed
Definition: libsheepyObject.c:1468
recycleContainersFt
void(* recycleContainersFt)(void *arg)
function pointer freeing the unused containers of a class in a thread
Definition: libsheepyObject.h:11081
toStringSmallBytesGF
char * toStringSmallBytesGF(smallBytest *object)
Definition: libsheepyObject.c:1333
equalChaUint32G
bool equalChaUint32G(char c, uint32_t value)
Definition: libsheepyObject.c:3613
equalUint32CharG
bool equalUint32CharG(uint32_t p1, const char *p2)
Definition: libsheepyObject.c:4722
toStringDoubleGF
char * toStringDoubleGF(double object)
Definition: libsheepyObject.c:1153
intToSG
char * intToSG(char *retType UNUSED, int64_t n)
call intToS for intToG
Definition: libsheepyObject.c:3413
equalOBoolG
bool equalOBoolG(baset *p1, bool p2)
Definition: libsheepyObject.c:3952
iListGetG
char * iListGetG(char **list, int retType UNUSED, int64_t index)
call iListGetS for getG
Definition: libsheepyObject.c:3458
rtI64
int64_t rtI64
Definition: libsheepyObject.c:5729
readDirAllSmallJsonO
smallArrayt * readDirAllSmallJsonO(smallJsont *dirPath)
Definition: libsheepyObject.c:1872
putsSGF
void putsSGF(const char *object)
Definition: libsheepyObject.c:951
iListUniqG
char ** iListUniqG(char ***list, int dum UNUSED)
call iListUniqS for uniqG
Definition: libsheepyObject.c:3423
readDirDirSmallJsonO
smallArrayt * readDirDirSmallJsonO(smallJsont *dirPath)
Definition: libsheepyObject.c:1731
icEqualOCharG
bool icEqualOCharG(baset *p1, const char *p2)
Definition: libsheepyObject.c:5318
equalCharInt32G
bool equalCharInt32G(const char *s, int32_t value)
Definition: libsheepyObject.c:3714
rtI32P
int32_t * rtI32P
Definition: libsheepyObject.c:5732
copyOSmallJson
int copyOSmallJson(smallStringt *src, smallJsont *dst)
Definition: libsheepyObject.c:2904
writeTextSmallStringNotSupported
int writeTextSmallStringNotSupported(char **self UNUSED, smallStringt *path UNUSED)
Definition: libsheepyObject.c:2641
i64
#define i64
Definition: libsheepy.h:444
putsListCSGF
void putsListCSGF(const char **object)
Definition: libsheepyObject.c:964
expandHomeO
smallStringt * expandHomeO(smallStringt *path)
Definition: libsheepyObject.c:2189
equalBoolUint32G
bool equalBoolUint32G(bool p1, uint32_t p2)
Definition: libsheepyObject.c:4150
rtU64P
uint64_t * rtU64P
Definition: libsheepyObject.c:5734
putsDictGF
void putsDictGF(smallDictt *object)
Definition: libsheepyObject.c:969
fp
END_TEST FILE * fp
Definition: libsheepyObjectTest.c:2195
rtUndefinedt
undefinedt * rtUndefinedt
Definition: libsheepyObject.c:5713
equalBoolUint64G
bool equalBoolUint64G(bool p1, uint64_t p2)
Definition: libsheepyObject.c:4155
equalDoubleInt64G
bool equalDoubleInt64G(double p1, int64_t p2)
Definition: libsheepyObject.c:4287
equalCharSmallBoolG
bool equalCharSmallBoolG(const char *s, smallBoolt *value)
Definition: libsheepyObject.c:3729
copySO
int copySO(const char *src, smallStringt *dst)
Definition: libsheepyObject.c:2801
equalInt32Uint64G
bool equalInt32Uint64G(int32_t p1, uint64_t p2)
Definition: libsheepyObject.c:4626
equalDoubleInt32G
bool equalDoubleInt32G(double p1, int32_t p2)
Definition: libsheepyObject.c:4292
equalUint64SmallBoolG
bool equalUint64SmallBoolG(uint64_t p1, smallBoolt *p2)
Definition: libsheepyObject.c:4955
listIndexOfCharCG
ssize_t listIndexOfCharCG(const char **list, char c)
Definition: libsheepyObject.c:3523
notEqualBoolOG
bool notEqualBoolOG(bool p1 UNUSED, void *p2 UNUSED)
Definition: libsheepyObject.c:5061
toStringUint8PGF
char * toStringUint8PGF(uint8_t *object)
Definition: libsheepyObject.c:1257
equalInt64SmallStringG
bool equalInt64SmallStringG(int64_t p1, smallStringt *p2)
Definition: libsheepyObject.c:4538
equalDoubleSmallIntG
bool equalDoubleSmallIntG(double p1, smallIntt *p2)
Definition: libsheepyObject.c:4354
equalInt32BoolG
bool equalInt32BoolG(int32_t p1, bool p2)
Definition: libsheepyObject.c:4601
toStringIntPGF
char * toStringIntPGF(int64_t *object)
Definition: libsheepyObject.c:1177
equalInt64Int32G
bool equalInt64Int32G(int64_t p1, int32_t p2)
Definition: libsheepyObject.c:4454
finalizeLibsheepyAtExit
void finalizeLibsheepyAtExit(void)
free class methods for all classes the objects and classes are not usuable after this an object has t...
Definition: libsheepyObject.c:5620
putsUint32GF
void putsUint32GF(uint32_t object)
Definition: libsheepyObject.c:928
cleanUpBaseFreeG
void cleanUpBaseFreeG(baset **val)
Definition: libsheepyObject.c:560
c
char c
Definition: libsheepyObjectTest.c:246
isDirJO
bool isDirJO(smallJsont *path)
is directory
Definition: libsheepyObject.c:2404
equalArraySmallArrayG
bool equalArraySmallArrayG(char **p1, smallArrayt *p2)
Definition: libsheepyObject.c:3868
equalUint64BoolG
bool equalUint64BoolG(uint64_t p1, bool p2)
Definition: libsheepyObject.c:4925
equalDoubleSmallJsonG
bool equalDoubleSmallJsonG(double p1, smallJsont *p2)
Definition: libsheepyObject.c:4363
equalOOG
bool equalOOG(baset *p1, baset *p2)
Definition: libsheepyObject.c:3933
systemO
int systemO(smallStringt *command)
Definition: libsheepyObject.c:694
equalCharPSmallStringG
bool equalCharPSmallStringG(const char *s, smallStringt *value)
Definition: libsheepyObject.c:3780
equalUint64SmallIntG
bool equalUint64SmallIntG(uint64_t p1, smallIntt *p2)
Definition: libsheepyObject.c:5002
renameSmallJsonSmallJson
int renameSmallJsonSmallJson(smallJsont *src, smallJsont *dst)
Definition: libsheepyObject.c:2958
libsheepyCSmallJson.h
smallJson class
equalBoolChaG
bool equalBoolChaG(bool p1 UNUSED, char p2 UNUSED)
Definition: libsheepyObject.c:4090
equalUint64SmallStringG
bool equalUint64SmallStringG(uint64_t p1, smallStringt *p2)
Definition: libsheepyObject.c:5024
equalODoubleG
bool equalODoubleG(baset *p1, double p2)
Definition: libsheepyObject.c:3957
listDupCG
char ** listDupCG(const char **list)
Definition: libsheepyObject.c:3478
equalCharSmallBytesG
bool equalCharSmallBytesG(const char *s, smallBytest *value)
Definition: libsheepyObject.c:3737
equalCharSmallDoubleG
bool equalCharSmallDoubleG(const char *s, smallDoublet *value)
Definition: libsheepyObject.c:3745
icEqualOChaG
bool icEqualOChaG(baset *p1, char p2)
Definition: libsheepyObject.c:5323
toStringBoolPGF
char * toStringBoolPGF(bool *object)
Definition: libsheepyObject.c:1121
toStringIntGF
char * toStringIntGF(int64_t object)
Definition: libsheepyObject.c:1172
notEqualOUint32G
bool notEqualOUint32G(void *p1 UNUSED, uint32_t p2 UNUSED)
Definition: libsheepyObject.c:5111
rtI32
int32_t rtI32
Definition: libsheepyObject.c:5731
equalCArrayOG
bool equalCArrayOG(const char **p1, baset *p2)
Definition: libsheepyObject.c:3819
libsheepy.h
This file has basic file, random, string, list functions.
rtBoolP
bool * rtBoolP
Definition: libsheepyObject.c:5715
equalInt64SmallJsonG
bool equalInt64SmallJsonG(int64_t p1, smallJsont *p2)
Definition: libsheepyObject.c:4525
equalArraySmallJsonG
bool equalArraySmallJsonG(char **p1, smallJsont *p2)
Definition: libsheepyObject.c:3849
copySmallJsonOS
int copySmallJsonOS(smallJsont *src, const char *dst)
Definition: libsheepyObject.c:2811
readTextSG
char ** readTextSG(char ***list, const char *filePath)
call readText (for readFileG)
Definition: libsheepyObject.c:2665
registerFinalizeRecycleContainersInThreadPool
unsigned registerFinalizeRecycleContainersInThreadPool(recycleContainersFt f)
register function freeing the unused containers a finalizeRecycle must be registered for each class i...
Definition: libsheepyObject.c:5606
equalOSmallStringG
bool equalOSmallStringG(baset *p1, smallStringt *p2)
Definition: libsheepyObject.c:4073
equalModificationTimesSJO
bool equalModificationTimesSJO(const char *path1, smallJsont *path2)
Definition: libsheepyObject.c:1976
rtInt32_tP
int32_t * rtInt32_tP
Definition: libsheepyObject.c:5721
otos
char * otos(void *basetObj)
object to string for debug this function is used for printing an object in gdb, lldb, any debugger, in gdb: p otos(obj) a longer alternative to print an object is: p obj->f->toString(obj)
Definition: libsheepyObject.c:1389
icEqualCArraySmallJsonG
bool icEqualCArraySmallJsonG(const char **p1, smallJsont *p2)
Definition: libsheepyObject.c:5272
putsUintGF
void putsUintGF(uint64_t object)
Definition: libsheepyObject.c:903
normalizePathJO
smallJsont * normalizePathJO(smallJsont *path)
normalize path
Definition: libsheepyObject.c:2236
toStringListSGF
char * toStringListSGF(char **object)
Definition: libsheepyObject.c:1279
icEqualArraySmallArrayG
bool icEqualArraySmallArrayG(char **p1, smallArrayt *p2)
Definition: libsheepyObject.c:5292
equalInt32SmallIntG
bool equalInt32SmallIntG(int32_t p1, smallIntt *p2)
Definition: libsheepyObject.c:4678
putsBoolGF
void putsBoolGF(bool object)
Definition: libsheepyObject.c:809
toBaset
baset * toBaset(smallt *obj)
convert smallt object to baset
Definition: libsheepyObject.c:5499
equalUint64Int64G
bool equalUint64Int64G(uint64_t p1, int64_t p2)
Definition: libsheepyObject.c:4935
equalChaSmallStringG
bool equalChaSmallStringG(char c, smallStringt *value)
Definition: libsheepyObject.c:3676
icEqualChaSmallStringG
bool icEqualChaSmallStringG(char c, smallStringt *value)
Definition: libsheepyObject.c:5147
baseFunctionst::toString
toStringBaseFt toString
Definition: libsheepyObject.h:9588
toStringDictGF
char * toStringDictGF(smallDictt *object)
Definition: libsheepyObject.c:1309
equalInt32SmallDoubleG
bool equalInt32SmallDoubleG(int32_t p1, smallDoublet *p2)
Definition: libsheepyObject.c:4669
equalUint64SmallBytesG
bool equalUint64SmallBytesG(uint64_t p1, smallBytest *p2)
Definition: libsheepyObject.c:4964
putsInt32GF
void putsInt32GF(int32_t object)
Definition: libsheepyObject.c:880
rtChar
char * rtChar
Definition: libsheepyObject.c:5739
rtI64P
int64_t * rtI64P
Definition: libsheepyObject.c:5730
equalBoolDoubleG
bool equalBoolDoubleG(bool p1, double p2)
Definition: libsheepyObject.c:4135
equalInt32FG
bool equalInt32FG(int32_t p1, int32_t p2)
Definition: libsheepyObject.c:4616
getRealProgPathO
smallStringt * getRealProgPathO(void)
Definition: libsheepyObject.c:674
equalOSmallBoolG
bool equalOSmallBoolG(baset *p1, smallBoolt *p2)
Definition: libsheepyObject.c:3995
base::type
const char * type
Definition: libsheepyObject.h:9598
icEqualArrayOG
bool icEqualArrayOG(char **p1, baset *p2)
Definition: libsheepyObject.c:5192
equalOCharG
bool equalOCharG(baset *p1, const char *p2)
Definition: libsheepyObject.c:3913
toStringFloatPGF
char * toStringFloatPGF(float *object)
Definition: libsheepyObject.c:1142
equalChaInt64G
bool equalChaInt64G(char c, int64_t value)
Definition: libsheepyObject.c:3601
putsOF
void putsOF(baset *object)
puts for objects using toString
Definition: libsheepyObject.c:787
rtSmallContainert
smallContainert * rtSmallContainert
Definition: libsheepyObject.c:5749
equalOChaG
bool equalOChaG(baset *p1, char p2)
Definition: libsheepyObject.c:3918
rtU8
uint8_t rtU8
Definition: libsheepyObject.c:5738
icEqualChaSmallJsonG
bool icEqualChaSmallJsonG(char c, smallJsont *value)
Definition: libsheepyObject.c:5133
readTextStreamG
char ** readTextStreamG(char ***list, FILE *fp)
Definition: libsheepyObject.c:2674
putsSmallDoubleGF
void putsSmallDoubleGF(smallDoublet *object)
Definition: libsheepyObject.c:1034
moveOS
int moveOS(smallStringt *src, const char *dst)
Definition: libsheepyObject.c:3241
randomAlphaNumSO
smallStringt * randomAlphaNumSO(uint64_t length)
Definition: libsheepyObject.c:3297
equalChaUint64G
bool equalChaUint64G(char c, uint64_t value)
Definition: libsheepyObject.c:3619
renameO
int renameO(smallStringt *src, smallStringt *dst)
Definition: libsheepyObject.c:3014
toStringOF
char * toStringOF(baset *object)
convert data in obj to string
Definition: libsheepyObject.c:1095
equalCharOG
bool equalCharOG(const char *s, baset *value)
Definition: libsheepyObject.c:3687
equalOUint64G
bool equalOUint64G(baset *p1, uint64_t p2)
Definition: libsheepyObject.c:3977
walkDirDirSmallStringO
smallArrayt * walkDirDirSmallStringO(smallStringt *dirPath)
Definition: libsheepyObject.c:1578
equalOUint32G
bool equalOUint32G(baset *p1, uint32_t p2)
Definition: libsheepyObject.c:3972
notEqualInt32OG
bool notEqualInt32OG(int32_t p1 UNUSED, void *p2 UNUSED)
Definition: libsheepyObject.c:5076
icEqCharChar
bool icEqCharChar(char c, char value)
ignore case equality functions
Definition: libsheepyObject.c:5122
terminateBaseFt
void(* terminateBaseFt)(baset **self)
free buffers and obj itself
Definition: libsheepyObject.h:9560
getModificationTimeJO
time_t getModificationTimeJO(smallJsont *path)
get modification time for path
Definition: libsheepyObject.c:1895
writeTextSmallJsonNotSupported
int writeTextSmallJsonNotSupported(char **self UNUSED, smallJsont *path UNUSED)
Definition: libsheepyObject.c:2633
listHasCharCG
bool listHasCharCG(const char **list, char c)
Definition: libsheepyObject.c:3538
a
smallArrayt * a
Definition: libsheepyObjectTest.c:2316
value
in value value
Definition: libsheepyObjectTest.c:1363
readLineO
smallStringt * readLineO(FILE *fp)
Definition: libsheepyObject.c:3392
icEqualArraySmallJsonG
bool icEqualArraySmallJsonG(char **p1, smallJsont *p2)
Definition: libsheepyObject.c:5252
listEqCG
bool listEqCG(char **list1, const char **list2)
Definition: libsheepyObject.c:3483
icEqualOSmallStringG
bool icEqualOSmallStringG(baset *p1, smallStringt *p2)
Definition: libsheepyObject.c:5397
toStringUintPGF
char * toStringUintPGF(uint64_t *object)
Definition: libsheepyObject.c:1217
notEqualCharG
bool notEqualCharG(char c UNUSED, void *value UNUSED)
return false, used in eqG when object types don&#39;t match
Definition: libsheepyObject.c:5041
equalModificationTimesOS
bool equalModificationTimesOS(smallStringt *path1, const char *path2)
Definition: libsheepyObject.c:2071
notEqualCCOG
bool notEqualCCOG(const char *a UNUSED, void *b UNUSED)
Definition: libsheepyObject.c:5056
copySmallJsonO
int copySmallJsonO(smallJsont *src, smallStringt *dst)
Definition: libsheepyObject.c:2867
icListIndexOfCharCG
ssize_t icListIndexOfCharCG(const char **list, char c)
Definition: libsheepyObject.c:3533
notEqualDoubleOG
bool notEqualDoubleOG(double p1 UNUSED, void *p2 UNUSED)
Definition: libsheepyObject.c:5066
readFileToNewG
void * readFileToNewG(void *none UNUSED, const char *filePath)
call readFileToS (for readFileG)
Definition: libsheepyObject.c:2567
equalInt32ChaG
bool equalInt32ChaG(int32_t p1, char p2)
Definition: libsheepyObject.c:4555
equalChaBoolG
bool equalChaBoolG(char c UNUSED, bool value UNUSED)
Definition: libsheepyObject.c:3590
toStringUintGF
char * toStringUintGF(uint64_t object)
Definition: libsheepyObject.c:1211
listIndexOfCG
ssize_t listIndexOfCG(const char **list, const char *string)
Definition: libsheepyObject.c:3518
moveSmallJsonO
int moveSmallJsonO(smallJsont *src, smallStringt *dst)
move files recursively
Definition: libsheepyObject.c:3090
copySSmallJsonO
int copySSmallJsonO(const char *src, smallJsont *dst)
Definition: libsheepyObject.c:2778
baseFunctionst::smash
smashBaseFt smash
Definition: libsheepyObject.h:9590
equalOSmallArrayG
bool equalOSmallArrayG(baset *p1, smallArrayt *p2)
Definition: libsheepyObject.c:3982
equalOSmallIntG
bool equalOSmallIntG(baset *p1, smallIntt *p2)
Definition: libsheepyObject.c:4047
icEqualOSmallArrayG
bool icEqualOSmallArrayG(baset *p1, smallArrayt *p2)
Definition: libsheepyObject.c:5357
equalOSmallDoubleG
bool equalOSmallDoubleG(baset *p1, smallDoublet *p2)
Definition: libsheepyObject.c:4021
equalModificationTimesOJO
bool equalModificationTimesOJO(smallStringt *path1, smallJsont *path2)
Definition: libsheepyObject.c:2027
icEqualOArrayG
bool icEqualOArrayG(baset *p1, char **p2)
Definition: libsheepyObject.c:5328
equalUint32BaseG
bool equalUint32BaseG(uint32_t p1, baset *p2)
Definition: libsheepyObject.c:4737
listFromCArrayG
char ** listFromCArrayG(char **retType UNUSED, const char **array, size_t size)
Definition: libsheepyObject.c:3438
listFromArrayG
char ** listFromArrayG(char **retType UNUSED, char **array, size_t size)
call listFromArrayS for fromArrayG
Definition: libsheepyObject.c:3433
putsUint32PGF
void putsUint32PGF(uint32_t *object)
Definition: libsheepyObject.c:938
putsDoublePGF
void putsDoublePGF(double *object)
Definition: libsheepyObject.c:843
equalInt32SmallBytesG
bool equalInt32SmallBytesG(int32_t p1, smallBytest *p2)
Definition: libsheepyObject.c:4640
equalInt32Int64G
bool equalInt32Int64G(int32_t p1, int64_t p2)
Definition: libsheepyObject.c:4611
equalUint32Uint64G
bool equalUint32Uint64G(uint32_t p1, uint64_t p2)
Definition: libsheepyObject.c:4788
randomSO
smallStringt * randomSO(uint64_t length)
Definition: libsheepyObject.c:3265
toSmallt
smallt * toSmallt(baset *obj)
convert baset object to smallt
Definition: libsheepyObject.c:5426
equalUint64Uint32G
bool equalUint64Uint32G(uint64_t p1, uint32_t p2)
Definition: libsheepyObject.c:4945
rtSmallJsont
smallJsont * rtSmallJsont
Definition: libsheepyObject.c:5746
equalOSmallJsonG
bool equalOSmallJsonG(baset *p1, smallJsont *p2)
Definition: libsheepyObject.c:4060
rtSmallDoublet
smallDoublet * rtSmallDoublet
Definition: libsheepyObject.c:5744
UNUSED
#define UNUSED
Definition: libsheepy.h:8195
doubleToSG
char * doubleToSG(char *retType UNUSED, double n)
call doubleToS for doubleToG
Definition: libsheepyObject.c:3418
toStringSmallJsonGF
char * toStringSmallJsonGF(smallJsont *object)
Definition: libsheepyObject.c:1381
equalCharPSmallJsonG
bool equalCharPSmallJsonG(const char *s, smallJsont *value)
Definition: libsheepyObject.c:3761
equalBoolFG
bool equalBoolFG(bool p1, bool p2)
Definition: libsheepyObject.c:4130
moveSSmallJsonO
int moveSSmallJsonO(const char *src, smallJsont *dst)
Definition: libsheepyObject.c:3210
icEqualChaOG
bool icEqualChaOG(char c, baset *value)
Definition: libsheepyObject.c:5127
equalDoubleSmallBoolG
bool equalDoubleSmallBoolG(double p1, smallBoolt *p2)
Definition: libsheepyObject.c:4307
putsSmallStringGF
void putsSmallStringGF(smallStringt *object)
Definition: libsheepyObject.c:1060
execSmallStringO
int execSmallStringO(smallStringt *cmd, smallArrayt *out, smallArrayt *err)
Definition: libsheepyObject.c:1460
equalUint64SmallDoubleG
bool equalUint64SmallDoubleG(uint64_t p1, smallDoublet *p2)
Definition: libsheepyObject.c:4993
equalChaOG
bool equalChaOG(char c, baset *value)
Definition: libsheepyObject.c:3584
isLinkO
bool isLinkO(smallStringt *path)
Definition: libsheepyObject.c:2452
putsInt32PGF
void putsInt32PGF(int32_t *object)
Definition: libsheepyObject.c:890
putsIntGF
void putsIntGF(int64_t object)
Definition: libsheepyObject.c:857
libsheepySmall.h
*Tiny functions dont check the parameter validity *ShortTiny do the shortest possible operations ...
equalUint32SmallBytesG
bool equalUint32SmallBytesG(uint32_t p1, smallBytest *p2)
Definition: libsheepyObject.c:4802
walkDirDirO
smallArrayt * walkDirDirO(const char *dirPath)
list all directories in a directory recursively and sort the list
Definition: libsheepyObject.c:1545
writeTextCG
bool writeTextCG(const char **list, const char *filePath)
Definition: libsheepyObject.c:2693
equalChaSmallBytesG
bool equalChaSmallBytesG(char c, smallBytest *value)
Definition: libsheepyObject.c:3625
toStringUndefinedGF
char * toStringUndefinedGF(undefinedt *object)
Definition: libsheepyObject.c:1103
equalDoubleChaG
bool equalDoubleChaG(double p1, char p2)
Definition: libsheepyObject.c:4231
equalDoubleSmallBytesG
bool equalDoubleSmallBytesG(double p1, smallBytest *p2)
Definition: libsheepyObject.c:4316
equalDoubleUint32G
bool equalDoubleUint32G(double p1, uint32_t p2)
Definition: libsheepyObject.c:4297
icListHasCG
bool icListHasCG(const char **list, const char *string)
Definition: libsheepyObject.c:3548
randomSmallJsonO
smallJsont * randomSmallJsonO(uint64_t length)
random string
Definition: libsheepyObject.c:3249
chDirO
int chDirO(smallStringt *path)
Definition: libsheepyObject.c:2389
equalInt32DoubleG
bool equalInt32DoubleG(int32_t p1, double p2)
Definition: libsheepyObject.c:4606
getProgPathO
smallStringt * getProgPathO(void)
Definition: libsheepyObject.c:659
equalInt32BaseG
bool equalInt32BaseG(int32_t p1, baset *p2)
Definition: libsheepyObject.c:4575
putsIntPGF
void putsIntPGF(int64_t *object)
Definition: libsheepyObject.c:867
duplicateBaseFt
baset *(* duplicateBaseFt)(baset *self)
create a copy of obj
Definition: libsheepyObject.h:9570
equalDoubleBoolG
bool equalDoubleBoolG(double p1, bool p2)
Definition: libsheepyObject.c:4277
chDirJO
int chDirJO(smallJsont *path)
change directory
Definition: libsheepyObject.c:2374
equalBoolSmallBoolG
bool equalBoolSmallBoolG(bool p1, smallBoolt *p2)
Definition: libsheepyObject.c:4160
equalUint64SmallJsonG
bool equalUint64SmallJsonG(uint64_t p1, smallJsont *p2)
Definition: libsheepyObject.c:5011
rtSmallDictt
smallDictt * rtSmallDictt
Definition: libsheepyObject.c:5743
cpuCount
int cpuCount(void)
return number of online CPUs, also number of threads in the thread pool
Definition: libsheepyObject.c:5597
formatO
smallStringt * formatO(const char *fmt,...)
format string allocate and format string using asprintf
Definition: libsheepyObject.c:1395
notEqualUint64OG
bool notEqualUint64OG(uint64_t p1 UNUSED, void *p2 UNUSED)
Definition: libsheepyObject.c:5086
initLibsheepyObject
void initLibsheepyObject(void)
called from initLibsheepy in libsheepy.c start the thread pool
Definition: libsheepyObject.c:5669
equalChaSmallIntG
bool equalChaSmallIntG(char c, smallIntt *value)
Definition: libsheepyObject.c:3646
base
base class
Definition: libsheepyObject.h:9597
equalUint32ChaG
bool equalUint32ChaG(uint32_t p1, char p2)
Definition: libsheepyObject.c:4717
putsSmallBoolGF
void putsSmallBoolGF(smallBoolt *object)
Definition: libsheepyObject.c:1008
equalCharInt64G
bool equalCharInt64G(const char *s, int64_t value)
Definition: libsheepyObject.c:3709
listEqCCG
bool listEqCCG(const char **list1, const char **list2)
Definition: libsheepyObject.c:3493
notEqualOCharG
bool notEqualOCharG(void *a UNUSED, char c UNUSED)
Definition: libsheepyObject.c:5046
icEqualCharPSmallStringG
bool icEqualCharPSmallStringG(const char *s, smallStringt *value)
Definition: libsheepyObject.c:5183
moveOSmallJson
int moveOSmallJson(smallStringt *src, smallJsont *dst)
Definition: libsheepyObject.c:3183
freeManyOF
void freeManyOF(void *paramType,...)
free many buffers in baset objects
Definition: libsheepyObject.c:580
renameOS
int renameOS(smallStringt *src, const char *dst)
Definition: libsheepyObject.c:3082
finishManyOF
void finishManyOF(void *paramType,...)
finish many baset objects
Definition: libsheepyObject.c:631
icEqualOOG
bool icEqualOOG(baset *p1, baset *p2)
Definition: libsheepyObject.c:5338
command
#define command(cmd)
Definition: libsheepy.h:3151
putsSmallContainerGF
void putsSmallContainerGF(smallContainert *object)
Definition: libsheepyObject.c:1081
duplicateBaseG
baset * duplicateBaseG(baset *self)
Definition: libsheepyObject.c:575
equalUint64Int32G
bool equalUint64Int32G(uint64_t p1, int32_t p2)
Definition: libsheepyObject.c:4940
renameSSmallJsonO
int renameSSmallJsonO(const char *src, smallJsont *dst)
Definition: libsheepyObject.c:3051
equalInt64BoolG
bool equalInt64BoolG(int64_t p1, bool p2)
Definition: libsheepyObject.c:4439
icEqualCArrayOG
bool icEqualCArrayOG(const char **p1, baset *p2)
Definition: libsheepyObject.c:5222
rtSmallStringt
smallStringt * rtSmallStringt
Definition: libsheepyObject.c:5747
equalInt64SmallDoubleG
bool equalInt64SmallDoubleG(int64_t p1, smallDoublet *p2)
Definition: libsheepyObject.c:4507
walkDirAllO
smallArrayt * walkDirAllO(const char *dirPath)
list all files and directories in a directory recursively the directories are listed ...
Definition: libsheepyObject.c:1754
smashBaseFt
void(* smashBaseFt)(baset **self)
free obj itself and keep buffers inside
Definition: libsheepyObject.h:9575
shDirnameJO
smallJsont * shDirnameJO(smallJsont *path)
sheepy dirname
Definition: libsheepyObject.c:2105
notEqualDoubleG
bool notEqualDoubleG(void *p1 UNUSED, double p2 UNUSED)
Definition: libsheepyObject.c:5096
notEqualOUint64G
bool notEqualOUint64G(void *p1 UNUSED, uint64_t p2 UNUSED)
Definition: libsheepyObject.c:5116
smashManyOF
void smashManyOF(void *paramType,...)
smash many baset objects
Definition: libsheepyObject.c:613
equalInt32SmallJsonG
bool equalInt32SmallJsonG(int32_t p1, smallJsont *p2)
Definition: libsheepyObject.c:4687
equalInt64Uint64G
bool equalInt64Uint64G(int64_t p1, uint64_t p2)
Definition: libsheepyObject.c:4464
systemNFreeJOF
int systemNFreeJOF(smallJsont *command, int line, const char *thisFunc, const char *thisFileName)
Definition: libsheepyObject.c:703
rtU32P
uint32_t * rtU32P
Definition: libsheepyObject.c:5736
equalBoolCharG
bool equalBoolCharG(bool p1, const char *p2)
Definition: libsheepyObject.c:4095
writeTextStreamG
bool writeTextStreamG(char **list, FILE *fp)
Definition: libsheepyObject.c:2688
toStringInt32PGF
char * toStringInt32PGF(int32_t *object)
Definition: libsheepyObject.c:1190
iListGetCG
const char * iListGetCG(const char **list, int retType UNUSED, int64_t index)
Definition: libsheepyObject.c:3463
shDirnameO
smallStringt * shDirnameO(smallStringt *path)
Definition: libsheepyObject.c:2125
putsSmallIntGF
void putsSmallIntGF(smallIntt *object)
Definition: libsheepyObject.c:1047
equalInt64Uint32G
bool equalInt64Uint32G(int64_t p1, uint32_t p2)
Definition: libsheepyObject.c:4459
equalInt64SmallIntG
bool equalInt64SmallIntG(int64_t p1, smallIntt *p2)
Definition: libsheepyObject.c:4516
readO
smallStringt * readO(void)
Definition: libsheepyObject.c:3330
rtF32
float rtF32
Definition: libsheepyObject.c:5726
equalBoolSmallBytesG
bool equalBoolSmallBytesG(bool p1, smallBytest *p2)
Definition: libsheepyObject.c:4169
rmAllO
int rmAllO(smallStringt *path)
Definition: libsheepyObject.c:2758
rtInt64_t
int64_t rtInt64_t
Definition: libsheepyObject.c:5718
toStringUint32PGF
char * toStringUint32PGF(uint32_t *object)
Definition: libsheepyObject.c:1231
equalUint32BoolG
bool equalUint32BoolG(uint32_t p1, bool p2)
Definition: libsheepyObject.c:4763
putsVoidGF
void putsVoidGF(void *object)
Definition: libsheepyObject.c:1073
toStringUint16PGF
char * toStringUint16PGF(uint16_t *object)
Definition: libsheepyObject.c:1244
readToFileSmallStringNotSupported
void readToFileSmallStringNotSupported(void *self UNUSED, smallStringt *path UNUSED)
Definition: libsheepyObject.c:2616
icListEqCG
bool icListEqCG(char **list1, const char **list2)
Definition: libsheepyObject.c:3498
equalInt64BaseG
bool equalInt64BaseG(int64_t p1, baset *p2)
Definition: libsheepyObject.c:4413
toStringSGF
char * toStringSGF(const char *object)
Definition: libsheepyObject.c:1274
equalChaDoubleG
bool equalChaDoubleG(char c, double value)
Definition: libsheepyObject.c:3595
toStringFloatGF
char * toStringFloatGF(float object)
Definition: libsheepyObject.c:1134
equalChaSmallJsonG
bool equalChaSmallJsonG(char c, smallJsont *value)
Definition: libsheepyObject.c:3656
readDirSmallStringO
smallArrayt * readDirSmallStringO(smallStringt *dirPath)
Definition: libsheepyObject.c:1679
renameSmallJsonO
int renameSmallJsonO(smallJsont *src, smallStringt *dst)
rename file
Definition: libsheepyObject.c:2931
equalUint64CharG
bool equalUint64CharG(uint64_t p1, const char *p2)
Definition: libsheepyObject.c:4884
joinCharCG
char * joinCharCG(const char **list, char delim)
Definition: libsheepyObject.c:3563
walkDirAllSmallStringO
smallArrayt * walkDirAllSmallStringO(smallStringt *dirPath)
Definition: libsheepyObject.c:1787
moveSmallJsonOS
int moveSmallJsonOS(smallJsont *src, const char *dst)
Definition: libsheepyObject.c:3150
randomAlphaNumSmallJsonO
smallJsont * randomAlphaNumSmallJsonO(uint64_t length)
random alpha numerical string
Definition: libsheepyObject.c:3281
putsBoolPGF
void putsBoolPGF(bool *object)
Definition: libsheepyObject.c:819
renameOSmallJson
int renameOSmallJson(smallStringt *src, smallJsont *dst)
Definition: libsheepyObject.c:3024
equalUint32Int64G
bool equalUint32Int64G(uint32_t p1, int64_t p2)
Definition: libsheepyObject.c:4773
listGetCG
char * listGetCG(const char **list, int retType UNUSED, int64_t index)
Definition: libsheepyObject.c:3453
readDirO
smallArrayt * readDirO(const char *dirPath)
list files in a directory and sort the list
Definition: libsheepyObject.c:1620
equalUint32DoubleG
bool equalUint32DoubleG(uint32_t p1, double p2)
Definition: libsheepyObject.c:4768
Generated on Thu Jul 13 2023 14:34:29 for libsheepy by   doxygen 1.8.13