libsheepy

C lib for handling text files, strings and json like data structure with an object oriented system
git clone https://spartatek.se/git/libsheepy.git
Log | Files | Refs | README | LICENSE
commit 3b512870c359ddc83e5495d7a2a618b3f4ae8ef8
parent 666eb836ea7833c15fb8477a27fa59e3796c41a9
Author: Remy Noulin <loader2x@gmail.com>
Date:   Tue, 25 May 2021 08:50:55 +0200

remove intmax_t and use i64 instead to make sure larger ints are not used

- change AT macro to use debug log
- make sure forEachSDict, enumerateSDict, forEachSArray and enumerateSArray macros
  don't make out of bound accesses. They were discarded but it can generate a
  page fault when the out of bound address is in an unmapped page

This is libsheepy 2.2.5.1, which is like previous version with bug
fixes.
Previous versions are now unsupported.

release/json/libsheepyCSmallArray.h        |  636 +++++-----
release/json/libsheepyCSmallArrayCuTest.c  |    2 +-
release/json/libsheepyCSmallArrayTest.c    |    2 +-
release/json/libsheepyCSmallArrayTestMem.c |    2 +-
release/json/libsheepyCSmallBool.h         |    4 +-
release/json/libsheepyCSmallBytes.h        |    4 +-
release/json/libsheepyCSmallContainer.h    |    2 +-
release/json/libsheepyCSmallDouble.h       |    4 +-
release/json/libsheepyCSmallInt.h          |   16 +-
release/json/libsheepyCSmallJson.h         |  684 +++++------
release/json/libsheepyCSmallJsonCuTest.c   |    2 +-
release/json/libsheepyCSmallJsonTest.c     |    2 +-
release/json/libsheepyCSmallJsonTestMem.c  |    2 +-
release/json/libsheepyCSmallString.h       |   96 +-
release/libsheepy.c                        |  751 ++++++------
release/libsheepy.h                        |  228 ++--
release/libsheepyObject.h                  |   12 +-
release/libsheepySmall.h                   |    8 +-
src/json/libsheepyCSmallArray.c            | 1682 ++++++++++++-------------
src/json/libsheepyCSmallArray.h            |  636 +++++-----
src/json/libsheepyCSmallBool.c             |    8 +-
src/json/libsheepyCSmallBool.h             |    4 +-
src/json/libsheepyCSmallBytes.c            |   12 +-
src/json/libsheepyCSmallBytes.h            |    4 +-
src/json/libsheepyCSmallContainer.c        |    5 +-
src/json/libsheepyCSmallContainer.h        |    2 +-
src/json/libsheepyCSmallDouble.c           |    8 +-
src/json/libsheepyCSmallDouble.h           |    4 +-
src/json/libsheepyCSmallInt.c              |   32 +-
src/json/libsheepyCSmallInt.h              |   16 +-
src/json/libsheepyCSmallJson.c             | 1841 ++++++++++++++--------------
src/json/libsheepyCSmallJson.h             |  684 +++++------
src/json/libsheepyCSmallString.c           |  257 ++--
src/json/libsheepyCSmallString.h           |   96 +-
src/json/libsheepyObject.c                 |   24 +-
src/libsheepy.c                            |  751 ++++++------
src/libsheepy.h                            |  230 ++--
src/libsheepyCuTest.c                      |    8 +-
src/libsheepyGenericsTest.c                |  256 ++--
src/libsheepyObject.h                      |   12 +-
src/libsheepySmall.h                       |    8 +-
src/libsheepyTest.c                        |    8 +-
42 files changed, 4521 insertions(+), 4524 deletions(-)

Diffstat:

Mrelease/json/libsheepyCSmallArray.h | 636++++++++++++++++++++++++++++++++++++++++----------------------------------------


Mrelease/json/libsheepyCSmallArrayCuTest.c | 2+-


Mrelease/json/libsheepyCSmallArrayTest.c | 2+-


Mrelease/json/libsheepyCSmallArrayTestMem.c | 2+-


Mrelease/json/libsheepyCSmallBool.h | 4++--


Mrelease/json/libsheepyCSmallBytes.h | 4++--


Mrelease/json/libsheepyCSmallContainer.h | 2+-


Mrelease/json/libsheepyCSmallDouble.h | 4++--


Mrelease/json/libsheepyCSmallInt.h | 16++++++++--------


Mrelease/json/libsheepyCSmallJson.h | 684++++++++++++++++++++++++++++++++++++++++----------------------------------------


Mrelease/json/libsheepyCSmallJsonCuTest.c | 2+-


Mrelease/json/libsheepyCSmallJsonTest.c | 2+-


Mrelease/json/libsheepyCSmallJsonTestMem.c | 2+-


Mrelease/json/libsheepyCSmallString.h | 96++++++++++++++++++++++++++++++++++++++++----------------------------------------


Mrelease/libsheepy.c | 751+++++++++++++++++++++++++++++++++++++++----------------------------------------


Mrelease/libsheepy.h | 228++++++++++++++++++++++++++++++++++++++++----------------------------------------


Mrelease/libsheepyObject.h | 12++++++------


Mrelease/libsheepySmall.h | 8++++----


Msrc/json/libsheepyCSmallArray.c | 1682++++++++++++++++++++++++++++++++++++++++----------------------------------------


Msrc/json/libsheepyCSmallArray.h | 636++++++++++++++++++++++++++++++++++++++++----------------------------------------


Msrc/json/libsheepyCSmallBool.c | 8++++----


Msrc/json/libsheepyCSmallBool.h | 4++--


Msrc/json/libsheepyCSmallBytes.c | 12++++++------


Msrc/json/libsheepyCSmallBytes.h | 4++--


Msrc/json/libsheepyCSmallContainer.c | 5+++--


Msrc/json/libsheepyCSmallContainer.h | 2+-


Msrc/json/libsheepyCSmallDouble.c | 8++++----


Msrc/json/libsheepyCSmallDouble.h | 4++--


Msrc/json/libsheepyCSmallInt.c | 32++++++++++++++++----------------


Msrc/json/libsheepyCSmallInt.h | 16++++++++--------


Msrc/json/libsheepyCSmallJson.c | 1841+++++++++++++++++++++++++++++++++++++++----------------------------------------


Msrc/json/libsheepyCSmallJson.h | 684++++++++++++++++++++++++++++++++++++++++----------------------------------------


Msrc/json/libsheepyCSmallString.c | 257+++++++++++++++++++++++++++++++++++++++----------------------------------------


Msrc/json/libsheepyCSmallString.h | 96++++++++++++++++++++++++++++++++++++++++----------------------------------------


Msrc/json/libsheepyObject.c | 24++++++++++++------------


Msrc/libsheepy.c | 751+++++++++++++++++++++++++++++++++++++++----------------------------------------


Msrc/libsheepy.h | 230++++++++++++++++++++++++++++++++++++++++----------------------------------------


Msrc/libsheepyCuTest.c | 8++++----


Msrc/libsheepyGenericsTest.c | 256++++++++++++++++++++++++++++++++++++++++----------------------------------------


Msrc/libsheepyObject.h | 12++++++------


Msrc/libsheepySmall.h | 8++++----


Msrc/libsheepyTest.c | 8++++----


42 files changed, 4521 insertions(+), 4524 deletions(-)

diff --git a/release/json/libsheepyCSmallArray.h b/release/json/libsheepyCSmallArray.h
@@ -444,7 +444,7 @@ typedef smallArrayt*          (*addSmallArrayFt)       (smallArrayt *self, small
  *   0  success
  *   -1 error
  */
-typedef smallArrayt*          (*sliceSmallArrayFt)     (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt*          (*sliceSmallArrayFt)     (smallArrayt *self, int64_t start, int64_t end);
 
 /**
  * Crop elements from start to end
@@ -466,7 +466,7 @@ typedef smallArrayt*          (*sliceSmallArrayFt)     (smallArrayt *self, intma
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallArrayt*     (*cropSmallArrayFt)                   (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt*     (*cropSmallArrayFt)                   (smallArrayt *self, int64_t start, int64_t end);
 
 
 /**
@@ -482,25 +482,25 @@ typedef smallArrayt*     (*cropSmallArrayFt)                   (smallArrayt *sel
  *   unchanged when list is empty
  *   NULL error
  */
-typedef baset*           (*cropElemSmallArrayFt)               (smallArrayt *self, intmax_t index);
-typedef undefinedt*      (*cropElemUndefinedSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef bool             (*cropElemBoolSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef double           (*cropElemDoubleSmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef int64_t          (*cropElemIntSmallArrayFt)            (smallArrayt *self, intmax_t index);
-typedef int32_t          (*cropElemInt32SmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef uint64_t         (*cropElemUintSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef uint32_t         (*cropElemUint32SmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef char*            (*cropElemSSmallArrayFt)              (smallArrayt *self, intmax_t index);
-typedef smallDictt*      (*cropElemDictSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef smallArrayt*     (*cropElemArraySmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallBoolt*      (*cropElemSmallBoolSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef smallBytest*     (*cropElemSmallBytesSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallDoublet*    (*cropElemSmallDoubleSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef smallIntt*       (*cropElemSmallIntSmallArrayFt)       (smallArrayt *self, intmax_t index);
-typedef smallJsont*      (*cropElemSmallJsonSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef smallStringt*    (*cropElemSmallStringSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef void*            (*cropElemVoidSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef smallContainert* (*cropElemSmallContainerSmallArrayFt) (smallArrayt *self, intmax_t index);
+typedef baset*           (*cropElemSmallArrayFt)               (smallArrayt *self, int64_t index);
+typedef undefinedt*      (*cropElemUndefinedSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef bool             (*cropElemBoolSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef double           (*cropElemDoubleSmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef int64_t          (*cropElemIntSmallArrayFt)            (smallArrayt *self, int64_t index);
+typedef int32_t          (*cropElemInt32SmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef uint64_t         (*cropElemUintSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef uint32_t         (*cropElemUint32SmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef char*            (*cropElemSSmallArrayFt)              (smallArrayt *self, int64_t index);
+typedef smallDictt*      (*cropElemDictSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef smallArrayt*     (*cropElemArraySmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallBoolt*      (*cropElemSmallBoolSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef smallBytest*     (*cropElemSmallBytesSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallDoublet*    (*cropElemSmallDoubleSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef smallIntt*       (*cropElemSmallIntSmallArrayFt)       (smallArrayt *self, int64_t index);
+typedef smallJsont*      (*cropElemSmallJsonSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef smallStringt*    (*cropElemSmallStringSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef void*            (*cropElemVoidSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef smallContainert* (*cropElemSmallContainerSmallArrayFt) (smallArrayt *self, int64_t index);
 
 /**
  * keep elements from start and end in list, free the other elements
@@ -517,7 +517,7 @@ typedef smallContainert* (*cropElemSmallContainerSmallArrayFt) (smallArrayt *sel
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallArrayt* (*copySmallArrayFt)          (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt* (*copySmallArrayFt)          (smallArrayt *self, int64_t start, int64_t end);
 
 /**
  * insert array in self at index
@@ -535,10 +535,10 @@ typedef smallArrayt* (*copySmallArrayFt)          (smallArrayt *self, intmax_t s
  *   unchanged array when array is NULL or invalid index
  *   NULL error
  */
-typedef smallArrayt*          (*insertSmallArrayFt)               (smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-typedef smallArrayt*          (*insertSmallJsonSmallArrayFt)      (smallArrayt *self, intmax_t index, smallJsont *toInsert);
-typedef smallArrayt*          (*insertNSmashSmallArrayFt)         (smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-typedef smallArrayt*          (*insertNSmashSmallJsonSmallArrayFt)(smallArrayt *self, intmax_t index, smallJsont *toInsert);
+typedef smallArrayt*          (*insertSmallArrayFt)               (smallArrayt *self, int64_t index, smallArrayt *toInsert);
+typedef smallArrayt*          (*insertSmallJsonSmallArrayFt)      (smallArrayt *self, int64_t index, smallJsont *toInsert);
+typedef smallArrayt*          (*insertNSmashSmallArrayFt)         (smallArrayt *self, int64_t index, smallArrayt *toInsert);
+typedef smallArrayt*          (*insertNSmashSmallJsonSmallArrayFt)(smallArrayt *self, int64_t index, smallJsont *toInsert);
 
 /**
  * inject an element in self at index
@@ -555,37 +555,37 @@ typedef smallArrayt*          (*insertNSmashSmallJsonSmallArrayFt)(smallArrayt *
  *   unchanged array when array is NULL or invalid index
  *   NULL error
  */
-typedef smallArrayt* (*injectSmallArrayFt)     (smallArrayt *self, intmax_t index, baset *toInject);
-typedef smallArrayt* (*injectUndefinedSmallArrayFt)(smallArrayt *self, intmax_t index);
-typedef smallArrayt* (*injectBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, bool toInject);
-typedef smallArrayt* (*injectDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, double toInject);
-typedef smallArrayt* (*injectIntSmallArrayFt)      (smallArrayt *self, intmax_t index, int64_t toInject);
-typedef smallArrayt* (*injectSSmallArrayFt)        (smallArrayt *self, intmax_t index, const char *toInject);
-typedef smallArrayt* (*injectCharSmallArrayFt)     (smallArrayt *self, intmax_t index, char c);
-typedef smallArrayt* (*injectDictSmallArrayFt)     (smallArrayt *self, intmax_t index, smallDictt *toInject);
-typedef smallArrayt* (*injectArraySmallArrayFt)    (smallArrayt *self, intmax_t index, smallArrayt *toInject);
-typedef smallArrayt* (*injectArraycSmallArrayFt)   (smallArrayt *self, intmax_t index, char **toInject);
-typedef smallArrayt* (*injectSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, smallBoolt *toInject);
-typedef smallArrayt* (*injectSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index, smallBytest *toInject);
-typedef smallArrayt* (*injectSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, smallDoublet *toInject);
-typedef smallArrayt* (*injectSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index, smallIntt *toInject);
-typedef smallArrayt* (*injectSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index, smallJsont *toInject);
-typedef smallArrayt* (*injectSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index, smallStringt *toInject);
-typedef smallArrayt* (*injectSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index, smallContainert *toInject);
-
-typedef smallArrayt* (*injectNFreeSmallArrayFt)         (smallArrayt *self, intmax_t index, baset *toInject);
-typedef smallArrayt* (*injectNFreeUndefinedSmallArrayFt)(smallArrayt *self, intmax_t index, undefinedt *undefined);
-typedef smallArrayt* (*injectNFreeSSmallArrayFt)        (smallArrayt *self, intmax_t index, char *toInject);
-typedef smallArrayt* (*injectNFreeDictSmallArrayFt)     (smallArrayt *self, intmax_t index, smallDictt *toInject);
-typedef smallArrayt* (*injectNFreeArraySmallArrayFt)    (smallArrayt *self, intmax_t index, smallArrayt *toInject);
-typedef smallArrayt* (*injectNFreeArraycSmallArrayFt)   (smallArrayt *self, intmax_t index, char **toInject);
-typedef smallArrayt* (*injectNFreeSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, smallBoolt *toInject);
-typedef smallArrayt* (*injectNFreeSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index, smallBytest *toInject);
-typedef smallArrayt* (*injectNFreeSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, smallDoublet *toInject);
-typedef smallArrayt* (*injectNFreeSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index, smallIntt *toInject);
-typedef smallArrayt* (*injectNFreeSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index, smallJsont *toInject);
-typedef smallArrayt* (*injectNFreeSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index, smallStringt *toInject);
-typedef smallArrayt* (*injectNFreeSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index, smallContainert *toInject);
+typedef smallArrayt* (*injectSmallArrayFt)     (smallArrayt *self, int64_t index, baset *toInject);
+typedef smallArrayt* (*injectUndefinedSmallArrayFt)(smallArrayt *self, int64_t index);
+typedef smallArrayt* (*injectBoolSmallArrayFt)     (smallArrayt *self, int64_t index, bool toInject);
+typedef smallArrayt* (*injectDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, double toInject);
+typedef smallArrayt* (*injectIntSmallArrayFt)      (smallArrayt *self, int64_t index, int64_t toInject);
+typedef smallArrayt* (*injectSSmallArrayFt)        (smallArrayt *self, int64_t index, const char *toInject);
+typedef smallArrayt* (*injectCharSmallArrayFt)     (smallArrayt *self, int64_t index, char c);
+typedef smallArrayt* (*injectDictSmallArrayFt)     (smallArrayt *self, int64_t index, smallDictt *toInject);
+typedef smallArrayt* (*injectArraySmallArrayFt)    (smallArrayt *self, int64_t index, smallArrayt *toInject);
+typedef smallArrayt* (*injectArraycSmallArrayFt)   (smallArrayt *self, int64_t index, char **toInject);
+typedef smallArrayt* (*injectSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index, smallBoolt *toInject);
+typedef smallArrayt* (*injectSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index, smallBytest *toInject);
+typedef smallArrayt* (*injectSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, smallDoublet *toInject);
+typedef smallArrayt* (*injectSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index, smallIntt *toInject);
+typedef smallArrayt* (*injectSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index, smallJsont *toInject);
+typedef smallArrayt* (*injectSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index, smallStringt *toInject);
+typedef smallArrayt* (*injectSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *toInject);
+
+typedef smallArrayt* (*injectNFreeSmallArrayFt)         (smallArrayt *self, int64_t index, baset *toInject);
+typedef smallArrayt* (*injectNFreeUndefinedSmallArrayFt)(smallArrayt *self, int64_t index, undefinedt *undefined);
+typedef smallArrayt* (*injectNFreeSSmallArrayFt)        (smallArrayt *self, int64_t index, char *toInject);
+typedef smallArrayt* (*injectNFreeDictSmallArrayFt)     (smallArrayt *self, int64_t index, smallDictt *toInject);
+typedef smallArrayt* (*injectNFreeArraySmallArrayFt)    (smallArrayt *self, int64_t index, smallArrayt *toInject);
+typedef smallArrayt* (*injectNFreeArraycSmallArrayFt)   (smallArrayt *self, int64_t index, char **toInject);
+typedef smallArrayt* (*injectNFreeSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index, smallBoolt *toInject);
+typedef smallArrayt* (*injectNFreeSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index, smallBytest *toInject);
+typedef smallArrayt* (*injectNFreeSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, smallDoublet *toInject);
+typedef smallArrayt* (*injectNFreeSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index, smallIntt *toInject);
+typedef smallArrayt* (*injectNFreeSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index, smallJsont *toInject);
+typedef smallArrayt* (*injectNFreeSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index, smallStringt *toInject);
+typedef smallArrayt* (*injectNFreeSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *toInject);
 
 /**
  * remove (free) elements from start and end in self
@@ -602,7 +602,7 @@ typedef smallArrayt* (*injectNFreeSmallContainerSmallArrayFt)(smallArrayt *self,
  *   0  success
  *   -1 error
  */
-typedef smallArrayt*          (*delSmallArrayFt)       (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt*          (*delSmallArrayFt)       (smallArrayt *self, int64_t start, int64_t end);
 
 /**
  * delete element
@@ -620,7 +620,7 @@ typedef smallArrayt*          (*delSmallArrayFt)       (smallArrayt *self, intma
  * To dispose a and be able to free all objects, the element at index 0 must be freed with delElem
  * The sObject at index 1 and in s are identical, so the element 1 is freed when s is freed
  */
-typedef smallArrayt*          (*delElemSmallArrayFt)   (smallArrayt *self, intmax_t index);
+typedef smallArrayt*          (*delElemSmallArrayFt)   (smallArrayt *self, int64_t index);
 
 /**
  * remove without freeing elements from start and end in self
@@ -637,7 +637,7 @@ typedef smallArrayt*          (*delElemSmallArrayFt)   (smallArrayt *self, intma
  *   0  success
  *   -1 error
  */
-typedef smallArrayt*          (*removeSmallArrayFt)       (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt*          (*removeSmallArrayFt)       (smallArrayt *self, int64_t start, int64_t end);
 
 /**
  * remove without freeing element
@@ -656,7 +656,7 @@ typedef smallArrayt*          (*removeSmallArrayFt)       (smallArrayt *self, in
  * // to do so, it uses removeElemG since S will free the sString object
  * removeElemG(a, 0);
  */
-typedef smallArrayt*          (*removeElemSmallArrayFt)   (smallArrayt *self, intmax_t index);
+typedef smallArrayt*          (*removeElemSmallArrayFt)   (smallArrayt *self, int64_t index);
 
 /**
  * sort self in alphabetic order
@@ -751,31 +751,31 @@ typedef smallArrayt*          (*trimSmallArrayFt)      (smallArrayt *self);
  *   pointer to object
  *   NULL when array is NULL or index is not set correctly
  */
-typedef baset*           (*getAtSmallArrayFt)              (smallArrayt *self, intmax_t index);
-typedef undefinedt*      (*getAtUndefinedSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef bool             (*getAtBoolSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef bool*            (*getAtBoolPSmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef double           (*getAtDoubleSmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef double*          (*getAtDoublePSmallArrayFt)       (smallArrayt *self, intmax_t index);
-typedef int64_t          (*getAtIntSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef int64_t*         (*getAtIntPSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef int32_t          (*getAtInt32SmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef int32_t*         (*getAtInt32PSmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef uint64_t         (*getAtUintSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef uint64_t*        (*getAtUintPSmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef uint32_t         (*getAtUint32SmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef uint32_t*        (*getAtUint32PSmallArrayFt)       (smallArrayt *self, intmax_t index);
-typedef char*            (*getAtSSmallArrayFt)             (smallArrayt *self, intmax_t index);
-typedef smallDictt*      (*getAtDictSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallArrayt*     (*getAtArraySmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef smallBoolt*      (*getAtSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallBytest*     (*getAtSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef smallDoublet*    (*getAtSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index);
-typedef smallIntt*       (*getAtSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef smallJsont*      (*getAtSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallStringt*    (*getAtSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index);
-typedef void*            (*getAtVoidSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallContainert* (*getAtSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index);
+typedef baset*           (*getAtSmallArrayFt)              (smallArrayt *self, int64_t index);
+typedef undefinedt*      (*getAtUndefinedSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef bool             (*getAtBoolSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef bool*            (*getAtBoolPSmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef double           (*getAtDoubleSmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef double*          (*getAtDoublePSmallArrayFt)       (smallArrayt *self, int64_t index);
+typedef int64_t          (*getAtIntSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef int64_t*         (*getAtIntPSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef int32_t          (*getAtInt32SmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef int32_t*         (*getAtInt32PSmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef uint64_t         (*getAtUintSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef uint64_t*        (*getAtUintPSmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef uint32_t         (*getAtUint32SmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef uint32_t*        (*getAtUint32PSmallArrayFt)       (smallArrayt *self, int64_t index);
+typedef char*            (*getAtSSmallArrayFt)             (smallArrayt *self, int64_t index);
+typedef smallDictt*      (*getAtDictSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallArrayt*     (*getAtArraySmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef smallBoolt*      (*getAtSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallBytest*     (*getAtSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef smallDoublet*    (*getAtSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index);
+typedef smallIntt*       (*getAtSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef smallJsont*      (*getAtSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallStringt*    (*getAtSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index);
+typedef void*            (*getAtVoidSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallContainert* (*getAtSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index);
 
 /**
  * get duplicated object
@@ -787,25 +787,25 @@ typedef smallContainert* (*getAtSmallContainerSmallArrayFt)(smallArrayt *self, i
  *   duplicated object
  *   NULL when array is NULL or index is not set correctly
  */
-typedef baset*           (*getAtNDupSmallArrayFt)              (smallArrayt *self, intmax_t index);
-typedef undefinedt*      (*getAtNDupUndefinedSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef bool             (*getAtNDupBoolSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef double           (*getAtNDupDoubleSmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef int64_t          (*getAtNDupIntSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef int32_t          (*getAtNDupInt32SmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef uint64_t         (*getAtNDupUintSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef uint32_t         (*getAtNDupUint32SmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef char*            (*getAtNDupSSmallArrayFt)             (smallArrayt *self, intmax_t index);
-typedef smallDictt*      (*getAtNDupDictSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallArrayt*     (*getAtNDupArraySmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef smallBoolt*      (*getAtNDupSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallBytest*     (*getAtNDupSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef smallDoublet*    (*getAtNDupSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index);
-typedef smallIntt*       (*getAtNDupSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef smallJsont*       (*getAtNDupSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallStringt*    (*getAtNDupSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index);
-typedef void*            (*getAtNDupVoidSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallContainert* (*getAtNDupSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index);
+typedef baset*           (*getAtNDupSmallArrayFt)              (smallArrayt *self, int64_t index);
+typedef undefinedt*      (*getAtNDupUndefinedSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef bool             (*getAtNDupBoolSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef double           (*getAtNDupDoubleSmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef int64_t          (*getAtNDupIntSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef int32_t          (*getAtNDupInt32SmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef uint64_t         (*getAtNDupUintSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef uint32_t         (*getAtNDupUint32SmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef char*            (*getAtNDupSSmallArrayFt)             (smallArrayt *self, int64_t index);
+typedef smallDictt*      (*getAtNDupDictSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallArrayt*     (*getAtNDupArraySmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef smallBoolt*      (*getAtNDupSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallBytest*     (*getAtNDupSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef smallDoublet*    (*getAtNDupSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index);
+typedef smallIntt*       (*getAtNDupSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef smallJsont*       (*getAtNDupSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallStringt*    (*getAtNDupSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index);
+typedef void*            (*getAtNDupVoidSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallContainert* (*getAtNDupSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index);
 
 /**
  * store object at given index (free already existing elements when baset *value is NULL)
@@ -836,23 +836,23 @@ typedef smallContainert* (*getAtNDupSmallContainerSmallArrayFt)(smallArrayt *sel
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallArrayt*         (*setAtSmallArrayFt)     (smallArrayt *self, intmax_t index, baset *value);
-typedef smallArrayt*         (*setAtUndefinedSmallArrayFt)(smallArrayt *self, intmax_t index);
-typedef smallArrayt*         (*setAtBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, bool value);
-typedef smallArrayt*         (*setAtDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, double value);
-typedef smallArrayt*         (*setAtIntSmallArrayFt)      (smallArrayt *self, intmax_t index, int64_t value);
-typedef smallArrayt*         (*setAtSSmallArrayFt)        (smallArrayt *self, intmax_t index, const char *string);
-typedef smallArrayt*         (*setAtCharSmallArrayFt)     (smallArrayt *self, intmax_t index, char c);
-typedef smallArrayt*         (*setAtDictSmallArrayFt)     (smallArrayt *self, intmax_t index, smallDictt *dict);
-typedef smallArrayt*         (*setAtArraySmallArrayFt)    (smallArrayt *self, intmax_t index, smallArrayt *array);
-typedef smallArrayt*         (*setAtArraycSmallArrayFt)   (smallArrayt *self, intmax_t index, char **array);
-typedef smallArrayt*         (*setAtSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, smallBoolt *value);
-typedef smallArrayt*         (*setAtSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index, smallBytest *value);
-typedef smallArrayt*         (*setAtSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, smallDoublet *value);
-typedef smallArrayt*         (*setAtSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index, smallIntt *value);
-typedef smallArrayt*         (*setAtSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index, smallJsont *value);
-typedef smallArrayt*         (*setAtSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index, smallStringt *string);
-typedef smallArrayt*         (*setAtSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index, smallContainert *container);
+typedef smallArrayt*         (*setAtSmallArrayFt)     (smallArrayt *self, int64_t index, baset *value);
+typedef smallArrayt*         (*setAtUndefinedSmallArrayFt)(smallArrayt *self, int64_t index);
+typedef smallArrayt*         (*setAtBoolSmallArrayFt)     (smallArrayt *self, int64_t index, bool value);
+typedef smallArrayt*         (*setAtDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, double value);
+typedef smallArrayt*         (*setAtIntSmallArrayFt)      (smallArrayt *self, int64_t index, int64_t value);
+typedef smallArrayt*         (*setAtSSmallArrayFt)        (smallArrayt *self, int64_t index, const char *string);
+typedef smallArrayt*         (*setAtCharSmallArrayFt)     (smallArrayt *self, int64_t index, char c);
+typedef smallArrayt*         (*setAtDictSmallArrayFt)     (smallArrayt *self, int64_t index, smallDictt *dict);
+typedef smallArrayt*         (*setAtArraySmallArrayFt)    (smallArrayt *self, int64_t index, smallArrayt *array);
+typedef smallArrayt*         (*setAtArraycSmallArrayFt)   (smallArrayt *self, int64_t index, char **array);
+typedef smallArrayt*         (*setAtSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index, smallBoolt *value);
+typedef smallArrayt*         (*setAtSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index, smallBytest *value);
+typedef smallArrayt*         (*setAtSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, smallDoublet *value);
+typedef smallArrayt*         (*setAtSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index, smallIntt *value);
+typedef smallArrayt*         (*setAtSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index, smallJsont *value);
+typedef smallArrayt*         (*setAtSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index, smallStringt *string);
+typedef smallArrayt*         (*setAtSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *container);
 
 /**
  * store object at given index (free already existing elements)
@@ -870,19 +870,19 @@ typedef smallArrayt*         (*setAtSmallContainerSmallArrayFt)(smallArrayt *sel
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallArrayt*         (*setAtNFreeSmallArrayFt)         (smallArrayt *self, intmax_t index, baset *value);
-typedef smallArrayt*         (*setAtNFreeUndefinedSmallArrayFt)(smallArrayt *self, intmax_t index, undefinedt *undefined);
-typedef smallArrayt*         (*setAtNFreeSSmallArrayFt)        (smallArrayt *self, intmax_t index, char *string);
-typedef smallArrayt*         (*setAtNFreeDictSmallArrayFt)     (smallArrayt *self, intmax_t index, smallDictt *dict);
-typedef smallArrayt*         (*setAtNFreeArraySmallArrayFt)    (smallArrayt *self, intmax_t index, smallArrayt *array);
-typedef smallArrayt*         (*setAtNFreeArraycSmallArrayFt)   (smallArrayt *self, intmax_t index, char **array);
-typedef smallArrayt*         (*setAtNFreeSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, smallBoolt *value);
-typedef smallArrayt*         (*setAtNFreeSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index, smallBytest *value);
-typedef smallArrayt*         (*setAtNFreeSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, smallDoublet *value);
-typedef smallArrayt*         (*setAtNFreeSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index, smallIntt *value);
-typedef smallArrayt*         (*setAtNFreeSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index, smallJsont *value);
-typedef smallArrayt*         (*setAtNFreeSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index, smallStringt *string);
-typedef smallArrayt*         (*setAtNFreeSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index, smallContainert *container);
+typedef smallArrayt*         (*setAtNFreeSmallArrayFt)         (smallArrayt *self, int64_t index, baset *value);
+typedef smallArrayt*         (*setAtNFreeUndefinedSmallArrayFt)(smallArrayt *self, int64_t index, undefinedt *undefined);
+typedef smallArrayt*         (*setAtNFreeSSmallArrayFt)        (smallArrayt *self, int64_t index, char *string);
+typedef smallArrayt*         (*setAtNFreeDictSmallArrayFt)     (smallArrayt *self, int64_t index, smallDictt *dict);
+typedef smallArrayt*         (*setAtNFreeArraySmallArrayFt)    (smallArrayt *self, int64_t index, smallArrayt *array);
+typedef smallArrayt*         (*setAtNFreeArraycSmallArrayFt)   (smallArrayt *self, int64_t index, char **array);
+typedef smallArrayt*         (*setAtNFreeSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index, smallBoolt *value);
+typedef smallArrayt*         (*setAtNFreeSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index, smallBytest *value);
+typedef smallArrayt*         (*setAtNFreeSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, smallDoublet *value);
+typedef smallArrayt*         (*setAtNFreeSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index, smallIntt *value);
+typedef smallArrayt*         (*setAtNFreeSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index, smallJsont *value);
+typedef smallArrayt*         (*setAtNFreeSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index, smallStringt *string);
+typedef smallArrayt*         (*setAtNFreeSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *container);
 
 /**
  * store pointer at given index (existing element is not freed)
@@ -898,14 +898,14 @@ typedef smallArrayt*         (*setAtNFreeSmallContainerSmallArrayFt)(smallArrayt
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallArrayt*         (*setPAtArraySmallArrayFt)           (smallArrayt *self, intmax_t index, smallArrayt *array);
-typedef smallArrayt*         (*setPAtDictSmallArrayFt)            (smallArrayt *self, intmax_t index, smallDictt *dict);
-typedef smallArrayt*         (*setPAtSmallJsonSmallArrayFt)       (smallArrayt *self, intmax_t index, smallJsont *json);
-typedef smallArrayt*         (*setPAtSmallStringSmallArrayFt)     (smallArrayt *self, intmax_t index, smallStringt *string);
-typedef smallArrayt*         (*setPAtNFreeArraySmallArrayFt)      (smallArrayt *self, intmax_t index, smallArrayt *array);
-typedef smallArrayt*         (*setPAtNFreeDictSmallArrayFt)       (smallArrayt *self, intmax_t index, smallDictt *dict);
-typedef smallArrayt*         (*setPAtNFreeSmallJsonSmallArrayFt)  (smallArrayt *self, intmax_t index, smallJsont *json);
-typedef smallArrayt*         (*setPAtNFreeSmallStringSmallArrayFt)(smallArrayt *self, intmax_t index, smallStringt *string);
+typedef smallArrayt*         (*setPAtArraySmallArrayFt)           (smallArrayt *self, int64_t index, smallArrayt *array);
+typedef smallArrayt*         (*setPAtDictSmallArrayFt)            (smallArrayt *self, int64_t index, smallDictt *dict);
+typedef smallArrayt*         (*setPAtSmallJsonSmallArrayFt)       (smallArrayt *self, int64_t index, smallJsont *json);
+typedef smallArrayt*         (*setPAtSmallStringSmallArrayFt)     (smallArrayt *self, int64_t index, smallStringt *string);
+typedef smallArrayt*         (*setPAtNFreeArraySmallArrayFt)      (smallArrayt *self, int64_t index, smallArrayt *array);
+typedef smallArrayt*         (*setPAtNFreeDictSmallArrayFt)       (smallArrayt *self, int64_t index, smallDictt *dict);
+typedef smallArrayt*         (*setPAtNFreeSmallJsonSmallArrayFt)  (smallArrayt *self, int64_t index, smallJsont *json);
+typedef smallArrayt*         (*setPAtNFreeSmallStringSmallArrayFt)(smallArrayt *self, int64_t index, smallStringt *string);
 
 /**
  * get number
@@ -919,7 +919,7 @@ typedef smallArrayt*         (*setPAtNFreeSmallStringSmallArrayFt)(smallArrayt *
  * \return
  *   double type number or 0
  */
-typedef double               (*getNumSmallArrayFt)                 (smallArrayt *self, intmax_t index);
+typedef double               (*getNumSmallArrayFt)                 (smallArrayt *self, int64_t index);
 
 /**
  * check if self has object
@@ -1180,12 +1180,12 @@ typedef void (*enumerateSmallArrayFt)              (smallArrayt *self, void *clo
  */
 typedef baset*   (*iterStartSmallArrayFt)          (smallArrayt *self);
 typedef baset*   (*iterStartLastSmallArrayFt)      (smallArrayt *self);
-typedef baset*   (*iterStartFromSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef baset*   (*iterStartFromStepSmallArrayFt)  (smallArrayt *self, intmax_t index, intmax_t step);
+typedef baset*   (*iterStartFromSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef baset*   (*iterStartFromStepSmallArrayFt)  (smallArrayt *self, int64_t index, int64_t step);
 typedef baset*   (*iterNextSmallArrayFt)           (smallArrayt *self);
 typedef baset*   (*iterElementSmallArrayFt)        (smallArrayt *self);
 typedef ssize_t  (*iterIndexSmallArrayFt)          (smallArrayt *self);
-typedef intmax_t (*iterStepSmallArrayFt)           (smallArrayt *self);
+typedef int64_t (*iterStepSmallArrayFt)           (smallArrayt *self);
 
 /**
  * join list, the elements are seperated with delim in the resulting string
@@ -1325,8 +1325,8 @@ typedef bool          (*appendTextSmallStringSmallArrayFt)(smallArrayt *self, sm
  * \return
  *    object type string
  */
-typedef const char*   (*typeStringSmallArrayFt) (smallArrayt *self, intmax_t index);
-typedef smallStringt* (*typeSmallStringSmallArrayFt)(smallArrayt *self, intmax_t index);
+typedef const char*   (*typeStringSmallArrayFt) (smallArrayt *self, int64_t index);
+typedef smallStringt* (*typeSmallStringSmallArrayFt)(smallArrayt *self, int64_t index);
 
 /**
  * get object type at index
@@ -1336,7 +1336,7 @@ typedef smallStringt* (*typeSmallStringSmallArrayFt)(smallArrayt *self, intmax_t
  * \return
  *    object type
  */
-typedef char         (*typeSmallArrayFt)       (smallArrayt *self, intmax_t index);
+typedef char         (*typeSmallArrayFt)       (smallArrayt *self, int64_t index);
 
 /**
  * get first level of object type string in array
@@ -1358,17 +1358,17 @@ typedef smallBytest* (*typesSmallArrayFt)      (smallArrayt *self);
 /**
  * is element at index of type type
  */
-typedef bool (*isETypeSmallArrayFt)      (smallArrayt *self, intmax_t index, const char *type);
-typedef bool (*isEUndefinedSmallArrayFt) (smallArrayt *self, intmax_t index);
-typedef bool (*isEBoolSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef bool (*isEContainerSmallArrayFt) (smallArrayt *self, intmax_t index);
-typedef bool (*isEDictSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef bool (*isEDoubleSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef bool (*isEIntSmallArrayFt)       (smallArrayt *self, intmax_t index);
-typedef bool (*isEStringSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef bool (*isEFaststringSmallArrayFt)(smallArrayt *self, intmax_t index);
-typedef bool (*isEArraySmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef bool (*isEBytesSmallArrayFt)     (smallArrayt *self, intmax_t index);
+typedef bool (*isETypeSmallArrayFt)      (smallArrayt *self, int64_t index, const char *type);
+typedef bool (*isEUndefinedSmallArrayFt) (smallArrayt *self, int64_t index);
+typedef bool (*isEBoolSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef bool (*isEContainerSmallArrayFt) (smallArrayt *self, int64_t index);
+typedef bool (*isEDictSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef bool (*isEDoubleSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef bool (*isEIntSmallArrayFt)       (smallArrayt *self, int64_t index);
+typedef bool (*isEStringSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef bool (*isEFaststringSmallArrayFt)(smallArrayt *self, int64_t index);
+typedef bool (*isEArraySmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef bool (*isEBytesSmallArrayFt)     (smallArrayt *self, int64_t index);
 
 /**
  * are all elements of type type
@@ -1866,7 +1866,7 @@ struct smallArray {
   // internal
   sArrayt              *a;
   ssize_t              iterIndex;
-  intmax_t             iterStep;
+  int64_t             iterStep;
   baset*               iterElement;
   // iterElementDataType indicates what the type baset object in iterElement
   // if iterElement is not small* class object then finish must not be called
@@ -2077,96 +2077,96 @@ void*            dequeueVoidSmallArrayG          (smallArrayt *self, void* retTy
 smallContainert* dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED);
 
 
-baset*           getAtSmallArrayG              (smallArrayt *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, intmax_t index);
-bool*            getAtBoolPSmallArrayG         (smallArrayt *self, bool* retType UNUSED, intmax_t index);
-double           getAtDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, intmax_t index);
-double*          getAtDoublePSmallArrayG       (smallArrayt *self, double* retType UNUSED, intmax_t index);
-int64_t          getAtIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, intmax_t index);
-int64_t*         getAtIntPSmallArrayG          (smallArrayt *self, int64_t* retType UNUSED, intmax_t index);
-int32_t          getAtInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, intmax_t index);
-int32_t*         getAtInt32PSmallArrayG        (smallArrayt *self, int32_t* retType UNUSED, intmax_t index);
-uint64_t         getAtUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, intmax_t index);
-uint64_t*        getAtUintPSmallArrayG         (smallArrayt *self, uint64_t* retType UNUSED, intmax_t index);
-uint32_t         getAtUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, intmax_t index);
-uint32_t*        getAtUint32PSmallArrayG       (smallArrayt *self, uint32_t* retType UNUSED, intmax_t index);
-char*            getAtSSmallArrayG             (smallArrayt *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtSmallBytesSmallArrayG    (smallArrayt *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*      getAtSmallJsonSmallArrayG     (smallArrayt *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, intmax_t index);
-
-baset*           getAtNDupSmallArrayG              (smallArrayt *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtNDupUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtNDupBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, intmax_t index);
-double           getAtNDupDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, intmax_t index);
-int64_t          getAtNDupIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, intmax_t index);
-int32_t          getAtNDupInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, intmax_t index);
-uint64_t         getAtNDupUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, intmax_t index);
-uint32_t         getAtNDupUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, intmax_t index);
-char*            getAtNDupSSmallArrayG             (smallArrayt *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtNDupDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtNDupArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtNDupSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtNDupSmallBytesSmallArrayG    (smallArrayt *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtNDupSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtNDupSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*      getAtNDupSmallJsonSmallArrayG      (smallArrayt *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtNDupSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtNDupVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, intmax_t index);
-
-smallArrayt* setAtSmallArrayG         (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtBoolSmallArrayG     (smallArrayt *self, intmax_t index, bool value);
-smallArrayt* setAtDoubleSmallArrayG   (smallArrayt *self, intmax_t index, double value);
-smallArrayt* setAtIntSmallArrayG      (smallArrayt *self, intmax_t index, int64_t value);
-smallArrayt* setAtSSmallArrayG        (smallArrayt *self, intmax_t index, const char *string);
-smallArrayt* setAtCharSmallArrayG     (smallArrayt *self, intmax_t index, char c);
-smallArrayt* setAtDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setAtArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setAtArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* setAtCArraycSmallArrayG  (smallArrayt *self, intmax_t index, const char **array);
-smallArrayt* setAtVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* setAtSmallBytesSmallArrayG    (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* setAtSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* setAtSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* setAtSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *value);
-smallArrayt* setAtSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-smallArrayt* setAtNFreeSmallArrayG    (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtNFreeSSmallArrayG        (smallArrayt *self, intmax_t index, char *string);
-smallArrayt* setAtNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setAtNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setAtNFreeArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* setAtNFreeVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtNFreeSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* setAtNFreeSmallBytesSmallArrayG    (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* setAtNFreeSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* setAtNFreeSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* setAtNFreeSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *value);
-smallArrayt* setAtNFreeSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-
-smallArrayt* setPAtDictSmallArrayG              (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setPAtArraySmallArrayG             (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setPAtSmallJsonSmallArrayG         (smallArrayt *self, intmax_t index, smallJsont *json);
-smallArrayt* setPAtSmallStringSmallArrayG       (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* setPAtNFreeDictSmallArrayG         (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setPAtNFreeArraySmallArrayG        (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setPAtNFreeSmallJsonSmallArrayG    (smallArrayt *self, intmax_t index, smallJsont *json);
-smallArrayt* setPAtNFreeSmallStringSmallArrayG  (smallArrayt *self, intmax_t index, smallStringt *string);
-
-double       getNumSmallArrayG                  (smallArrayt *self, intmax_t index);
+baset*           getAtSmallArrayG              (smallArrayt *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, int64_t index);
+bool*            getAtBoolPSmallArrayG         (smallArrayt *self, bool* retType UNUSED, int64_t index);
+double           getAtDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, int64_t index);
+double*          getAtDoublePSmallArrayG       (smallArrayt *self, double* retType UNUSED, int64_t index);
+int64_t          getAtIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, int64_t index);
+int64_t*         getAtIntPSmallArrayG          (smallArrayt *self, int64_t* retType UNUSED, int64_t index);
+int32_t          getAtInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, int64_t index);
+int32_t*         getAtInt32PSmallArrayG        (smallArrayt *self, int32_t* retType UNUSED, int64_t index);
+uint64_t         getAtUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, int64_t index);
+uint64_t*        getAtUintPSmallArrayG         (smallArrayt *self, uint64_t* retType UNUSED, int64_t index);
+uint32_t         getAtUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, int64_t index);
+uint32_t*        getAtUint32PSmallArrayG       (smallArrayt *self, uint32_t* retType UNUSED, int64_t index);
+char*            getAtSSmallArrayG             (smallArrayt *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtSmallBytesSmallArrayG    (smallArrayt *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*      getAtSmallJsonSmallArrayG     (smallArrayt *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index);
+
+baset*           getAtNDupSmallArrayG              (smallArrayt *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtNDupUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtNDupBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, int64_t index);
+double           getAtNDupDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, int64_t index);
+int64_t          getAtNDupIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, int64_t index);
+int32_t          getAtNDupInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, int64_t index);
+uint64_t         getAtNDupUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, int64_t index);
+uint32_t         getAtNDupUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, int64_t index);
+char*            getAtNDupSSmallArrayG             (smallArrayt *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtNDupDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtNDupArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtNDupSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtNDupSmallBytesSmallArrayG    (smallArrayt *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtNDupSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtNDupSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*      getAtNDupSmallJsonSmallArrayG      (smallArrayt *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtNDupSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtNDupVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index);
+
+smallArrayt* setAtSmallArrayG         (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtBoolSmallArrayG     (smallArrayt *self, int64_t index, bool value);
+smallArrayt* setAtDoubleSmallArrayG   (smallArrayt *self, int64_t index, double value);
+smallArrayt* setAtIntSmallArrayG      (smallArrayt *self, int64_t index, int64_t value);
+smallArrayt* setAtSSmallArrayG        (smallArrayt *self, int64_t index, const char *string);
+smallArrayt* setAtCharSmallArrayG     (smallArrayt *self, int64_t index, char c);
+smallArrayt* setAtDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setAtArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setAtArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* setAtCArraycSmallArrayG  (smallArrayt *self, int64_t index, const char **array);
+smallArrayt* setAtVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* setAtSmallBytesSmallArrayG    (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* setAtSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* setAtSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* setAtSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *value);
+smallArrayt* setAtSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+smallArrayt* setAtNFreeSmallArrayG    (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtNFreeSSmallArrayG        (smallArrayt *self, int64_t index, char *string);
+smallArrayt* setAtNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setAtNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setAtNFreeArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* setAtNFreeVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtNFreeSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* setAtNFreeSmallBytesSmallArrayG    (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* setAtNFreeSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* setAtNFreeSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* setAtNFreeSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *value);
+smallArrayt* setAtNFreeSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+
+smallArrayt* setPAtDictSmallArrayG              (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setPAtArraySmallArrayG             (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setPAtSmallJsonSmallArrayG         (smallArrayt *self, int64_t index, smallJsont *json);
+smallArrayt* setPAtSmallStringSmallArrayG       (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* setPAtNFreeDictSmallArrayG         (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setPAtNFreeArraySmallArrayG        (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setPAtNFreeSmallJsonSmallArrayG    (smallArrayt *self, int64_t index, smallJsont *json);
+smallArrayt* setPAtNFreeSmallStringSmallArrayG  (smallArrayt *self, int64_t index, smallStringt *string);
+
+double       getNumSmallArrayG                  (smallArrayt *self, int64_t index);
 
 smallArrayt* reverseSmallArrayG              (smallArrayt *self);
 smallArrayt* appendSmallArrayG               (smallArrayt *self, smallArrayt *array);
@@ -2182,71 +2182,71 @@ smallArrayt* shiftNSmashSmallArrayG          (smallArrayt *self, smallArrayt *ar
 smallArrayt* shiftNSmashSmallJsonSmallArrayG (smallArrayt *self, smallJsont *json);
 
 smallArrayt* addSmallArrayG  (smallArrayt *self, smallArrayt *array);
-smallArrayt* sliceSmallArrayG(smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* cropSmallArrayG                      (smallArrayt *self, intmax_t start, intmax_t end);
-baset* cropElemSmallArrayG                        (smallArrayt *self, intmax_t index);
-undefinedt* cropElemUndefinedSmallArrayG          (smallArrayt *self, intmax_t index);
-bool cropElemBoolSmallArrayG                      (smallArrayt *self, intmax_t index);
-double cropElemDoubleSmallArrayG                  (smallArrayt *self, intmax_t index);
-int64_t cropElemIntSmallArrayG                    (smallArrayt *self, intmax_t index);
-int32_t cropElemInt32SmallArrayG                  (smallArrayt *self, intmax_t index);
-uint64_t cropElemUintSmallArrayG                  (smallArrayt *self, intmax_t index);
-uint32_t cropElemUint32SmallArrayG                (smallArrayt *self, intmax_t index);
-char* cropElemSSmallArrayG                        (smallArrayt *self, intmax_t index);
-smallDictt* cropElemDictSmallArrayG               (smallArrayt *self, intmax_t index);
-smallArrayt* cropElemArraySmallArrayG             (smallArrayt *self, intmax_t index);
-smallBoolt* cropElemSmallBoolSmallArrayG          (smallArrayt *self, intmax_t index);
-smallBytest* cropElemSmallBytesSmallArrayG        (smallArrayt *self, intmax_t index);
-smallDoublet* cropElemSmallDoubleSmallArrayG      (smallArrayt *self, intmax_t index);
-smallIntt* cropElemSmallIntSmallArrayG            (smallArrayt *self, intmax_t index);
-smallJsont* cropElemSmallJsonSmallArrayG          (smallArrayt *self, intmax_t index);
-smallStringt* cropElemSmallStringSmallArrayG      (smallArrayt *self, intmax_t index);
-void* cropElemVoidSmallArrayG                     (smallArrayt *self, intmax_t index);
-smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, intmax_t index);
-smallArrayt* copySmallArrayG (smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* insertSmallArrayG               (smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-smallArrayt* insertSmallJsonSmallArrayG      (smallArrayt *self, intmax_t index, smallJsont *toInsert);
-smallArrayt* insertNSmashSmallArrayG         (smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *toInsert);
-
-smallArrayt* injectSmallArrayG         (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value);
-smallArrayt* injectBoolSmallArrayG     (smallArrayt *self, intmax_t index, bool value);
-smallArrayt* injectDoubleSmallArrayG   (smallArrayt *self, intmax_t index, double value);
-smallArrayt* injectIntSmallArrayG      (smallArrayt *self, intmax_t index, int64_t value);
-smallArrayt* injectSSmallArrayG        (smallArrayt *self, intmax_t index, const char *string);
-smallArrayt* injectCharSmallArrayG(smallArrayt *self, intmax_t index, char c);
-smallArrayt* injectDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* injectArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* injectArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* injectCArraycSmallArrayG   (smallArrayt *self, intmax_t index, const char **array);
-smallArrayt* injectVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* injectSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* injectSmallBytesSmallArrayG    (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* injectSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* injectSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* injectSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *string);
-smallArrayt* injectSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-smallArrayt* injectNFreeSmallArrayG    (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, intmax_t index, undefinedt *value);
-smallArrayt* injectNFreeSSmallArrayG        (smallArrayt *self, intmax_t index, char *string);
-smallArrayt* injectNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* injectNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* injectNFreeArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* injectNFreeVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* injectNFreeSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* injectNFreeSmallBytesSmallArrayG    (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* injectNFreeSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* injectNFreeSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* injectNFreeSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *string);
-smallArrayt* injectNFreeSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-
-smallArrayt* delSmallArrayG           (smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* delElemSmallArrayG       (smallArrayt *self, intmax_t index);
-smallArrayt* removeSmallArrayG        (smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* removeElemSmallArrayG    (smallArrayt *self, intmax_t index);
+smallArrayt* sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* cropSmallArrayG                      (smallArrayt *self, int64_t start, int64_t end);
+baset* cropElemSmallArrayG                        (smallArrayt *self, int64_t index);
+undefinedt* cropElemUndefinedSmallArrayG          (smallArrayt *self, int64_t index);
+bool cropElemBoolSmallArrayG                      (smallArrayt *self, int64_t index);
+double cropElemDoubleSmallArrayG                  (smallArrayt *self, int64_t index);
+int64_t cropElemIntSmallArrayG                    (smallArrayt *self, int64_t index);
+int32_t cropElemInt32SmallArrayG                  (smallArrayt *self, int64_t index);
+uint64_t cropElemUintSmallArrayG                  (smallArrayt *self, int64_t index);
+uint32_t cropElemUint32SmallArrayG                (smallArrayt *self, int64_t index);
+char* cropElemSSmallArrayG                        (smallArrayt *self, int64_t index);
+smallDictt* cropElemDictSmallArrayG               (smallArrayt *self, int64_t index);
+smallArrayt* cropElemArraySmallArrayG             (smallArrayt *self, int64_t index);
+smallBoolt* cropElemSmallBoolSmallArrayG          (smallArrayt *self, int64_t index);
+smallBytest* cropElemSmallBytesSmallArrayG        (smallArrayt *self, int64_t index);
+smallDoublet* cropElemSmallDoubleSmallArrayG      (smallArrayt *self, int64_t index);
+smallIntt* cropElemSmallIntSmallArrayG            (smallArrayt *self, int64_t index);
+smallJsont* cropElemSmallJsonSmallArrayG          (smallArrayt *self, int64_t index);
+smallStringt* cropElemSmallStringSmallArrayG      (smallArrayt *self, int64_t index);
+void* cropElemVoidSmallArrayG                     (smallArrayt *self, int64_t index);
+smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index);
+smallArrayt* copySmallArrayG (smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* insertSmallArrayG               (smallArrayt *self, int64_t index, smallArrayt *toInsert);
+smallArrayt* insertSmallJsonSmallArrayG      (smallArrayt *self, int64_t index, smallJsont *toInsert);
+smallArrayt* insertNSmashSmallArrayG         (smallArrayt *self, int64_t index, smallArrayt *toInsert);
+smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert);
+
+smallArrayt* injectSmallArrayG         (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value);
+smallArrayt* injectBoolSmallArrayG     (smallArrayt *self, int64_t index, bool value);
+smallArrayt* injectDoubleSmallArrayG   (smallArrayt *self, int64_t index, double value);
+smallArrayt* injectIntSmallArrayG      (smallArrayt *self, int64_t index, int64_t value);
+smallArrayt* injectSSmallArrayG        (smallArrayt *self, int64_t index, const char *string);
+smallArrayt* injectCharSmallArrayG(smallArrayt *self, int64_t index, char c);
+smallArrayt* injectDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* injectArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* injectArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* injectCArraycSmallArrayG   (smallArrayt *self, int64_t index, const char **array);
+smallArrayt* injectVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* injectSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* injectSmallBytesSmallArrayG    (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* injectSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* injectSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* injectSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *string);
+smallArrayt* injectSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+smallArrayt* injectNFreeSmallArrayG    (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value);
+smallArrayt* injectNFreeSSmallArrayG        (smallArrayt *self, int64_t index, char *string);
+smallArrayt* injectNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* injectNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* injectNFreeArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* injectNFreeVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* injectNFreeSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* injectNFreeSmallBytesSmallArrayG    (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* injectNFreeSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* injectNFreeSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* injectNFreeSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *string);
+smallArrayt* injectNFreeSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+
+smallArrayt* delSmallArrayG           (smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* delElemSmallArrayG       (smallArrayt *self, int64_t index);
+smallArrayt* removeSmallArrayG        (smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* removeElemSmallArrayG    (smallArrayt *self, int64_t index);
 smallArrayt* sortSmallArrayG          (smallArrayt *self);
 smallArrayt* sortFSmallArrayG         (smallArrayt *self, shCmpt compareFunction);
 smallArrayt* icSortSmallArrayG        (smallArrayt *self);
@@ -2384,7 +2384,7 @@ bool writeTextSmallStringSmallArrayG (smallArrayt *self, smallStringt *filePath)
 bool writeStreamSmallArrayG          (smallArrayt *self, FILE *fp);
 bool appendTextSmallArrayG(smallArrayt *self, const char *filePath);
 bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath);
-smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, intmax_t index);
+smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, int64_t index);
 smallArrayt* typeSmallStringsSmallArrayG(smallArrayt *self);
 
 /**
diff --git a/release/json/libsheepyCSmallArrayCuTest.c b/release/json/libsheepyCSmallArrayCuTest.c
@@ -17829,7 +17829,7 @@ void iterIndexSmallArrayT(CuTest *tc UNUSED) {
 
 void iterStepSmallArrayT(CuTest *tc UNUSED) {
 
-  intmax_t r;
+  int64_t r;
   baset* r2;
   smallArrayt *self = allocG(rtSmallArrayt);
 
diff --git a/release/json/libsheepyCSmallArrayTest.c b/release/json/libsheepyCSmallArrayTest.c
@@ -17818,7 +17818,7 @@ END_TEST
 
 START_TEST(iterStepSmallArrayT)
 
-  intmax_t r;
+  int64_t r;
   baset* r2;
   smallArrayt *self = allocG(rtSmallArrayt);
 
diff --git a/release/json/libsheepyCSmallArrayTestMem.c b/release/json/libsheepyCSmallArrayTestMem.c
@@ -17827,7 +17827,7 @@ void iterIndexSmallArrayT(void) {
 
 void iterStepSmallArrayT(void) {
 
-  intmax_t r;
+  int64_t r;
   baset* r2;
   smallArrayt *self = allocG(rtSmallArrayt);
 
diff --git a/release/json/libsheepyCSmallBool.h b/release/json/libsheepyCSmallBool.h
@@ -285,8 +285,8 @@ smallBoolt* duplicateSmallBoolG (smallBoolt *self);
 
 void    freeSmallBoolG      (smallBoolt *self);
 
-bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, intmax_t index UNUSED);
-bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, intmax_t index UNUSED);
+bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, int64_t index UNUSED);
+bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, int64_t index UNUSED);
 
 smallBoolt* setSmallBoolG(smallBoolt* self, bool p2);
 smallBoolt* setDoubleSmallBoolG(smallBoolt* self, double p2);
diff --git a/release/json/libsheepyCSmallBytes.h b/release/json/libsheepyCSmallBytes.h
@@ -89,7 +89,7 @@ typedef smallBytest*    (*pushBufferSmallBytesFt) (smallBytest *self, void *data
  * \return
  *    char at index
  */
-typedef char            (*getAtSmallBytesFt) (smallBytest *self, intmax_t index);
+typedef char            (*getAtSmallBytesFt) (smallBytest *self, int64_t index);
 
 /**
  * return buffer size in bytes
@@ -300,7 +300,7 @@ smallBytest* duplicateSmallBytesG (smallBytest *self);
 
 void            freeSmallBytesG      (smallBytest *self);
 
-char getAtSmallBytesG(smallBytest *self, char retType UNUSED, intmax_t index);
+char getAtSmallBytesG(smallBytest *self, char retType UNUSED, int64_t index);
 smallBytest* pushSmallBytesG (smallBytest *self, char data);
 size_t lenSmallBytesG(smallBytest *self);
 bool isEmptySmallBytesG(smallBytest *self);
diff --git a/release/json/libsheepyCSmallContainer.h b/release/json/libsheepyCSmallContainer.h
@@ -255,7 +255,7 @@ smallContainert* duplicateSmallContainerG              (smallContainert *self);
 
 void  freeSmallContainerG(smallContainert *self);
 
-void* getSmallContainerG(smallContainert *self, void* retType UNUSED, intmax_t index UNUSED);
+void* getSmallContainerG(smallContainert *self, void* retType UNUSED, int64_t index UNUSED);
 
 smallContainert* setSmallContainerG(smallContainert *self, void *data);
 
diff --git a/release/json/libsheepyCSmallDouble.h b/release/json/libsheepyCSmallDouble.h
@@ -283,7 +283,7 @@ smallDoublet*      duplicateSmallDoubleG          (smallDoublet *self);
 
 void               freeSmallDoubleG               (smallDoublet *self);
 
-double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, intmax_t index UNUSED);
+double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, int64_t index UNUSED);
 
 smallDoublet*               setBoolSmallDoubleG            (smallDoublet* self, bool p2);
 smallDoublet*               setSmallDoubleG                (smallDoublet* self, double p2);
@@ -298,7 +298,7 @@ smallDoublet*               setSmallIntSmallDoubleG        (smallDoublet* self, 
 smallDoublet*               setSmallJsonSmallDoubleG       (smallDoublet* self, smallJsont* p2);
 smallDoublet*               setSmallStringSmallDoubleG     (smallDoublet* self, smallStringt* p2);
 
-double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, intmax_t index UNUSED);
+double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, int64_t index UNUSED);
 
 bool               equalSmallDoubleChaG           (smallDoublet* self, char p2);
 bool               equalSmallDoubleCharG          (smallDoublet* self, const char * p2);
diff --git a/release/json/libsheepyCSmallInt.h b/release/json/libsheepyCSmallInt.h
@@ -285,14 +285,14 @@ smallIntt*          duplicateSmallIntG       (smallIntt *self);
 
 void                freeSmallIntG            (smallIntt *self);
 
-int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, intmax_t index UNUSED);
-int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, intmax_t index UNUSED);
-int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, intmax_t index UNUSED);
-int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, intmax_t index UNUSED);
-uint64_t            getUintSmallIntG         (smallIntt *self, uint64_t retType UNUSED, intmax_t index UNUSED);
-uint64_t*           getUintPSmallIntG        (smallIntt *self, uint64_t* retType UNUSED, intmax_t index UNUSED);
-uint32_t            getUint32SmallIntG       (smallIntt *self, uint32_t retType UNUSED, intmax_t index UNUSED);
-uint32_t*           getUint32PSmallIntG      (smallIntt *self, uint32_t* retType UNUSED, intmax_t index UNUSED);
+int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, int64_t index UNUSED);
+int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, int64_t index UNUSED);
+int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, int64_t index UNUSED);
+int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, int64_t index UNUSED);
+uint64_t            getUintSmallIntG         (smallIntt *self, uint64_t retType UNUSED, int64_t index UNUSED);
+uint64_t*           getUintPSmallIntG        (smallIntt *self, uint64_t* retType UNUSED, int64_t index UNUSED);
+uint32_t            getUint32SmallIntG       (smallIntt *self, uint32_t retType UNUSED, int64_t index UNUSED);
+uint32_t*           getUint32PSmallIntG      (smallIntt *self, uint32_t* retType UNUSED, int64_t index UNUSED);
 
 smallIntt*                setBoolSmallIntG         (smallIntt* self, bool p2);
 smallIntt*                setDoubleSmallIntG       (smallIntt* self, double p2);
diff --git a/release/json/libsheepyCSmallJson.h b/release/json/libsheepyCSmallJson.h
@@ -446,23 +446,23 @@ typedef smallJsont*         (*setNFreePSmallStringSmallJsonFt)(smallJsont *self,
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallJsont*         (*setAtSmallJsonFt)     (smallJsont *self, intmax_t index, baset *value);
-typedef smallJsont*         (*setAtUndefinedSmallJsonFt)(smallJsont *self, intmax_t index);
-typedef smallJsont*         (*setAtBoolSmallJsonFt)     (smallJsont *self, intmax_t index, bool value);
-typedef smallJsont*         (*setAtDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, double value);
-typedef smallJsont*         (*setAtIntSmallJsonFt)      (smallJsont *self, intmax_t index, int64_t value);
-typedef smallJsont*         (*setAtSSmallJsonFt)        (smallJsont *self, intmax_t index, const char *string);
-typedef smallJsont*         (*setAtCharSmallJsonFt)     (smallJsont *self, intmax_t index, char c);
-typedef smallJsont*         (*setAtDictSmallJsonFt)     (smallJsont *self, intmax_t index, smallDictt *dict);
-typedef smallJsont*         (*setAtArraySmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *array);
-typedef smallJsont*         (*setAtArraycSmallJsonFt)   (smallJsont *self, intmax_t index, char **array);
-typedef smallJsont*         (*setAtSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index, smallBoolt *value);
-typedef smallJsont*         (*setAtSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index, smallBytest *value);
-typedef smallJsont*         (*setAtSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, smallDoublet *value);
-typedef smallJsont*         (*setAtSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index, smallIntt *value);
-typedef smallJsont*         (*setAtSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index, smallJsont *value);
-typedef smallJsont*         (*setAtSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index, smallStringt *string);
-typedef smallJsont*         (*setAtSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index, smallContainert *container);
+typedef smallJsont*         (*setAtSmallJsonFt)     (smallJsont *self, int64_t index, baset *value);
+typedef smallJsont*         (*setAtUndefinedSmallJsonFt)(smallJsont *self, int64_t index);
+typedef smallJsont*         (*setAtBoolSmallJsonFt)     (smallJsont *self, int64_t index, bool value);
+typedef smallJsont*         (*setAtDoubleSmallJsonFt)   (smallJsont *self, int64_t index, double value);
+typedef smallJsont*         (*setAtIntSmallJsonFt)      (smallJsont *self, int64_t index, int64_t value);
+typedef smallJsont*         (*setAtSSmallJsonFt)        (smallJsont *self, int64_t index, const char *string);
+typedef smallJsont*         (*setAtCharSmallJsonFt)     (smallJsont *self, int64_t index, char c);
+typedef smallJsont*         (*setAtDictSmallJsonFt)     (smallJsont *self, int64_t index, smallDictt *dict);
+typedef smallJsont*         (*setAtArraySmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *array);
+typedef smallJsont*         (*setAtArraycSmallJsonFt)   (smallJsont *self, int64_t index, char **array);
+typedef smallJsont*         (*setAtSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index, smallBoolt *value);
+typedef smallJsont*         (*setAtSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index, smallBytest *value);
+typedef smallJsont*         (*setAtSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index, smallDoublet *value);
+typedef smallJsont*         (*setAtSmallIntSmallJsonFt)      (smallJsont *self, int64_t index, smallIntt *value);
+typedef smallJsont*         (*setAtSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index, smallJsont *value);
+typedef smallJsont*         (*setAtSmallStringSmallJsonFt)   (smallJsont *self, int64_t index, smallStringt *string);
+typedef smallJsont*         (*setAtSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *container);
 
 /**
  * store object at given index (free already existing elements)
@@ -480,19 +480,19 @@ typedef smallJsont*         (*setAtSmallContainerSmallJsonFt)(smallJsont *self, 
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallJsont*         (*setAtNFreeSmallJsonFt)         (smallJsont *self, intmax_t index, baset *value);
-typedef smallJsont*         (*setAtNFreeUndefinedSmallJsonFt)(smallJsont *self, intmax_t index, undefinedt *undefined);
-typedef smallJsont*         (*setAtNFreeSSmallJsonFt)        (smallJsont *self, intmax_t index, char *string);
-typedef smallJsont*         (*setAtNFreeDictSmallJsonFt)     (smallJsont *self, intmax_t index, smallDictt *dict);
-typedef smallJsont*         (*setAtNFreeArraySmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *array);
-typedef smallJsont*         (*setAtNFreeArraycSmallJsonFt)   (smallJsont *self, intmax_t index, char **array);
-typedef smallJsont*         (*setAtNFreeSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index, smallBoolt *value);
-typedef smallJsont*         (*setAtNFreeSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index, smallBytest *value);
-typedef smallJsont*         (*setAtNFreeSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, smallDoublet *value);
-typedef smallJsont*         (*setAtNFreeSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index, smallIntt *value);
-typedef smallJsont*         (*setAtNFreeSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index, smallJsont *value);
-typedef smallJsont*         (*setAtNFreeSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index, smallStringt *string);
-typedef smallJsont*         (*setAtNFreeSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index, smallContainert *container);
+typedef smallJsont*         (*setAtNFreeSmallJsonFt)         (smallJsont *self, int64_t index, baset *value);
+typedef smallJsont*         (*setAtNFreeUndefinedSmallJsonFt)(smallJsont *self, int64_t index, undefinedt *undefined);
+typedef smallJsont*         (*setAtNFreeSSmallJsonFt)        (smallJsont *self, int64_t index, char *string);
+typedef smallJsont*         (*setAtNFreeDictSmallJsonFt)     (smallJsont *self, int64_t index, smallDictt *dict);
+typedef smallJsont*         (*setAtNFreeArraySmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *array);
+typedef smallJsont*         (*setAtNFreeArraycSmallJsonFt)   (smallJsont *self, int64_t index, char **array);
+typedef smallJsont*         (*setAtNFreeSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index, smallBoolt *value);
+typedef smallJsont*         (*setAtNFreeSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index, smallBytest *value);
+typedef smallJsont*         (*setAtNFreeSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index, smallDoublet *value);
+typedef smallJsont*         (*setAtNFreeSmallIntSmallJsonFt)      (smallJsont *self, int64_t index, smallIntt *value);
+typedef smallJsont*         (*setAtNFreeSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index, smallJsont *value);
+typedef smallJsont*         (*setAtNFreeSmallStringSmallJsonFt)   (smallJsont *self, int64_t index, smallStringt *string);
+typedef smallJsont*         (*setAtNFreeSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *container);
 
 /**
  * store pointer at given index (existing element is not freed)
@@ -508,14 +508,14 @@ typedef smallJsont*         (*setAtNFreeSmallContainerSmallJsonFt)(smallJsont *s
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallJsont*         (*setPAtArraySmallJsonFt)           (smallJsont *self, intmax_t index, smallArrayt *array);
-typedef smallJsont*         (*setPAtDictSmallJsonFt)            (smallJsont *self, intmax_t index, smallDictt *dict);
-typedef smallJsont*         (*setPAtSmallJsonSmallJsonFt)       (smallJsont *self, intmax_t index, smallJsont *value);
-typedef smallJsont*         (*setPAtSmallStringSmallJsonFt)     (smallJsont *self, intmax_t index, smallStringt *string);
-typedef smallJsont*         (*setPAtNFreeArraySmallJsonFt)      (smallJsont *self, intmax_t index, smallArrayt *array);
-typedef smallJsont*         (*setPAtNFreeDictSmallJsonFt)       (smallJsont *self, intmax_t index, smallDictt *dict);
-typedef smallJsont*         (*setPAtNFreeSmallJsonSmallJsonFt)  (smallJsont *self, intmax_t index, smallJsont *value);
-typedef smallJsont*         (*setPAtNFreeSmallStringSmallJsonFt)(smallJsont *self, intmax_t index, smallStringt *string);
+typedef smallJsont*         (*setPAtArraySmallJsonFt)           (smallJsont *self, int64_t index, smallArrayt *array);
+typedef smallJsont*         (*setPAtDictSmallJsonFt)            (smallJsont *self, int64_t index, smallDictt *dict);
+typedef smallJsont*         (*setPAtSmallJsonSmallJsonFt)       (smallJsont *self, int64_t index, smallJsont *value);
+typedef smallJsont*         (*setPAtSmallStringSmallJsonFt)     (smallJsont *self, int64_t index, smallStringt *string);
+typedef smallJsont*         (*setPAtNFreeArraySmallJsonFt)      (smallJsont *self, int64_t index, smallArrayt *array);
+typedef smallJsont*         (*setPAtNFreeDictSmallJsonFt)       (smallJsont *self, int64_t index, smallDictt *dict);
+typedef smallJsont*         (*setPAtNFreeSmallJsonSmallJsonFt)  (smallJsont *self, int64_t index, smallJsont *value);
+typedef smallJsont*         (*setPAtNFreeSmallStringSmallJsonFt)(smallJsont *self, int64_t index, smallStringt *string);
 
 /**
  * get element
@@ -589,31 +589,31 @@ typedef smallContainert* (*getNDupSmallContainerSmallJsonFt)(smallJsont *self, c
  *   pointer to object
  *   NULL when array is NULL or index is not set correctly
  */
-typedef baset*           (*getAtSmallJsonFt)              (smallJsont *self, intmax_t index);
-typedef undefinedt*      (*getAtUndefinedSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef bool             (*getAtBoolSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef bool*            (*getAtBoolPSmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef double           (*getAtDoubleSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef double*          (*getAtDoublePSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef int64_t          (*getAtIntSmallJsonFt)           (smallJsont *self, intmax_t index);
-typedef int64_t*         (*getAtIntPSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef int32_t          (*getAtInt32SmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef int32_t*         (*getAtInt32PSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef uint64_t         (*getAtUintSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef uint64_t*        (*getAtUintPSmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef uint32_t         (*getAtUint32SmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef uint32_t*        (*getAtUint32PSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef char*            (*getAtSSmallJsonFt)             (smallJsont *self, intmax_t index);
-typedef smallDictt*      (*getAtDictSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef smallArrayt*     (*getAtArraySmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef smallBoolt*      (*getAtSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallBytest*     (*getAtSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef smallDoublet*    (*getAtSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index);
-typedef smallIntt*       (*getAtSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef smallJsont*      (*getAtSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallStringt*    (*getAtSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index);
-typedef void*            (*getAtVoidSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef smallContainert* (*getAtSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index);
+typedef baset*           (*getAtSmallJsonFt)              (smallJsont *self, int64_t index);
+typedef undefinedt*      (*getAtUndefinedSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef bool             (*getAtBoolSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef bool*            (*getAtBoolPSmallJsonFt)         (smallJsont *self, int64_t index);
+typedef double           (*getAtDoubleSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef double*          (*getAtDoublePSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef int64_t          (*getAtIntSmallJsonFt)           (smallJsont *self, int64_t index);
+typedef int64_t*         (*getAtIntPSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef int32_t          (*getAtInt32SmallJsonFt)         (smallJsont *self, int64_t index);
+typedef int32_t*         (*getAtInt32PSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef uint64_t         (*getAtUintSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef uint64_t*        (*getAtUintPSmallJsonFt)         (smallJsont *self, int64_t index);
+typedef uint32_t         (*getAtUint32SmallJsonFt)        (smallJsont *self, int64_t index);
+typedef uint32_t*        (*getAtUint32PSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef char*            (*getAtSSmallJsonFt)             (smallJsont *self, int64_t index);
+typedef smallDictt*      (*getAtDictSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef smallArrayt*     (*getAtArraySmallJsonFt)         (smallJsont *self, int64_t index);
+typedef smallBoolt*      (*getAtSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallBytest*     (*getAtSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef smallDoublet*    (*getAtSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index);
+typedef smallIntt*       (*getAtSmallIntSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef smallJsont*      (*getAtSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallStringt*    (*getAtSmallStringSmallJsonFt)   (smallJsont *self, int64_t index);
+typedef void*            (*getAtVoidSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef smallContainert* (*getAtSmallContainerSmallJsonFt)(smallJsont *self, int64_t index);
 
 /**
  * get duplicated object at index
@@ -625,25 +625,25 @@ typedef smallContainert* (*getAtSmallContainerSmallJsonFt)(smallJsont *self, int
  *   duplicated object
  *   NULL when array is NULL or index is not set correctly
  */
-typedef baset*           (*getAtNDupSmallJsonFt)              (smallJsont *self, intmax_t index);
-typedef undefinedt*      (*getAtNDupUndefinedSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef bool             (*getAtNDupBoolSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef double           (*getAtNDupDoubleSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef int64_t          (*getAtNDupIntSmallJsonFt)           (smallJsont *self, intmax_t index);
-typedef int32_t          (*getAtNDupInt32SmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef uint64_t         (*getAtNDupUintSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef uint32_t         (*getAtNDupUint32SmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef char*            (*getAtNDupSSmallJsonFt)             (smallJsont *self, intmax_t index);
-typedef smallDictt*      (*getAtNDupDictSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef smallArrayt*     (*getAtNDupArraySmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef smallBoolt*      (*getAtNDupSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallBytest*     (*getAtNDupSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef smallDoublet*    (*getAtNDupSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index);
-typedef smallIntt*       (*getAtNDupSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef smallJsont*      (*getAtNDupSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallStringt*    (*getAtNDupSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index);
-typedef void*            (*getAtNDupVoidSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef smallContainert* (*getAtNDupSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index);
+typedef baset*           (*getAtNDupSmallJsonFt)              (smallJsont *self, int64_t index);
+typedef undefinedt*      (*getAtNDupUndefinedSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef bool             (*getAtNDupBoolSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef double           (*getAtNDupDoubleSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef int64_t          (*getAtNDupIntSmallJsonFt)           (smallJsont *self, int64_t index);
+typedef int32_t          (*getAtNDupInt32SmallJsonFt)         (smallJsont *self, int64_t index);
+typedef uint64_t         (*getAtNDupUintSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef uint32_t         (*getAtNDupUint32SmallJsonFt)        (smallJsont *self, int64_t index);
+typedef char*            (*getAtNDupSSmallJsonFt)             (smallJsont *self, int64_t index);
+typedef smallDictt*      (*getAtNDupDictSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef smallArrayt*     (*getAtNDupArraySmallJsonFt)         (smallJsont *self, int64_t index);
+typedef smallBoolt*      (*getAtNDupSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallBytest*     (*getAtNDupSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef smallDoublet*    (*getAtNDupSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index);
+typedef smallIntt*       (*getAtNDupSmallIntSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef smallJsont*      (*getAtNDupSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallStringt*    (*getAtNDupSmallStringSmallJsonFt)   (smallJsont *self, int64_t index);
+typedef void*            (*getAtNDupVoidSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef smallContainert* (*getAtNDupSmallContainerSmallJsonFt)(smallJsont *self, int64_t index);
 
 /**
  * get number
@@ -658,7 +658,7 @@ typedef smallContainert* (*getAtNDupSmallContainerSmallJsonFt)(smallJsont *self,
  *   double type number or 0
  */
 typedef double           (*getNumSmallJsonFt)                 (smallJsont *self, const char *key);
-typedef double           (*getNumAtSmallJsonFt)               (smallJsont *self, intmax_t index);
+typedef double           (*getNumAtSmallJsonFt)               (smallJsont *self, int64_t index);
 
 /**
  * delete element
@@ -696,7 +696,7 @@ typedef smallJsont*      (*delElemSmallJsonFt)              (smallJsont *self, c
  *   0  success
  *   -1 error
  */
-typedef smallJsont*      (*delSmallJsonFt)                  (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont*      (*delSmallJsonFt)                  (smallJsont *self, int64_t start, int64_t end);
 
 /**
  * delete element
@@ -714,7 +714,7 @@ typedef smallJsont*      (*delSmallJsonFt)                  (smallJsont *self, i
  * To dispose a and be able to free all objects, the element at index 0 must be freed with delElem
  * The sObject at index 1 and in s are identical, so the element 1 is freed when s is freed
  */
-typedef smallJsont*      (*delElemIndexSmallJsonFt)         (smallJsont *self, intmax_t index);
+typedef smallJsont*      (*delElemIndexSmallJsonFt)         (smallJsont *self, int64_t index);
 
 /**
  * remove without freeing element
@@ -753,7 +753,7 @@ typedef smallJsont*      (*removeElemSmallJsonFt)           (smallJsont *self, c
  *   0  success
  *   -1 error
  */
-typedef smallJsont*      (*removeSmallJsonFt)               (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont*      (*removeSmallJsonFt)               (smallJsont *self, int64_t start, int64_t end);
 
 /**
  * remove without freeing element
@@ -772,7 +772,7 @@ typedef smallJsont*      (*removeSmallJsonFt)               (smallJsont *self, i
  * // to do so, it uses removeElemG since S will free the sString object
  * removeElemG(a, 0);
  */
-typedef smallJsont*      (*removeElemIndexSmallJsonFt)      (smallJsont *self, intmax_t index);
+typedef smallJsont*      (*removeElemIndexSmallJsonFt)      (smallJsont *self, int64_t index);
 
  /**
  * push value to json
@@ -1094,7 +1094,7 @@ typedef smallJsont*          (*addJsonSmallJsonFt)   (smallJsont *self, smallJso
  *   0  success
  *   -1 error
  */
-typedef smallJsont*          (*sliceSmallJsonFt)     (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont*          (*sliceSmallJsonFt)     (smallJsont *self, int64_t start, int64_t end);
 
 /**
  * Crop elements from start to end
@@ -1116,9 +1116,9 @@ typedef smallJsont*          (*sliceSmallJsonFt)     (smallJsont *self, intmax_t
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallJsont*      (*cropSmallJsonFt)                      (smallJsont *self, intmax_t start, intmax_t end);
-typedef char*            (*cropSSmallJsonFt)                     (smallJsont *self, intmax_t start, intmax_t end);
-typedef smallStringt*    (*cropSmallStringSmallJsonFt)           (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont*      (*cropSmallJsonFt)                      (smallJsont *self, int64_t start, int64_t end);
+typedef char*            (*cropSSmallJsonFt)                     (smallJsont *self, int64_t start, int64_t end);
+typedef smallStringt*    (*cropSmallStringSmallJsonFt)           (smallJsont *self, int64_t start, int64_t end);
 
 
 /**
@@ -1134,26 +1134,26 @@ typedef smallStringt*    (*cropSmallStringSmallJsonFt)           (smallJsont *se
  *   unchanged when list is empty
  *   NULL error
  */
-typedef baset*           (*cropElemAtSmallJsonFt)                (smallJsont *self, intmax_t index);
-typedef undefinedt*      (*cropElemAtUndefinedSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef bool             (*cropElemAtBoolSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef double           (*cropElemAtDoubleSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef int64_t          (*cropElemAtIntSmallJsonFt)             (smallJsont *self, intmax_t index);
-typedef int32_t          (*cropElemAtInt32SmallJsonFt)           (smallJsont *self, intmax_t index);
-typedef uint64_t         (*cropElemAtUintSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef uint32_t         (*cropElemAtUint32SmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef char*            (*cropElemAtSSmallJsonFt)               (smallJsont *self, intmax_t index);
-typedef char             (*cropElemAtCharSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef smallDictt*      (*cropElemAtDictSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef smallArrayt*     (*cropElemAtArraySmallJsonFt)           (smallJsont *self, intmax_t index);
-typedef smallBoolt*      (*cropElemAtSmallBoolSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef smallBytest*     (*cropElemAtSmallBytesSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef smallDoublet*    (*cropElemAtSmallDoubleSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallIntt*       (*cropElemAtSmallIntSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef smallJsont*      (*cropElemAtSmallJsonSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef smallStringt*    (*cropElemAtSmallStringSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef void*            (*cropElemAtVoidSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef smallContainert* (*cropElemAtSmallContainerSmallJsonFt)  (smallJsont *self, intmax_t index);
+typedef baset*           (*cropElemAtSmallJsonFt)                (smallJsont *self, int64_t index);
+typedef undefinedt*      (*cropElemAtUndefinedSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef bool             (*cropElemAtBoolSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef double           (*cropElemAtDoubleSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef int64_t          (*cropElemAtIntSmallJsonFt)             (smallJsont *self, int64_t index);
+typedef int32_t          (*cropElemAtInt32SmallJsonFt)           (smallJsont *self, int64_t index);
+typedef uint64_t         (*cropElemAtUintSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef uint32_t         (*cropElemAtUint32SmallJsonFt)          (smallJsont *self, int64_t index);
+typedef char*            (*cropElemAtSSmallJsonFt)               (smallJsont *self, int64_t index);
+typedef char             (*cropElemAtCharSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef smallDictt*      (*cropElemAtDictSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef smallArrayt*     (*cropElemAtArraySmallJsonFt)           (smallJsont *self, int64_t index);
+typedef smallBoolt*      (*cropElemAtSmallBoolSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef smallBytest*     (*cropElemAtSmallBytesSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef smallDoublet*    (*cropElemAtSmallDoubleSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallIntt*       (*cropElemAtSmallIntSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef smallJsont*      (*cropElemAtSmallJsonSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef smallStringt*    (*cropElemAtSmallStringSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef void*            (*cropElemAtVoidSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef smallContainert* (*cropElemAtSmallContainerSmallJsonFt)  (smallJsont *self, int64_t index);
 
 /**
  * Crop an Element
@@ -1202,7 +1202,7 @@ typedef smallContainert* (*cropElemKeySmallContainerSmallJsonFt) (smallJsont *se
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallJsont* (*copySmallJsonFt)          (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont* (*copySmallJsonFt)          (smallJsont *self, int64_t start, int64_t end);
 
 /**
  * insert array in self at index
@@ -1220,10 +1220,10 @@ typedef smallJsont* (*copySmallJsonFt)          (smallJsont *self, intmax_t star
  *   unchanged array when array is NULL or invalid index
  *   NULL error
  */
-typedef smallJsont*          (*insertSmallJsonFt)          (smallJsont *self, intmax_t index, smallArrayt *toInsert);
-typedef smallJsont*          (*insertNSmashSmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *toInsert);
-typedef smallJsont*          (*insertSmallJsonSmallJsonFt)      (smallJsont *self, intmax_t index, smallJsont *toInsert);
-typedef smallJsont*          (*insertNSmashSmallJsonSmallJsonFt)(smallJsont *self, intmax_t index, smallJsont *toInsert);
+typedef smallJsont*          (*insertSmallJsonFt)          (smallJsont *self, int64_t index, smallArrayt *toInsert);
+typedef smallJsont*          (*insertNSmashSmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *toInsert);
+typedef smallJsont*          (*insertSmallJsonSmallJsonFt)      (smallJsont *self, int64_t index, smallJsont *toInsert);
+typedef smallJsont*          (*insertNSmashSmallJsonSmallJsonFt)(smallJsont *self, int64_t index, smallJsont *toInsert);
 
 /**
  * insert smallString in self at index
@@ -1240,10 +1240,10 @@ typedef smallJsont*          (*insertNSmashSmallJsonSmallJsonFt)(smallJsont *sel
  *   self smallString
  *   NULL unchanged smallString when smallString is NULL or invalid index
  */
-typedef smallJsont* (*insertStringSmallJsonFt)    (smallJsont *self, intmax_t index, smallStringt *toInsert);
-typedef smallJsont* (*insertSSmallJsonFt)    (smallJsont *self, intmax_t index, const char *toInsert);
-typedef smallJsont* (*insertNFreeStringSmallJsonFt)(smallJsont *self, intmax_t index, smallStringt *toInsert);
-typedef smallJsont* (*insertSNFreeSmallJsonFt)    (smallJsont *self, intmax_t index, char *toInsert);
+typedef smallJsont* (*insertStringSmallJsonFt)    (smallJsont *self, int64_t index, smallStringt *toInsert);
+typedef smallJsont* (*insertSSmallJsonFt)    (smallJsont *self, int64_t index, const char *toInsert);
+typedef smallJsont* (*insertNFreeStringSmallJsonFt)(smallJsont *self, int64_t index, smallStringt *toInsert);
+typedef smallJsont* (*insertSNFreeSmallJsonFt)    (smallJsont *self, int64_t index, char *toInsert);
 
 /**
  * inject an element in self at index
@@ -1260,37 +1260,37 @@ typedef smallJsont* (*insertSNFreeSmallJsonFt)    (smallJsont *self, intmax_t in
  *   unchanged array when array is NULL or invalid index
  *   NULL error
  */
-typedef smallJsont* (*injectSmallJsonFt)     (smallJsont *self, intmax_t index, baset *toInject);
-typedef smallJsont* (*injectUndefinedSmallJsonFt)(smallJsont *self, intmax_t index);
-typedef smallJsont* (*injectBoolSmallJsonFt)     (smallJsont *self, intmax_t index, bool toInject);
-typedef smallJsont* (*injectDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, double toInject);
-typedef smallJsont* (*injectIntSmallJsonFt)      (smallJsont *self, intmax_t index, int64_t toInject);
-typedef smallJsont* (*injectSSmallJsonFt)        (smallJsont *self, intmax_t index, const char *toInject);
-typedef smallJsont* (*injectCharSmallJsonFt)     (smallJsont *self, intmax_t index, char c);
-typedef smallJsont* (*injectDictSmallJsonFt)     (smallJsont *self, intmax_t index, smallDictt *toInject);
-typedef smallJsont* (*injectArraySmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *toInject);
-typedef smallJsont* (*injectArraycSmallJsonFt)   (smallJsont *self, intmax_t index, char **toInject);
-typedef smallJsont* (*injectSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index, smallBoolt *toInject);
-typedef smallJsont* (*injectSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index, smallBytest *toInject);
-typedef smallJsont* (*injectSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, smallDoublet *toInject);
-typedef smallJsont* (*injectSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index, smallIntt *toInject);
-typedef smallJsont* (*injectSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index, smallJsont *toInject);
-typedef smallJsont* (*injectSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index, smallStringt *toInject);
-typedef smallJsont* (*injectSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index, smallContainert *toInject);
-
-typedef smallJsont* (*injectNFreeSmallJsonFt)         (smallJsont *self, intmax_t index, baset *toInject);
-typedef smallJsont* (*injectNFreeUndefinedSmallJsonFt)(smallJsont *self, intmax_t index, undefinedt *undefined);
-typedef smallJsont* (*injectNFreeSSmallJsonFt)        (smallJsont *self, intmax_t index, char *toInject);
-typedef smallJsont* (*injectNFreeDictSmallJsonFt)     (smallJsont *self, intmax_t index, smallDictt *toInject);
-typedef smallJsont* (*injectNFreeArraySmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *toInject);
-typedef smallJsont* (*injectNFreeArraycSmallJsonFt)   (smallJsont *self, intmax_t index, char **toInject);
-typedef smallJsont* (*injectNFreeSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index, smallBoolt *toInject);
-typedef smallJsont* (*injectNFreeSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index, smallBytest *toInject);
-typedef smallJsont* (*injectNFreeSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, smallDoublet *toInject);
-typedef smallJsont* (*injectNFreeSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index, smallIntt *toInject);
-typedef smallJsont* (*injectNFreeSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index, smallJsont *toInject);
-typedef smallJsont* (*injectNFreeSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index, smallStringt *toInject);
-typedef smallJsont* (*injectNFreeSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index, smallContainert *toInject);
+typedef smallJsont* (*injectSmallJsonFt)     (smallJsont *self, int64_t index, baset *toInject);
+typedef smallJsont* (*injectUndefinedSmallJsonFt)(smallJsont *self, int64_t index);
+typedef smallJsont* (*injectBoolSmallJsonFt)     (smallJsont *self, int64_t index, bool toInject);
+typedef smallJsont* (*injectDoubleSmallJsonFt)   (smallJsont *self, int64_t index, double toInject);
+typedef smallJsont* (*injectIntSmallJsonFt)      (smallJsont *self, int64_t index, int64_t toInject);
+typedef smallJsont* (*injectSSmallJsonFt)        (smallJsont *self, int64_t index, const char *toInject);
+typedef smallJsont* (*injectCharSmallJsonFt)     (smallJsont *self, int64_t index, char c);
+typedef smallJsont* (*injectDictSmallJsonFt)     (smallJsont *self, int64_t index, smallDictt *toInject);
+typedef smallJsont* (*injectArraySmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *toInject);
+typedef smallJsont* (*injectArraycSmallJsonFt)   (smallJsont *self, int64_t index, char **toInject);
+typedef smallJsont* (*injectSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index, smallBoolt *toInject);
+typedef smallJsont* (*injectSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index, smallBytest *toInject);
+typedef smallJsont* (*injectSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index, smallDoublet *toInject);
+typedef smallJsont* (*injectSmallIntSmallJsonFt)      (smallJsont *self, int64_t index, smallIntt *toInject);
+typedef smallJsont* (*injectSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index, smallJsont *toInject);
+typedef smallJsont* (*injectSmallStringSmallJsonFt)   (smallJsont *self, int64_t index, smallStringt *toInject);
+typedef smallJsont* (*injectSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *toInject);
+
+typedef smallJsont* (*injectNFreeSmallJsonFt)         (smallJsont *self, int64_t index, baset *toInject);
+typedef smallJsont* (*injectNFreeUndefinedSmallJsonFt)(smallJsont *self, int64_t index, undefinedt *undefined);
+typedef smallJsont* (*injectNFreeSSmallJsonFt)        (smallJsont *self, int64_t index, char *toInject);
+typedef smallJsont* (*injectNFreeDictSmallJsonFt)     (smallJsont *self, int64_t index, smallDictt *toInject);
+typedef smallJsont* (*injectNFreeArraySmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *toInject);
+typedef smallJsont* (*injectNFreeArraycSmallJsonFt)   (smallJsont *self, int64_t index, char **toInject);
+typedef smallJsont* (*injectNFreeSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index, smallBoolt *toInject);
+typedef smallJsont* (*injectNFreeSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index, smallBytest *toInject);
+typedef smallJsont* (*injectNFreeSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index, smallDoublet *toInject);
+typedef smallJsont* (*injectNFreeSmallIntSmallJsonFt)      (smallJsont *self, int64_t index, smallIntt *toInject);
+typedef smallJsont* (*injectNFreeSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index, smallJsont *toInject);
+typedef smallJsont* (*injectNFreeSmallStringSmallJsonFt)   (smallJsont *self, int64_t index, smallStringt *toInject);
+typedef smallJsont* (*injectNFreeSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *toInject);
 
 /**
  * Uniquify elements of list
@@ -1763,10 +1763,10 @@ typedef bool (*icEqualCharSmallJsonFt)       (smallJsont *self, char c);
  *   true smallString at index is equal to string
  *   false they differ
  */
-typedef bool     (*equalISSmallJsonFt)   (smallJsont *self, const char *string, intmax_t index);
-typedef bool     (*equalICharSmallJsonFt)(smallJsont *self, char c, intmax_t index);
-typedef bool     (*equalIJsonSmallJsonFt)(smallJsont *self, smallJsont *string, intmax_t index);
-typedef bool     (*equalISmallStringSmallJsonFt)   (smallJsont *self, smallStringt *string, intmax_t index);
+typedef bool     (*equalISSmallJsonFt)   (smallJsont *self, const char *string, int64_t index);
+typedef bool     (*equalICharSmallJsonFt)(smallJsont *self, char c, int64_t index);
+typedef bool     (*equalIJsonSmallJsonFt)(smallJsont *self, smallJsont *string, int64_t index);
+typedef bool     (*equalISmallStringSmallJsonFt)   (smallJsont *self, smallStringt *string, int64_t index);
 
 /**
  * starts With String
@@ -1899,9 +1899,9 @@ typedef bool (*isIntSmallJsonFt) (smallJsont *self);
  * \return
  *   int64_t
  *   0 when smallString represents 0 or doesnt represent a number or the input is NULL
- *   INTMAX_MAX or INTMAX_MIN for strtoimax parse errors.
+ *   INT64_MAX or INT64_MIN for strtoll parse errors.
  */
-typedef intmax_t (*parseIntSmallJsonFt)  (smallJsont *self);
+typedef int64_t (*parseIntSmallJsonFt)  (smallJsont *self);
 
 /**
  * convert self to double
@@ -1918,9 +1918,9 @@ typedef double (*parseDoubleSmallJsonFt)  (smallJsont *self);
  * convert int to smallString, assign result to self
  *
  * \param
- *   intmax_t number
+ *   int64_t number
  */
-typedef smallJsont*     (*intToSmallJsonFt)     (smallJsont *self, intmax_t n);
+typedef smallJsont*     (*intToSmallJsonFt)     (smallJsont *self, int64_t n);
 
 /**
  * double To String
@@ -2286,14 +2286,14 @@ typedef smallJsont*  (*zipCArrayJsonSmallJsonFt)    (smallJsont *self, const cha
 typedef baset*         (*iterStartSmallJsonFt)        (smallJsont *self);
 typedef const char*    (*iterStartKeySmallJsonFt)     (smallJsont *self);
 typedef baset*         (*iterStartLastSmallJsonFt)    (smallJsont *self);
-typedef baset*         (*iterStartFromSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef baset*         (*iterStartFromStepSmallJsonFt)(smallJsont *self, intmax_t index, intmax_t step);
+typedef baset*         (*iterStartFromSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef baset*         (*iterStartFromStepSmallJsonFt)(smallJsont *self, int64_t index, int64_t step);
 typedef baset*         (*iterNextSmallJsonFt)         (smallJsont *self);
 typedef const char*    (*iterNextKeySmallJsonFt)      (smallJsont *self);
 typedef baset*         (*iterElementSmallJsonFt)      (smallJsont *self);
 typedef const char*    (*iterKeySmallJsonFt)          (smallJsont *self);
 typedef ssize_t        (*iterIndexSmallJsonFt)        (smallJsont *self);
-typedef intmax_t       (*iterStepSmallJsonFt)         (smallJsont *self);
+typedef int64_t       (*iterStepSmallJsonFt)         (smallJsont *self);
 
 /**
  * stringify self
@@ -2493,8 +2493,8 @@ typedef bool          (*appendTextJsonSmallJsonFt)       (smallJsont *self, smal
  */
 typedef const char*   (*typeStringSmallJsonFt)          (smallJsont *self, const char *key);
 typedef smallStringt* (*typeSmallStringSmallJsonFt)     (smallJsont *self, const char *key);
-typedef const char*   (*typeAtStringSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef smallStringt* (*typeAtSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index);
+typedef const char*   (*typeAtStringSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef smallStringt* (*typeAtSmallStringSmallJsonFt)   (smallJsont *self, int64_t index);
 
 typedef const char*   (*typeStringKCharSmallJsonFt)     (smallJsont *self, char key);
 typedef smallStringt* (*typeSmallStringKCharSmallJsonFt)(smallJsont *self, char key);
@@ -2509,7 +2509,7 @@ typedef smallStringt* (*typeSmallStringKCharSmallJsonFt)(smallJsont *self, char 
  */
 typedef char         (*typeSmallJsonFt)       (smallJsont *self, const char *key);
 typedef char         (*typeKCharSmallJsonFt)  (smallJsont *self, char key);
-typedef char         (*typeAtSmallJsonFt)     (smallJsont *self, intmax_t index);
+typedef char         (*typeAtSmallJsonFt)     (smallJsont *self, int64_t index);
 
 /**
  * get first level of object type string in json
@@ -2530,17 +2530,17 @@ typedef smallBytest* (*typesSmallJsonFt)          (smallJsont *self);
 /**
  * is element at index of type type
  */
-typedef bool (*isETypeAtSmallJsonFt)      (smallJsont *self, intmax_t index, const char *type);
-typedef bool (*isEUndefinedAtSmallJsonFt) (smallJsont *self, intmax_t index);
-typedef bool (*isEBoolAtSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef bool (*isEContainerAtSmallJsonFt) (smallJsont *self, intmax_t index);
-typedef bool (*isEDictAtSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef bool (*isEDoubleAtSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef bool (*isEIntAtSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef bool (*isEStringAtSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef bool (*isEFaststringAtSmallJsonFt)(smallJsont *self, intmax_t index);
-typedef bool (*isEArrayAtSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef bool (*isEBytesAtSmallJsonFt)     (smallJsont *self, intmax_t index);
+typedef bool (*isETypeAtSmallJsonFt)      (smallJsont *self, int64_t index, const char *type);
+typedef bool (*isEUndefinedAtSmallJsonFt) (smallJsont *self, int64_t index);
+typedef bool (*isEBoolAtSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef bool (*isEContainerAtSmallJsonFt) (smallJsont *self, int64_t index);
+typedef bool (*isEDictAtSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef bool (*isEDoubleAtSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef bool (*isEIntAtSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef bool (*isEStringAtSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef bool (*isEFaststringAtSmallJsonFt)(smallJsont *self, int64_t index);
+typedef bool (*isEArrayAtSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef bool (*isEBytesAtSmallJsonFt)     (smallJsont *self, int64_t index);
 
 /**
  * is element at key of type type
@@ -3469,7 +3469,7 @@ struct smallJson {
   void        **propertyOrValue;
   ssize_t     iterIndex;
   char*       iterKey;
-  intmax_t    iterStep;
+  int64_t    iterStep;
   baset*      iterElement;
 };
 
@@ -3713,48 +3713,48 @@ smallJsont* setNFreePArraySmallJsonG      (smallJsont *self, const char *key, sm
 smallJsont* setNFreePSmallJsonSmallJsonG  (smallJsont *self, const char *key, smallJsont *value);
 smallJsont* setNFreePSmallStringSmallJsonG(smallJsont *self, const char *key, smallStringt *string);
 
-smallJsont* setAtSmallJsonG         (smallJsont *self, intmax_t index, baset *value);
-smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtBoolSmallJsonG     (smallJsont *self, intmax_t index, bool value);
-smallJsont* setAtDoubleSmallJsonG   (smallJsont *self, intmax_t index, double value);
-smallJsont* setAtIntSmallJsonG      (smallJsont *self, intmax_t index, int64_t value);
-smallJsont* setAtSSmallJsonG        (smallJsont *self, intmax_t index, const char *string);
-smallJsont* setAtCharSmallJsonG     (smallJsont *self, intmax_t index, char c);
-smallJsont* setAtDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setAtArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setAtArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* setAtCArraycSmallJsonG  (smallJsont *self, intmax_t index, const char **array);
-smallJsont* setAtVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* setAtSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* setAtSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* setAtSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* setAtSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setAtSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* setAtSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
-smallJsont* setAtNFreeSmallJsonG         (smallJsont *self, intmax_t index, baset *value);
-smallJsont* setAtNFreeUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtNFreeSSmallJsonG        (smallJsont *self, intmax_t index, char *string);
-smallJsont* setAtNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setAtNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setAtNFreeArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* setAtNFreeVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtNFreeSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* setAtNFreeSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* setAtNFreeSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* setAtNFreeSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* setAtNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setAtNFreeSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* setAtNFreeSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
-
-smallJsont* setPAtDictSmallJsonG              (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setPAtArraySmallJsonG             (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setPAtSmallJsonSmallJsonG         (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setPAtSmallStringSmallJsonG       (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* setPAtNFreeDictSmallJsonG         (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setPAtNFreeArraySmallJsonG        (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setPAtNFreeSmallJsonSmallJsonG    (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setPAtNFreeSmallStringSmallJsonG  (smallJsont *self, intmax_t index, smallStringt *string);
+smallJsont* setAtSmallJsonG         (smallJsont *self, int64_t index, baset *value);
+smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* setAtBoolSmallJsonG     (smallJsont *self, int64_t index, bool value);
+smallJsont* setAtDoubleSmallJsonG   (smallJsont *self, int64_t index, double value);
+smallJsont* setAtIntSmallJsonG      (smallJsont *self, int64_t index, int64_t value);
+smallJsont* setAtSSmallJsonG        (smallJsont *self, int64_t index, const char *string);
+smallJsont* setAtCharSmallJsonG     (smallJsont *self, int64_t index, char c);
+smallJsont* setAtDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setAtArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setAtArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* setAtCArraycSmallJsonG  (smallJsont *self, int64_t index, const char **array);
+smallJsont* setAtVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* setAtSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* setAtSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* setAtSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* setAtSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* setAtSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setAtSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* setAtSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
+smallJsont* setAtNFreeSmallJsonG         (smallJsont *self, int64_t index, baset *value);
+smallJsont* setAtNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* setAtNFreeSSmallJsonG        (smallJsont *self, int64_t index, char *string);
+smallJsont* setAtNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setAtNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setAtNFreeArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* setAtNFreeVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* setAtNFreeSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* setAtNFreeSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* setAtNFreeSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* setAtNFreeSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* setAtNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setAtNFreeSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* setAtNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
+
+smallJsont* setPAtDictSmallJsonG              (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setPAtArraySmallJsonG             (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setPAtSmallJsonSmallJsonG         (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setPAtSmallStringSmallJsonG       (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* setPAtNFreeDictSmallJsonG         (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setPAtNFreeArraySmallJsonG        (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setPAtNFreeSmallJsonSmallJsonG    (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setPAtNFreeSmallStringSmallJsonG  (smallJsont *self, int64_t index, smallStringt *string);
 
 baset*           getSmallJsonG              (smallJsont *self, baset* retType UNUSED, const char *key);
 undefinedt*      getUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, const char *key);
@@ -3802,63 +3802,63 @@ smallStringt*    getNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt*
 void*            getNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, const char *key);
 smallContainert* getNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, const char *key);
 
-baset*           getAtSmallJsonG              (smallJsont *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, intmax_t index);
-bool*            getAtBoolPSmallJsonG         (smallJsont *self, bool* retType UNUSED, intmax_t index);
-double           getAtDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, intmax_t index);
-double*          getAtDoublePSmallJsonG       (smallJsont *self, double* retType UNUSED, intmax_t index);
-int64_t          getAtIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, intmax_t index);
-int64_t*         getAtIntPSmallJsonG          (smallJsont *self, int64_t* retType UNUSED, intmax_t index);
-int32_t          getAtInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, intmax_t index);
-int32_t*         getAtInt32PSmallJsonG        (smallJsont *self, int32_t* retType UNUSED, intmax_t index);
-uint64_t         getAtUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, intmax_t index);
-uint64_t*        getAtUintPSmallJsonG         (smallJsont *self, uint64_t* retType UNUSED, intmax_t index);
-uint32_t         getAtUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, intmax_t index);
-uint32_t*        getAtUint32PSmallJsonG       (smallJsont *self, uint32_t* retType UNUSED, intmax_t index);
-char*            getAtSSmallJsonG             (smallJsont *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*      getAtSmallJsonSmallJsonG     (smallJsont *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, intmax_t index);
-
-baset*           getAtNDupSmallJsonG              (smallJsont *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtNDupUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtNDupBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, intmax_t index);
-double           getAtNDupDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, intmax_t index);
-int64_t          getAtNDupIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, intmax_t index);
-int32_t          getAtNDupInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, intmax_t index);
-uint64_t         getAtNDupUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, intmax_t index);
-uint32_t         getAtNDupUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, intmax_t index);
-char*            getAtNDupSSmallJsonG             (smallJsont *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtNDupDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtNDupArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtNDupSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtNDupSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtNDupSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtNDupSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*      getAtNDupSmallJsonSmallJsonG     (smallJsont *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, intmax_t index);
+baset*           getAtSmallJsonG              (smallJsont *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, int64_t index);
+bool*            getAtBoolPSmallJsonG         (smallJsont *self, bool* retType UNUSED, int64_t index);
+double           getAtDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, int64_t index);
+double*          getAtDoublePSmallJsonG       (smallJsont *self, double* retType UNUSED, int64_t index);
+int64_t          getAtIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, int64_t index);
+int64_t*         getAtIntPSmallJsonG          (smallJsont *self, int64_t* retType UNUSED, int64_t index);
+int32_t          getAtInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, int64_t index);
+int32_t*         getAtInt32PSmallJsonG        (smallJsont *self, int32_t* retType UNUSED, int64_t index);
+uint64_t         getAtUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, int64_t index);
+uint64_t*        getAtUintPSmallJsonG         (smallJsont *self, uint64_t* retType UNUSED, int64_t index);
+uint32_t         getAtUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, int64_t index);
+uint32_t*        getAtUint32PSmallJsonG       (smallJsont *self, uint32_t* retType UNUSED, int64_t index);
+char*            getAtSSmallJsonG             (smallJsont *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*      getAtSmallJsonSmallJsonG     (smallJsont *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index);
+
+baset*           getAtNDupSmallJsonG              (smallJsont *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtNDupUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtNDupBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, int64_t index);
+double           getAtNDupDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, int64_t index);
+int64_t          getAtNDupIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, int64_t index);
+int32_t          getAtNDupInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, int64_t index);
+uint64_t         getAtNDupUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, int64_t index);
+uint32_t         getAtNDupUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, int64_t index);
+char*            getAtNDupSSmallJsonG             (smallJsont *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtNDupDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtNDupArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtNDupSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtNDupSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtNDupSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtNDupSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*      getAtNDupSmallJsonSmallJsonG     (smallJsont *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index);
 
 double           getNumSmallJsonG                 (smallJsont *self, const char *key);
-double           getNumAtSmallJsonG               (smallJsont *self, intmax_t index);
+double           getNumAtSmallJsonG               (smallJsont *self, int64_t index);
 
 smallJsont*      delKeySmallJsonG               (smallJsont *self, const char *key, int unused UNUSED);
 smallJsont*      delElemSmallJsonG              (smallJsont *self, const char *key);
-smallJsont*      delSmallJsonG                  (smallJsont *self, intmax_t start, intmax_t end);
-smallJsont*      delElemIndexSmallJsonG         (smallJsont *self, intmax_t index);
+smallJsont*      delSmallJsonG                  (smallJsont *self, int64_t start, int64_t end);
+smallJsont*      delElemIndexSmallJsonG         (smallJsont *self, int64_t index);
 smallJsont*      removeKeySmallJsonG            (smallJsont *self, const char *key, int unused UNUSED);
 smallJsont*      removeElemSmallJsonG           (smallJsont *self, const char *key);
-smallJsont*      removeSmallJsonG               (smallJsont *self, intmax_t start, intmax_t end);
-smallJsont*      removeElemIndexSmallJsonG      (smallJsont *self, intmax_t index);
+smallJsont*      removeSmallJsonG               (smallJsont *self, int64_t start, int64_t end);
+smallJsont*      removeElemIndexSmallJsonG      (smallJsont *self, int64_t index);
 
 smallJsont* prependSmallJsonG         (smallJsont *self, baset *value);
 smallJsont* prependUndefinedSmallJsonG(smallJsont *self, void *value UNUSED);
@@ -3935,30 +3935,30 @@ smallJsont* shiftNSmashSmallJsonSmallJsonG(smallJsont *self, smallJsont *array);
 
 smallJsont* addSmallJsonG  (smallJsont *self, smallArrayt *array);
 smallJsont* addJsonSmallJsonG(smallJsont *self, smallJsont *array);
-smallJsont* sliceSmallJsonG(smallJsont *self, intmax_t start, intmax_t end);
-smallJsont* cropSmallJsonG                          (smallJsont *self, intmax_t start, intmax_t end);
-char* cropSSmallJsonG                               (smallJsont *self, intmax_t start, intmax_t end);
-smallStringt* cropSmallStringSmallJsonG             (smallJsont *self, intmax_t start, intmax_t end);
-baset* cropElemAtSmallJsonG                         (smallJsont *self, intmax_t index);
-undefinedt* cropElemAtUndefinedSmallJsonG           (smallJsont *self, intmax_t index);
-bool cropElemAtBoolSmallJsonG                       (smallJsont *self, intmax_t index);
-double cropElemAtDoubleSmallJsonG                   (smallJsont *self, intmax_t index);
-int64_t cropElemAtIntSmallJsonG                     (smallJsont *self, intmax_t index);
-int32_t cropElemAtInt32SmallJsonG                   (smallJsont *self, intmax_t index);
-uint64_t cropElemAtUintSmallJsonG                   (smallJsont *self, intmax_t index);
-uint32_t cropElemAtUint32SmallJsonG                 (smallJsont *self, intmax_t index);
-char* cropElemAtSSmallJsonG                         (smallJsont *self, intmax_t index);
-char cropElemAtCharSmallJsonG                       (smallJsont *self, intmax_t index);
-smallDictt* cropElemAtDictSmallJsonG                (smallJsont *self, intmax_t index);
-smallArrayt* cropElemAtArraySmallJsonG              (smallJsont *self, intmax_t index);
-smallBoolt* cropElemAtSmallBoolSmallJsonG           (smallJsont *self, intmax_t index);
-smallBytest* cropElemAtSmallBytesSmallJsonG         (smallJsont *self, intmax_t index);
-smallDoublet* cropElemAtSmallDoubleSmallJsonG       (smallJsont *self, intmax_t index);
-smallIntt* cropElemAtSmallIntSmallJsonG             (smallJsont *self, intmax_t index);
-smallJsont* cropElemAtSmallJsonSmallJsonG           (smallJsont *self, intmax_t index);
-smallStringt* cropElemAtSmallStringSmallJsonG       (smallJsont *self, intmax_t index);
-void* cropElemAtVoidSmallJsonG                      (smallJsont *self, intmax_t index);
-smallContainert* cropElemAtSmallContainerSmallJsonG (smallJsont *self, intmax_t index);
+smallJsont* sliceSmallJsonG(smallJsont *self, int64_t start, int64_t end);
+smallJsont* cropSmallJsonG                          (smallJsont *self, int64_t start, int64_t end);
+char* cropSSmallJsonG                               (smallJsont *self, int64_t start, int64_t end);
+smallStringt* cropSmallStringSmallJsonG             (smallJsont *self, int64_t start, int64_t end);
+baset* cropElemAtSmallJsonG                         (smallJsont *self, int64_t index);
+undefinedt* cropElemAtUndefinedSmallJsonG           (smallJsont *self, int64_t index);
+bool cropElemAtBoolSmallJsonG                       (smallJsont *self, int64_t index);
+double cropElemAtDoubleSmallJsonG                   (smallJsont *self, int64_t index);
+int64_t cropElemAtIntSmallJsonG                     (smallJsont *self, int64_t index);
+int32_t cropElemAtInt32SmallJsonG                   (smallJsont *self, int64_t index);
+uint64_t cropElemAtUintSmallJsonG                   (smallJsont *self, int64_t index);
+uint32_t cropElemAtUint32SmallJsonG                 (smallJsont *self, int64_t index);
+char* cropElemAtSSmallJsonG                         (smallJsont *self, int64_t index);
+char cropElemAtCharSmallJsonG                       (smallJsont *self, int64_t index);
+smallDictt* cropElemAtDictSmallJsonG                (smallJsont *self, int64_t index);
+smallArrayt* cropElemAtArraySmallJsonG              (smallJsont *self, int64_t index);
+smallBoolt* cropElemAtSmallBoolSmallJsonG           (smallJsont *self, int64_t index);
+smallBytest* cropElemAtSmallBytesSmallJsonG         (smallJsont *self, int64_t index);
+smallDoublet* cropElemAtSmallDoubleSmallJsonG       (smallJsont *self, int64_t index);
+smallIntt* cropElemAtSmallIntSmallJsonG             (smallJsont *self, int64_t index);
+smallJsont* cropElemAtSmallJsonSmallJsonG           (smallJsont *self, int64_t index);
+smallStringt* cropElemAtSmallStringSmallJsonG       (smallJsont *self, int64_t index);
+void* cropElemAtVoidSmallJsonG                      (smallJsont *self, int64_t index);
+smallContainert* cropElemAtSmallContainerSmallJsonG (smallJsont *self, int64_t index);
 baset* cropElemKeySmallJsonG                        (smallJsont *self, const char* key);
 undefinedt* cropElemKeyUndefinedSmallJsonG          (smallJsont *self, const char* key);
 bool cropElemKeyBoolSmallJsonG                      (smallJsont *self, const char* key);
@@ -3978,49 +3978,49 @@ smallJsont* cropElemKeySmallJsonSmallJsonG          (smallJsont *self, const cha
 smallStringt* cropElemKeySmallStringSmallJsonG      (smallJsont *self, const char* key);
 void* cropElemKeyVoidSmallJsonG                     (smallJsont *self, const char* key);
 smallContainert* cropElemKeySmallContainerSmallJsonG(smallJsont *self, const char* key);
-smallJsont* copySmallJsonG (smallJsont *self, intmax_t start, intmax_t end);
-smallJsont* insertSmallJsonG(smallJsont *self, intmax_t index, smallArrayt *toInsert);
-smallJsont* insertNSmashSmallJsonG(smallJsont *self, intmax_t index, smallArrayt *toInsert);
-smallJsont* insertSmallJsonSmallJsonG(smallJsont *self, intmax_t index, smallJsont *toInsert);
-smallJsont* insertNSmashSmallJsonSmallJsonG(smallJsont *self, intmax_t index, smallJsont *toInsert);
-smallJsont* insertStringSmallJsonG     (smallJsont *self, intmax_t index, smallStringt *toInsert);
-smallJsont* insertSSmallJsonG          (smallJsont *self, intmax_t index, const char *toInsert);
-smallJsont* insertNFreeStringSmallJsonG(smallJsont *self, intmax_t index, smallStringt *toInsert); // not used in generics
-smallJsont* insertNFreeSSmallJsonG     (smallJsont *self, intmax_t index, char *toInsert); // not used in generics
-
-smallJsont* injectSmallJsonG         (smallJsont *self, intmax_t index, baset *value);
-smallJsont* injectUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* injectBoolSmallJsonG     (smallJsont *self, intmax_t index, bool value);
-smallJsont* injectDoubleSmallJsonG   (smallJsont *self, intmax_t index, double value);
-smallJsont* injectIntSmallJsonG      (smallJsont *self, intmax_t index, int64_t value);
-smallJsont* injectSSmallJsonG        (smallJsont *self, intmax_t index, const char *string);
-smallJsont* injectCharSmallJsonG(smallJsont *self, intmax_t index, char c);
-smallJsont* injectDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* injectArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* injectArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* injectCArraycSmallJsonG   (smallJsont *self, intmax_t index, const char **array);
-smallJsont* injectVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* injectSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* injectSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* injectSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* injectSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* injectSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* injectSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* injectSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
-smallJsont* injectNFreeSmallJsonG    (smallJsont *self, intmax_t index, baset *value);
-smallJsont* injectNFreeUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* injectNFreeSSmallJsonG        (smallJsont *self, intmax_t index, char *string);
-smallJsont* injectNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* injectNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* injectNFreeArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* injectNFreeVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* injectNFreeSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* injectNFreeSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* injectNFreeSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* injectNFreeSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* injectNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* injectNFreeSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* injectNFreeSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
+smallJsont* copySmallJsonG (smallJsont *self, int64_t start, int64_t end);
+smallJsont* insertSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert);
+smallJsont* insertNSmashSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert);
+smallJsont* insertSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert);
+smallJsont* insertNSmashSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert);
+smallJsont* insertStringSmallJsonG     (smallJsont *self, int64_t index, smallStringt *toInsert);
+smallJsont* insertSSmallJsonG          (smallJsont *self, int64_t index, const char *toInsert);
+smallJsont* insertNFreeStringSmallJsonG(smallJsont *self, int64_t index, smallStringt *toInsert); // not used in generics
+smallJsont* insertNFreeSSmallJsonG     (smallJsont *self, int64_t index, char *toInsert); // not used in generics
+
+smallJsont* injectSmallJsonG         (smallJsont *self, int64_t index, baset *value);
+smallJsont* injectUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* injectBoolSmallJsonG     (smallJsont *self, int64_t index, bool value);
+smallJsont* injectDoubleSmallJsonG   (smallJsont *self, int64_t index, double value);
+smallJsont* injectIntSmallJsonG      (smallJsont *self, int64_t index, int64_t value);
+smallJsont* injectSSmallJsonG        (smallJsont *self, int64_t index, const char *string);
+smallJsont* injectCharSmallJsonG(smallJsont *self, int64_t index, char c);
+smallJsont* injectDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* injectArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* injectArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* injectCArraycSmallJsonG   (smallJsont *self, int64_t index, const char **array);
+smallJsont* injectVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* injectSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* injectSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* injectSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* injectSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* injectSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* injectSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* injectSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
+smallJsont* injectNFreeSmallJsonG    (smallJsont *self, int64_t index, baset *value);
+smallJsont* injectNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* injectNFreeSSmallJsonG        (smallJsont *self, int64_t index, char *string);
+smallJsont* injectNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* injectNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* injectNFreeArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* injectNFreeVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* injectNFreeSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* injectNFreeSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* injectNFreeSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* injectNFreeSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* injectNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* injectNFreeSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* injectNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
 
 smallJsont* uniqSmallJsonG(smallJsont *self, char c);
 smallJsont* icUniqSmallJsonG(smallJsont *self, char c);
@@ -4202,10 +4202,10 @@ bool icEqualSmallJsonSmallJsonG  (smallJsont* self, smallJsont* p2);
 bool icEqualSmallJsonSmallStringG(smallJsont* self, smallStringt* p2);
 bool icEqualCharSmallJsonG       (smallJsont *self, char c);
 bool icEqualSSmallJsonG          (smallJsont *self, const char *string);
-bool    equalISSmallJsonG                (smallJsont *self, const char *string, intmax_t index);
-bool    equalICharSmallJsonG             (smallJsont *self, char c, intmax_t index);
-bool    equalIJsonSmallJsonG             (smallJsont *self, smallJsont *string, intmax_t index);
-bool    equalISmallStringSmallJsonG      (smallJsont *self, smallStringt *string, intmax_t index);
+bool    equalISSmallJsonG                (smallJsont *self, const char *string, int64_t index);
+bool    equalICharSmallJsonG             (smallJsont *self, char c, int64_t index);
+bool    equalIJsonSmallJsonG             (smallJsont *self, smallJsont *string, int64_t index);
+bool    equalISmallStringSmallJsonG      (smallJsont *self, smallStringt *string, int64_t index);
 bool    startsWithSSmallJsonG            (smallJsont *self, const char *string);
 bool    startsWithCharSmallJsonG         (smallJsont *self, char c);
 bool    startsWithSmallStringSmallJsonG  (smallJsont *self, smallStringt *string);
@@ -4232,9 +4232,9 @@ ssize_t icCountSmallStringSmallJsonG     (smallJsont *self, smallStringt *string
 ssize_t icCountJsonSmallJsonG            (smallJsont *self, smallJsont *string);
 bool    isNumberSmallJsonG               (smallJsont *self);
 bool    isIntSmallJsonG                  (smallJsont *self);
-intmax_t parseIntSmallJsonG      (smallJsont *self);
+int64_t parseIntSmallJsonG      (smallJsont *self);
 double   parseDoubleSmallJsonG   (smallJsont *self);
-smallJsont* intToSmallJsonG      (smallJsont *self, intmax_t n);
+smallJsont* intToSmallJsonG      (smallJsont *self, int64_t n);
 smallJsont* doubleToSmallJsonG   (smallJsont *self, double n);
 size_t      lenSmallJsonG        (smallJsont *self);
 smallJsont* upperSmallJsonG      (smallJsont *self);
diff --git a/release/json/libsheepyCSmallJsonCuTest.c b/release/json/libsheepyCSmallJsonCuTest.c
@@ -35143,7 +35143,7 @@ void iterIndexSmallJsonT(CuTest *tc UNUSED) {
 
 void iterStepSmallJsonT(CuTest *tc UNUSED) {
 
-  intmax_t r;
+  int64_t r;
   baset* r2;
   smallJsont *self = allocSmallJson();
 
diff --git a/release/json/libsheepyCSmallJsonTest.c b/release/json/libsheepyCSmallJsonTest.c
@@ -35132,7 +35132,7 @@ END_TEST
 
 START_TEST(iterStepSmallJsonT)
 
-  intmax_t r;
+  int64_t r;
   baset* r2;
   smallJsont *self = allocSmallJson();
 
diff --git a/release/json/libsheepyCSmallJsonTestMem.c b/release/json/libsheepyCSmallJsonTestMem.c
@@ -35141,7 +35141,7 @@ void iterIndexSmallJsonT(void) {
 
 void iterStepSmallJsonT(void) {
 
-  intmax_t r;
+  int64_t r;
   baset* r2;
   smallJsont *self = allocSmallJson();
 
diff --git a/release/json/libsheepyCSmallString.h b/release/json/libsheepyCSmallString.h
@@ -321,10 +321,10 @@ typedef bool     (*icEqualSmallStringSmallJsonFt)(smallStringt* self, smallJsont
  *   true smallString at index is equal to string
  *   false they differ
  */
-typedef bool     (*equalISSmallStringFt)          (smallStringt *self, const char *string, intmax_t index);
-typedef bool     (*equalICharSmallStringFt)       (smallStringt *self, char c, intmax_t index);
-typedef bool     (*equalISmallJsonSmallStringFt)  (smallStringt *self, smallJsont *string, intmax_t index);
-typedef bool     (*equalISmallStringSmallStringFt)(smallStringt *self, smallStringt *string, intmax_t index);
+typedef bool     (*equalISSmallStringFt)          (smallStringt *self, const char *string, int64_t index);
+typedef bool     (*equalICharSmallStringFt)       (smallStringt *self, char c, int64_t index);
+typedef bool     (*equalISmallJsonSmallStringFt)  (smallStringt *self, smallJsont *string, int64_t index);
+typedef bool     (*equalISmallStringSmallStringFt)(smallStringt *self, smallStringt *string, int64_t index);
 
 /**
  * starts With String
@@ -457,9 +457,9 @@ typedef bool (*isIntSmallStringFt) (smallStringt *self);
  * \return
  *   int64_t
  *   0 when smallString represents 0 or doesnt represent a number or the input is NULL
- *   INTMAX_MAX or INTMAX_MIN for strtoimax parse errors.
+ *   INTM64_MAX or INT64_MIN for strtoll parse errors.
  */
-typedef intmax_t (*parseIntSmallStringFt)  (smallStringt *self);
+typedef int64_t (*parseIntSmallStringFt)  (smallStringt *self);
 
 /**
  * convert self to double
@@ -476,9 +476,9 @@ typedef double (*parseDoubleSmallStringFt)  (smallStringt *self);
  * convert int to smallString, assign result to self
  *
  * \param
- *   intmax_t number
+ *   int64_t number
  */
-typedef smallStringt*     (*intToSmallStringFt)     (smallStringt *self, intmax_t n);
+typedef smallStringt*     (*intToSmallStringFt)     (smallStringt *self, int64_t n);
 
 /**
  * double To String
@@ -547,12 +547,12 @@ typedef smallStringt*      (*icUniqSmallStringFt)    (smallStringt *self, char c
 /**
  * get char at python index
  */
-typedef char     (*getAtSmallStringFt)     (smallStringt *self, intmax_t index);
+typedef char     (*getAtSmallStringFt)     (smallStringt *self, int64_t index);
 
 /**
  * set char at python index
  */
-typedef smallStringt*      (*setAtSmallStringFt)     (smallStringt *self, intmax_t index, char c);
+typedef smallStringt*      (*setAtSmallStringFt)     (smallStringt *self, int64_t index, char c);
 
 /**
  * slice self
@@ -568,7 +568,7 @@ typedef smallStringt*      (*setAtSmallStringFt)     (smallStringt *self, intmax
  *      "" when start=end
  *   -1 unchanged smallString when start and end are not set correctly
  */
-typedef smallStringt*      (*sliceSmallStringFt)     (smallStringt *self, intmax_t start, intmax_t end);
+typedef smallStringt*      (*sliceSmallStringFt)     (smallStringt *self, int64_t start, int64_t end);
 
 /**
  * Crop characters from start to end
@@ -587,9 +587,9 @@ typedef smallStringt*      (*sliceSmallStringFt)     (smallStringt *self, intmax
  *   unchanged when string is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallStringt* (*cropSmallStringFt)(smallStringt *self, intmax_t start, intmax_t end);
-typedef char* (*cropSSmallStringFt)(smallStringt *self, intmax_t start, intmax_t end);
-typedef smallJsont* (*cropSmallJsonSmallStringFt)(smallStringt *self, intmax_t start, intmax_t end);
+typedef smallStringt* (*cropSmallStringFt)(smallStringt *self, int64_t start, int64_t end);
+typedef char* (*cropSSmallStringFt)(smallStringt *self, int64_t start, int64_t end);
+typedef smallJsont* (*cropSmallJsonSmallStringFt)(smallStringt *self, int64_t start, int64_t end);
 
 
 /**
@@ -605,7 +605,7 @@ typedef smallJsont* (*cropSmallJsonSmallStringFt)(smallStringt *self, intmax_t s
  *   unchanged when list is empty
  *   0 error
  */
-typedef char (*cropElemSmallStringFt)(smallStringt *self, intmax_t index);
+typedef char (*cropElemSmallStringFt)(smallStringt *self, int64_t index);
 
 
 /**
@@ -622,7 +622,7 @@ typedef char (*cropElemSmallStringFt)(smallStringt *self, intmax_t index);
  *      "" when start=end
  *   NULL when start and end are not set correctly
  */
-typedef smallStringt* (*copySmallStringFt) (smallStringt *self, intmax_t start, intmax_t end);
+typedef smallStringt* (*copySmallStringFt) (smallStringt *self, int64_t start, int64_t end);
 
 /**
  * insert smallString in self at index
@@ -639,12 +639,12 @@ typedef smallStringt* (*copySmallStringFt) (smallStringt *self, intmax_t start, 
  *   self smallString
  *   NULL unchanged smallString when smallString is NULL or invalid index
  */
-typedef smallStringt*      (*insertSmallStringFt)              (smallStringt *self, intmax_t index, smallStringt *toInsert);
-typedef smallStringt*      (*insertSmallJsonSmallStringFt)     (smallStringt *self, intmax_t index, smallJsont *toInsert);
-typedef smallStringt*      (*insertSSmallStringFt)             (smallStringt *self, intmax_t index, const char *toInsert);
-typedef smallStringt*      (*insertNFreeSmallStringFt)         (smallStringt *self, intmax_t index, smallStringt *toInsert);
-typedef smallStringt*      (*insertNFreeSmallJsonSmallStringFt)(smallStringt *self, intmax_t index, smallJsont *toInsert);
-typedef smallStringt*      (*insertSNFreeSmallStringFt)        (smallStringt *self, intmax_t index, char *toInsert);
+typedef smallStringt*      (*insertSmallStringFt)              (smallStringt *self, int64_t index, smallStringt *toInsert);
+typedef smallStringt*      (*insertSmallJsonSmallStringFt)     (smallStringt *self, int64_t index, smallJsont *toInsert);
+typedef smallStringt*      (*insertSSmallStringFt)             (smallStringt *self, int64_t index, const char *toInsert);
+typedef smallStringt*      (*insertNFreeSmallStringFt)         (smallStringt *self, int64_t index, smallStringt *toInsert);
+typedef smallStringt*      (*insertNFreeSmallJsonSmallStringFt)(smallStringt *self, int64_t index, smallJsont *toInsert);
+typedef smallStringt*      (*insertSNFreeSmallStringFt)        (smallStringt *self, int64_t index, char *toInsert);
 
 /**
  * inject a char in self at index
@@ -661,7 +661,7 @@ typedef smallStringt*      (*insertSNFreeSmallStringFt)        (smallStringt *se
  *   self smallString
  *   NULL unchanged smallString when smallString is NULL or invalid index
  */
-typedef smallStringt*      (*injectSmallStringFt)    (smallStringt *self, intmax_t index, char toInject);
+typedef smallStringt*      (*injectSmallStringFt)    (smallStringt *self, int64_t index, char toInject);
 
 /**
  * delete smallString
@@ -679,8 +679,8 @@ typedef smallStringt*      (*injectSmallStringFt)    (smallStringt *self, intmax
  *   -1 when start and end are not set correctly
  *        or when input smallString is NULL or when malloc failed or when end is under start
  */
-typedef smallStringt*      (*delSmallStringFt)       (smallStringt *self, intmax_t start, intmax_t end);
-typedef smallStringt*      (*delElemSmallStringFt)   (smallStringt *self, intmax_t index);
+typedef smallStringt*      (*delSmallStringFt)       (smallStringt *self, int64_t start, int64_t end);
+typedef smallStringt*      (*delElemSmallStringFt)   (smallStringt *self, int64_t index);
 
 /**
  * has SmallString
@@ -1347,8 +1347,8 @@ smallStringt* setSmallIntSmallStringG   (smallStringt* self, smallIntt* p2);
 smallStringt* setSmallJsonSmallStringG  (smallStringt* self, smallJsont* p2);
 smallStringt* setSmallStringSmallStringG(smallStringt* self, smallStringt* p2);
 
-char getAtSmallStringG        (smallStringt *self, char retType UNUSED, intmax_t index);
-smallStringt* setAtSmallStringG         (smallStringt *self, intmax_t index, char c);
+char getAtSmallStringG        (smallStringt *self, char retType UNUSED, int64_t index);
+smallStringt* setAtSmallStringG         (smallStringt *self, int64_t index, char c);
 
 smallStringt* appendSmallStringG               (smallStringt *self, smallStringt *string);
 smallStringt* appendSmallJsonSmallStringG      (smallStringt *self, smallJsont *string);
@@ -1417,10 +1417,10 @@ bool icEqualSmallStringSmallJsonG(smallStringt* self, smallJsont* p2);
 bool icEqualSmallStringFG        (smallStringt* self, smallStringt* p2);
 bool icEqualCharSmallStringG     (smallStringt *self, char c);
 bool icEqualSSmallStringG        (smallStringt *self, const char *string);
-bool equalISSmallStringG      (smallStringt *self, const char *string, intmax_t index);
-bool equalICharSmallStringG   (smallStringt *self, char c, intmax_t index);
-bool equalISmallJsonSmallStringG(smallStringt *self, smallJsont *string, intmax_t index);
-bool equalISmallStringSmallStringG(smallStringt *self, smallStringt *string, intmax_t index);
+bool equalISSmallStringG      (smallStringt *self, const char *string, int64_t index);
+bool equalICharSmallStringG   (smallStringt *self, char c, int64_t index);
+bool equalISmallJsonSmallStringG(smallStringt *self, smallJsont *string, int64_t index);
+bool equalISmallStringSmallStringG(smallStringt *self, smallStringt *string, int64_t index);
 bool startsWithSSmallStringG          (smallStringt *self, const char *string);
 bool startsWithCharSmallStringG       (smallStringt *self, char c);
 bool startsWithSmallJsonSmallStringG  (smallStringt *self, smallJsont *string);
@@ -1447,8 +1447,8 @@ ssize_t icCountSmallJsonSmallStringG  (smallStringt *self, smallJsont *string);
 ssize_t icCountSmallStringSmallStringG(smallStringt *self, smallStringt *string);
 bool isNumberSmallStringG     (smallStringt *self);
 bool isIntSmallStringG        (smallStringt *self);
-intmax_t parseIntSmallStringG (smallStringt *self);
-smallStringt* intToSmallStringG        (smallStringt *self, intmax_t n);
+int64_t parseIntSmallStringG (smallStringt *self);
+smallStringt* intToSmallStringG        (smallStringt *self, int64_t n);
 double   parseDoubleSmallStringG (smallStringt *self);
 smallStringt* doubleToSmallStringG     (smallStringt *self, double n);
 size_t lenSmallStringG        (smallStringt *self);
@@ -1459,21 +1459,21 @@ smallStringt*    lTrimSmallStringG      (smallStringt *self);
 smallStringt*    rTrimSmallStringG      (smallStringt *self);
 smallStringt*    uniqSmallStringG       (smallStringt *self, char c);
 smallStringt*    icUniqSmallStringG     (smallStringt *self, char c);
-smallStringt*    sliceSmallStringG      (smallStringt *self, intmax_t start, intmax_t end);
-smallStringt* cropSmallStringG       (smallStringt *self, intmax_t start, intmax_t end);
-char* cropSSmallStringG              (smallStringt *self, intmax_t start, intmax_t end);
-smallJsont* cropSmallJsonSmallStringG(smallStringt *self, intmax_t start, intmax_t end);
-char cropElemSmallStringG            (smallStringt *self, intmax_t index);
-smallStringt* copySmallStringG(smallStringt *self, intmax_t start, intmax_t end);
-smallStringt*    insertSmallStringG              (smallStringt *self, intmax_t index, smallStringt *toInsert);
-smallStringt*    insertSmallJsonSmallStringG     (smallStringt *self, intmax_t index, smallJsont *toInsert);
-smallStringt*    insertSSmallStringG             (smallStringt *self, intmax_t index, const char *toInsert);
-smallStringt*    insertNFreeSmallStringG         (smallStringt *self, intmax_t index, smallStringt *toInsert);
-smallStringt*    insertNFreeSmallJsonSmallStringG(smallStringt *self, intmax_t index, smallJsont *toInsert);
-smallStringt*    insertSNFreeSmallStringG        (smallStringt *self, intmax_t index, char *toInsert);
-smallStringt*    injectSmallStringG     (smallStringt *self, intmax_t index, char toInject);
-smallStringt*  delSmallStringG          (smallStringt *self, intmax_t start, intmax_t end);
-smallStringt*  delElemSmallStringG      (smallStringt *self, intmax_t index);
+smallStringt*    sliceSmallStringG      (smallStringt *self, int64_t start, int64_t end);
+smallStringt* cropSmallStringG       (smallStringt *self, int64_t start, int64_t end);
+char* cropSSmallStringG              (smallStringt *self, int64_t start, int64_t end);
+smallJsont* cropSmallJsonSmallStringG(smallStringt *self, int64_t start, int64_t end);
+char cropElemSmallStringG            (smallStringt *self, int64_t index);
+smallStringt* copySmallStringG(smallStringt *self, int64_t start, int64_t end);
+smallStringt*    insertSmallStringG              (smallStringt *self, int64_t index, smallStringt *toInsert);
+smallStringt*    insertSmallJsonSmallStringG     (smallStringt *self, int64_t index, smallJsont *toInsert);
+smallStringt*    insertSSmallStringG             (smallStringt *self, int64_t index, const char *toInsert);
+smallStringt*    insertNFreeSmallStringG         (smallStringt *self, int64_t index, smallStringt *toInsert);
+smallStringt*    insertNFreeSmallJsonSmallStringG(smallStringt *self, int64_t index, smallJsont *toInsert);
+smallStringt*    insertSNFreeSmallStringG        (smallStringt *self, int64_t index, char *toInsert);
+smallStringt*    injectSmallStringG     (smallStringt *self, int64_t index, char toInject);
+smallStringt*  delSmallStringG          (smallStringt *self, int64_t start, int64_t end);
+smallStringt*  delElemSmallStringG      (smallStringt *self, int64_t index);
 char* hasSmallStringG           (smallStringt *self, const char *needle);
 char* hasCharSmallStringG       (smallStringt *self, char c);
 char* hasSmallJsonSmallStringG  (smallStringt *self, smallJsont *needle);
diff --git a/release/libsheepy.c b/release/libsheepy.c
@@ -51,7 +51,6 @@ typedef enum { LOCALE_NORMAL, LOCALE_TURKIC, LOCALE_LITHUANIAN } localeType;
 #include <ucontext.h>
 #endif
 #include <libgen.h>
-#include <inttypes.h>
 #include <dirent.h>
 #include <stdarg.h>
 #include <errno.h>
@@ -316,8 +315,8 @@ char *bLicReplaceManySF(char *s, size_t sSize, char *paramType, ...);
 bool eqS(const char *string1, const char *string2);
 bool eqCharS(char c, const char *string2);
 bool eqSChar(const char *string1, char c);
-bool eqIS(const char *string1, const char *string2, intmax_t index);
-bool eqICharS(const char *string1, char c, intmax_t index);
+bool eqIS(const char *string1, const char *string2, int64_t index);
+bool eqICharS(const char *string1, char c, int64_t index);
 bool startsWithS(const char *string1, const char *string2);
 bool startsWithCharS(const char *string1, char c);
 bool endsWithS(const char *string1, const char *string2);
@@ -327,8 +326,8 @@ ssize_t countCharS(const char *s, char c);
 bool icEqS(const char *string1, const char *string2);
 bool icEqCharS(char c, const char *string2);
 bool icEqSChar(const char *string1, char c);
-bool icEqIS(const char *string1, const char *string2, intmax_t index);
-bool icEqICharS(const char *string1, char c, intmax_t index);
+bool icEqIS(const char *string1, const char *string2, int64_t index);
+bool icEqICharS(const char *string1, char c, int64_t index);
 bool icStartsWithS(const char *string1, const char *string2);
 bool icStartsWithCharS(const char *string1, char c);
 bool icEndsWithS(const char *string1, const char *string2);
@@ -341,15 +340,15 @@ char *iStripCtrlS(char **string);
 char *bStripCtrlS(char *string);
 bool isNumber(const char *string);
 bool isInt(const char *string);
-intmax_t parseInt(const char *string);
-intmax_t parseIntChar(char c);
+int64_t parseInt(const char *string);
+int64_t parseIntChar(char c);
 int64_t parseI64(const char *string);
 int64_t parseI64Char(char c);
 double parseDouble(const char *string);
 double parseDoubleChar(char c);
 uint64_t parseHex(const char *string);
-char *intToS(intmax_t n);
-char *bIntToS(char *s, intmax_t n);
+char *intToS(int64_t n);
+char *bIntToS(char *s, int64_t n);
 char *doubleToS(double n);
 char *bDoubleToS(char *s, double n);
 size_t lenS(const char *string);
@@ -418,38 +417,38 @@ char *iPadEndCharS(char **string, size_t targetLength, char padChar);
 char *bPadEndCharS(char *dest, const char *string, size_t targetLength, char padChar);
 char *bLPadEndCharS(char *dest, size_t destSize, const char *string, size_t targetLength, char padChar);
 ssize_t padEndLenS(const char *string, size_t targetLength, const char *padString);
-char getS(const char *string, intmax_t index);
-char *setS(char *string, intmax_t index, char c);
-char *swapS(char *string, intmax_t index1, intmax_t index2);
-char *iSwapS(char **string, intmax_t index1, intmax_t index2);
-char *bSwapS(char *string, intmax_t index1, intmax_t index2);
-char *bLSwapS(char *string, size_t size, intmax_t index1, intmax_t index2);
-char *sliceS(const char *string, intmax_t start, intmax_t end);
-char *iSliceS(char **string, intmax_t start, intmax_t end);
-char *bSliceS(char *string, intmax_t start, intmax_t end);
-char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end);
-char *cropS(char *string, intmax_t start, intmax_t end);
-char *iCropS(char **string, intmax_t start, intmax_t end);
-char cropElemS(char *string, intmax_t index);
-char iCropElemS(char **string, intmax_t index);
-char *insertS(const char *string, intmax_t index, const char *toInsert);
-char *insertNFreeS(const char *string, intmax_t index, char *toInsert);
-char *iInsertS(char **string, intmax_t index, const char *toInsert);
-char *iInsertNFreeS(char **string, intmax_t index, char *toInsert);
-char *bInsertS(char *string, intmax_t index, const char *toInsert);
-char *bLInsertS(char *string, size_t stringSize, intmax_t index, const char *toInsert);
-char *injectS(const char *string, intmax_t index, char toInject);
-char *iInjectS(char **string, intmax_t index, char toInject);
-char *bInjectS(char *string, intmax_t index, char toInject);
-char *bLInjectS(char *string, size_t stringSize, intmax_t index, char toInject);
-char *delS(const char *string, intmax_t start, intmax_t end);
-char *iDelS(char **string, intmax_t start, intmax_t end);
-char *bDelS(char *string, intmax_t start, intmax_t end);
-char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end);
-char *delElemS(const char *string, intmax_t index);
-char *iDelElemS(char **string, intmax_t index);
-char *bDelElemS(char *string, intmax_t index);
-char *bLDelElemS(char *string, size_t stringSize, intmax_t index);
+char getS(const char *string, int64_t index);
+char *setS(char *string, int64_t index, char c);
+char *swapS(char *string, int64_t index1, int64_t index2);
+char *iSwapS(char **string, int64_t index1, int64_t index2);
+char *bSwapS(char *string, int64_t index1, int64_t index2);
+char *bLSwapS(char *string, size_t size, int64_t index1, int64_t index2);
+char *sliceS(const char *string, int64_t start, int64_t end);
+char *iSliceS(char **string, int64_t start, int64_t end);
+char *bSliceS(char *string, int64_t start, int64_t end);
+char *bLSliceS(char *string, size_t stringSize, int64_t start, int64_t end);
+char *cropS(char *string, int64_t start, int64_t end);
+char *iCropS(char **string, int64_t start, int64_t end);
+char cropElemS(char *string, int64_t index);
+char iCropElemS(char **string, int64_t index);
+char *insertS(const char *string, int64_t index, const char *toInsert);
+char *insertNFreeS(const char *string, int64_t index, char *toInsert);
+char *iInsertS(char **string, int64_t index, const char *toInsert);
+char *iInsertNFreeS(char **string, int64_t index, char *toInsert);
+char *bInsertS(char *string, int64_t index, const char *toInsert);
+char *bLInsertS(char *string, size_t stringSize, int64_t index, const char *toInsert);
+char *injectS(const char *string, int64_t index, char toInject);
+char *iInjectS(char **string, int64_t index, char toInject);
+char *bInjectS(char *string, int64_t index, char toInject);
+char *bLInjectS(char *string, size_t stringSize, int64_t index, char toInject);
+char *delS(const char *string, int64_t start, int64_t end);
+char *iDelS(char **string, int64_t start, int64_t end);
+char *bDelS(char *string, int64_t start, int64_t end);
+char *bLDelS(char *string, size_t stringSize, int64_t start, int64_t end);
+char *delElemS(const char *string, int64_t index);
+char *iDelElemS(char **string, int64_t index);
+char *bDelElemS(char *string, int64_t index);
+char *bLDelElemS(char *string, size_t stringSize, int64_t index);
 char *findS(const char *string, const char *needle);
 char *findCharS(const char *string, char c);
 ssize_t indexOfS(const char *string, const char *needle);
@@ -475,12 +474,12 @@ char *findNextUTF8(const char *string, size_t utf8Size, const char *utf8);
 char *prevUTF8(const char *utf8);
 char *bPrevUTF8(const char *string, const char *utf8);
 local char *bPrevUTF8Tiny(const char *string, const char *utf8);
-char *idx2PtrUTF8(const char *utf8, intmax_t index);
-char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index);
-intmax_t ptr2IdxUTF8(const char *utf8, const char *pos);
-intmax_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos);
-intmax_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
-intmax_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
+char *idx2PtrUTF8(const char *utf8, int64_t index);
+char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, int64_t index);
+int64_t ptr2IdxUTF8(const char *utf8, const char *pos);
+int64_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos);
+int64_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
+int64_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
 char *makeValidUTF8(const char *utf8);
 char *bMakeValidUTF8(char *utf8);
 char *nMakeValidUTF8(const char *utf8, size_t utf8Len);
@@ -507,13 +506,13 @@ char *icReplaceManyUTF8F(const char *paramType UNUSED, ...);
 char *iicReplaceManyUTF8F(char **s UNUSED, char *paramType UNUSED, ...);
 char *bicReplaceManyUTF8F(char *s UNUSED, char *paramType UNUSED, ...);
 char *bLicReplaceManyUTF8F(char *s UNUSED, size_t sSize UNUSED, char *paramType UNUSED, ...);
-bool eqIUTF8(const char *string1, const char *string2, intmax_t index);
-bool eqICharUTF8(const char *string1, char c, intmax_t index);
+bool eqIUTF8(const char *string1, const char *string2, int64_t index);
+bool eqICharUTF8(const char *string1, char c, int64_t index);
 bool icEqUTF8(const char *string1, const char *string2);
 bool icEqCharUTF8(char c, const char *string2);
 bool icEqUTF8Char(const char *string1, char c);
-bool icEqIUTF8(const char *string1 UNUSED, const char *string2 UNUSED, intmax_t index UNUSED);
-bool icEqICharUTF8(const char *string1 UNUSED, char c UNUSED, intmax_t index UNUSED);
+bool icEqIUTF8(const char *string1 UNUSED, const char *string2 UNUSED, int64_t index UNUSED);
+bool icEqICharUTF8(const char *string1 UNUSED, char c UNUSED, int64_t index UNUSED);
 bool icStartsWithUTF8(const char *string1, const char *string2);
 bool icEndsWithUTF8(const char *string1, const char *string2);
 ssize_t icCountUTF8(const char *s, const char *needle);
@@ -546,22 +545,22 @@ char *bUniqUTF8(char *string, const char *code);
 char *icUniqUTF8(const char *string UNUSED, const char *code UNUSED);
 char *iicUniqUTF8(char **string UNUSED, const char *code UNUSED);
 char *bicUniqUTF8(char *string UNUSED, char c UNUSED);
-rune getUTF8(const char *string, intmax_t index);
-char *setUTF8(char *string, intmax_t index, rune c);
-char *sliceUTF8(const char *string, intmax_t start, intmax_t end);
-char *iSliceUTF8(char **string, intmax_t start, intmax_t end);
-char *bSliceUTF8(char *string, intmax_t start, intmax_t end);
-char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end);
-char *insertUTF8(const char *string, intmax_t index, const char *toInsert);
-char *insertNFreeUTF8(const char *string, intmax_t index, char *toInsert);
-char *iInsertUTF8(char **string, intmax_t index, const char *toInsert);
-char *iInsertNFreeUTF8(char **string, intmax_t index, char *toInsert);
-char *bInsertUTF8(char *string, intmax_t index, const char *toInsert);
-char *bLInsertUTF8(char *string, size_t stringSize, intmax_t index, const char *toInsert);
-char *delUTF8(const char *string, intmax_t start, intmax_t end);
-char *iDelUTF8(char **string, intmax_t start, intmax_t end);
-char *bDelUTF8(char *string, intmax_t start, intmax_t end);
-char *bLDelUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end);
+rune getUTF8(const char *string, int64_t index);
+char *setUTF8(char *string, int64_t index, rune c);
+char *sliceUTF8(const char *string, int64_t start, int64_t end);
+char *iSliceUTF8(char **string, int64_t start, int64_t end);
+char *bSliceUTF8(char *string, int64_t start, int64_t end);
+char *bLSliceUTF8(char *string, size_t stringSize, int64_t start, int64_t end);
+char *insertUTF8(const char *string, int64_t index, const char *toInsert);
+char *insertNFreeUTF8(const char *string, int64_t index, char *toInsert);
+char *iInsertUTF8(char **string, int64_t index, const char *toInsert);
+char *iInsertNFreeUTF8(char **string, int64_t index, char *toInsert);
+char *bInsertUTF8(char *string, int64_t index, const char *toInsert);
+char *bLInsertUTF8(char *string, size_t stringSize, int64_t index, const char *toInsert);
+char *delUTF8(const char *string, int64_t start, int64_t end);
+char *iDelUTF8(char **string, int64_t start, int64_t end);
+char *bDelUTF8(char *string, int64_t start, int64_t end);
+char *bLDelUTF8(char *string, size_t stringSize, int64_t start, int64_t end);
 ssize_t indexOfUTF8(const char *string, const char *needle);
 ssize_t icIndexOfUTF8(const char *string UNUSED, const char *needle UNUSED);
 bool icHasUTF8(const char *string, const char *needle);
@@ -583,7 +582,7 @@ char *emptySF(void);
 char *iEmptySF(char **string);
 bool isEmptyS(const char *string);
 bool isBlankS(const char *string);
-ssize_t intIndex(intmax_t index, intmax_t length);
+ssize_t intIndex(int64_t index, int64_t length);
 char **listEmptySF(void);
 char **iListEmptySF(char ***list);
 bool listIsEmptyS(char **list);
@@ -602,15 +601,15 @@ void listFreeS(char **list);
 void listFreeManySF(char **paramType, ...);
 size_t listLengthS(char **list);
 ssize_t listStrLengthS(char **list);
-ssize_t listIntIndexS(char **list, intmax_t index);
-char **listAddrS(char **list, intmax_t index);
-char *listGetS(char **list, intmax_t index);
-char *iListGetS(char **list, intmax_t index);
-char **listSetS(char **list, intmax_t index, const char *s);
-char **listSetCharS(char **list, intmax_t index, char c);
-char **iListSetS(char **list, intmax_t index, char *s);
-char **listSwapS(char **list, intmax_t index1, intmax_t index2);
-char **iListSwapS(char **list, intmax_t index1, intmax_t index2);
+ssize_t listIntIndexS(char **list, int64_t index);
+char **listAddrS(char **list, int64_t index);
+char *listGetS(char **list, int64_t index);
+char *iListGetS(char **list, int64_t index);
+char **listSetS(char **list, int64_t index, const char *s);
+char **listSetCharS(char **list, int64_t index, char c);
+char **iListSetS(char **list, int64_t index, char *s);
+char **listSwapS(char **list, int64_t index1, int64_t index2);
+char **iListSwapS(char **list, int64_t index1, int64_t index2);
 char **split(const char *string, const char* delim);
 char **splitChar(const char *string, char delim);
 char **icSplit(const char *string, const char* delim);
@@ -642,26 +641,26 @@ char **listShiftS(char ***list1, char **list2);
 char **iListShiftS(char ***list1, char **list2);
 char **iListShiftNSmashS(char ***list1, char **list2);
 char **listAddS(char **list1, char **list2);
-char **listSliceS(char **list, intmax_t start, intmax_t end);
-char **iListCopyS(char **list, intmax_t start, intmax_t end);
-char **iListSliceS(char ***list, intmax_t start, intmax_t end);
-char **listCropS(char **list, intmax_t start, intmax_t end);
-char **iListCropS(char ***list, intmax_t start, intmax_t end);
-char *listCropElemS(char **list, intmax_t index);
-char *iListCropElemS(char ***list, intmax_t index);
-char **listInsertS(char **list, intmax_t index, char **toInsert);
-char **iListInsertS(char ***list, intmax_t index, char **toInsert);
-char **iListInsertNFreeS(char ***list, intmax_t index, char **toInsert);
-char **listInjectS(char **list, intmax_t index, char *toInject);
-char **listInjectCharS(char **list, intmax_t index, char toInject);
-char **iListInjectS(char ***list, intmax_t index, char *toInject);
-char **iListInjectCharS(char ***list, intmax_t index, char toInject);
-char **listDelS(char **list, intmax_t start, intmax_t end);
-char **iListDelS(char ***list, intmax_t start, intmax_t end);
-char **iListRemoveS(char ***list, intmax_t start, intmax_t end);
-char **listDelElemS(char **list, intmax_t index);
-char **iListDelElemS(char ***list, intmax_t index);
-char **iListRemoveElemS(char ***list, intmax_t index);
+char **listSliceS(char **list, int64_t start, int64_t end);
+char **iListCopyS(char **list, int64_t start, int64_t end);
+char **iListSliceS(char ***list, int64_t start, int64_t end);
+char **listCropS(char **list, int64_t start, int64_t end);
+char **iListCropS(char ***list, int64_t start, int64_t end);
+char *listCropElemS(char **list, int64_t index);
+char *iListCropElemS(char ***list, int64_t index);
+char **listInsertS(char **list, int64_t index, char **toInsert);
+char **iListInsertS(char ***list, int64_t index, char **toInsert);
+char **iListInsertNFreeS(char ***list, int64_t index, char **toInsert);
+char **listInjectS(char **list, int64_t index, char *toInject);
+char **listInjectCharS(char **list, int64_t index, char toInject);
+char **iListInjectS(char ***list, int64_t index, char *toInject);
+char **iListInjectCharS(char ***list, int64_t index, char toInject);
+char **listDelS(char **list, int64_t start, int64_t end);
+char **iListDelS(char ***list, int64_t start, int64_t end);
+char **iListRemoveS(char ***list, int64_t start, int64_t end);
+char **listDelElemS(char **list, int64_t index);
+char **iListDelElemS(char ***list, int64_t index);
+char **iListRemoveElemS(char ***list, int64_t index);
 int listPrintS(char **list);
 internal int listSortSCmp(const void * a, const void * b);
 char **listSortS(char **list);
@@ -721,20 +720,20 @@ void *listDequeue(void ***list);
 void listFree(void **list);
 void listFreeManyF(void **paramType, ...);
 size_t listLength(void **list);
-void *listGet(void **list, intmax_t index);
-void **listSet(void **list, intmax_t index, void *s);
+void *listGet(void **list, int64_t index);
+void **listSet(void **list, int64_t index, void *s);
 void **listDup(void **list);
 void **listReverse(void **list);
 void **iListReverse(void ***list);
 void **listCatF(void **paramType, ...);
 void **listAppend(void ***list1, void **list2);
 void **listAdd(void **list1, void **list2);
-void **listSlice(void **list, intmax_t start, intmax_t end);
-void **iListSlice(void ***list, intmax_t start, intmax_t end);
-void **listInsert(void **list, intmax_t index, void **toInsert);
-void **iListInsert(void ***list, intmax_t index, void **toInsert);
-void **listDel(void **list, intmax_t start, intmax_t end);
-void **iListDel(void ***list, intmax_t start, intmax_t end);
+void **listSlice(void **list, int64_t start, int64_t end);
+void **iListSlice(void ***list, int64_t start, int64_t end);
+void **listInsert(void **list, int64_t index, void **toInsert);
+void **iListInsert(void ***list, int64_t index, void **toInsert);
+void **listDel(void **list, int64_t start, int64_t end);
+void **iListDel(void ***list, int64_t start, int64_t end);
 int ringInit(void *ring, int maxCount);
 int ringEmpty(void *ring);
 int ringIsEmpty(void *ring);
@@ -9009,14 +9008,14 @@ bool eqSChar(const char *string1, char c) {
  *   true string1 at index is equal to string2
  *   false they differ
  */
-bool eqIS(const char *string1, const char *string2, intmax_t index) {
+bool eqIS(const char *string1, const char *string2, int64_t index) {
 
   // sanity checks
   if (!string1 || !string2) {
     return(false);
   }
 
-  intmax_t len = strlen(string1);
+  int64_t len = strlen(string1);
   if (index >= len && len) {
     // && len: string1 is empty, check below if string2 is also empty
     // when string1 and string2 are empty and index is 0, the result is true
@@ -9029,7 +9028,7 @@ bool eqIS(const char *string1, const char *string2, intmax_t index) {
     index = len + index;
   }
 
-  intmax_t len2 = (intmax_t)strlen(string2);
+  int64_t len2 = (int64_t)strlen(string2);
   if (!len2 && !len && !index) {
     // string1 and string2 are empty and index is 0
     return(true);
@@ -9044,7 +9043,7 @@ bool eqIS(const char *string1, const char *string2, intmax_t index) {
   return(strncmp(string1 + index, string2, len2) == 0);;
 }
 
-bool eqICharS(const char *string1, char c, intmax_t index) {
+bool eqICharS(const char *string1, char c, int64_t index) {
 
   charToS(s,c);
   return(eqIS(string1, s, index));
@@ -9225,14 +9224,14 @@ bool icEqSChar(const char *string1, char c) {
  *   true string1 at index is equal to string2
  *   false they differ
  */
-bool icEqIS(const char *string1, const char *string2, intmax_t index) {
+bool icEqIS(const char *string1, const char *string2, int64_t index) {
 
   // sanity checks
   if (!string1 || !string2) {
     return(false);
   }
 
-  intmax_t len = strlen(string1);
+  int64_t len = strlen(string1);
   if (index >= len && len) {
     // && len: string1 is empty, check below if string2 is also empty
     // when string1 and string2 are empty and index is 0, the result is true
@@ -9245,7 +9244,7 @@ bool icEqIS(const char *string1, const char *string2, intmax_t index) {
     index = len + index;
   }
 
-  intmax_t len2 = (intmax_t)strlen(string2);
+  int64_t len2 = (int64_t)strlen(string2);
   if (!len2 && !len && !index) {
     // string1 and string2 are empty and index is 0
     return(true);
@@ -9260,7 +9259,7 @@ bool icEqIS(const char *string1, const char *string2, intmax_t index) {
   return(strncasecmp(string1 + index, string2, len2) == 0);;
 }
 
-bool icEqICharS(const char *string1, char c, intmax_t index) {
+bool icEqICharS(const char *string1, char c, int64_t index) {
 
   charToS(s,c);
   return(icEqIS(string1, s, index));
@@ -9608,10 +9607,10 @@ bool isInt(const char *string) {
  * \param
  *   string
  * \return
- *   intmax_t
+ *   int64_t
  *   0 when string represents 0 or doesnt represent a number or the input is NULL
  */
-intmax_t parseInt(const char *string) {
+int64_t parseInt(const char *string) {
 
   // sanity checks
   if (!string) {
@@ -9620,15 +9619,15 @@ intmax_t parseInt(const char *string) {
   while (!isdigit(*string) && *string != '-' && *string != 0) {
     string++;
   }
-  intmax_t r = strtoimax(string, NULL, 10);
-  if (r == INTMAX_MAX || r == INTMAX_MIN) {
+  int64_t r = strtoll(string, NULL, 10);
+  if (r == INT64_MAX || r == INT64_MIN) {
     pFuncError
     shEPrintfS("The string was: \"%s\"\n", string);
   }
   return(r);
 }
 
-intmax_t parseIntChar(char c) {
+int64_t parseIntChar(char c) {
 
   if (!isdigit(c)) {
     return(-1);
@@ -9735,7 +9734,7 @@ uint64_t parseHex(const char *string) {
  * \return
  *   string representing the number (you must free the pointer)
  */
-char *intToS(intmax_t n) {
+char *intToS(int64_t n) {
   char s[50];
   char *r = NULL;
 
@@ -9754,7 +9753,7 @@ char *intToS(intmax_t n) {
  * \return
  *   string representing the number
  */
-char *bIntToS(char *s, intmax_t n) {
+char *bIntToS(char *s, int64_t n) {
 
   if (!s) {
     return(NULL);
@@ -12541,8 +12540,8 @@ ssize_t padEndLenS(const char *string, size_t targetLength, const char *padStrin
  * get char at python index
  *
  */
-char getS(const char *string, intmax_t index) {
-  intmax_t len;
+char getS(const char *string, int64_t index) {
+  int64_t len;
 
   if (!string) {
     return(0);
@@ -12567,8 +12566,8 @@ char getS(const char *string, intmax_t index) {
  *
  * set char at python index
  */
-char *setS(char *string, intmax_t index, char c) {
-  intmax_t len;
+char *setS(char *string, int64_t index, char c) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -12602,8 +12601,8 @@ char *setS(char *string, intmax_t index, char c) {
  * new string with characters swapped at index1 and index2 (you must free this pointer)
  * NULL when string is NULL or when index1 or index2 are outside the string
  */
-char *swapS(char *string, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char *swapS(char *string, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -12652,8 +12651,8 @@ char *swapS(char *string, intmax_t index1, intmax_t index2) {
  * updated string with characters swapped at index1 and index2 (you must free this pointer)
  * NULL when string is NULL or when index1 or index2 are outside the string
  */
-char *iSwapS(char **string, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char *iSwapS(char **string, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!string or !*string) {
     return(NULL);
@@ -12700,8 +12699,8 @@ char *iSwapS(char **string, intmax_t index1, intmax_t index2) {
  * string with characters swapped at index1 and index2
  * NULL when string is NULL or when index1 or index2 are outside the string
  */
-char *bSwapS(char *string, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char *bSwapS(char *string, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -12753,8 +12752,8 @@ char *bSwapS(char *string, intmax_t index1, intmax_t index2) {
  * string with characters swapped at index1 and index2
  * NULL when string is NULL or when index1 or index2 are outside the string
   */
-char *bLSwapS(char *string, size_t size, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char *bLSwapS(char *string, size_t size, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -12814,9 +12813,9 @@ char *bLSwapS(char *string, size_t size, intmax_t index1, intmax_t index2) {
  *   "" when start=end
  *   NULL when start and end are not set correctly
  */
-char *sliceS(const char *string, intmax_t start, intmax_t end) {
+char *sliceS(const char *string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -12852,7 +12851,7 @@ char *sliceS(const char *string, intmax_t start, intmax_t end) {
   else {
     // start < end < len
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = end - start;
     s = MALLOC(n+1);
     if (!s) {
@@ -12879,9 +12878,9 @@ char *sliceS(const char *string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *iSliceS(char **string, intmax_t start, intmax_t end) {
+char *iSliceS(char **string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -12923,7 +12922,7 @@ char *iSliceS(char **string, intmax_t start, intmax_t end) {
   else {
     // start < end < len
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = end - start;
     s = MALLOC(n+1);
     if (!s) {
@@ -12952,8 +12951,8 @@ char *iSliceS(char **string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *bSliceS(char *string, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bSliceS(char *string, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -12992,7 +12991,7 @@ char *bSliceS(char *string, intmax_t start, intmax_t end) {
   else {
     // start < end < len
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = end - start;
     if (start) {
       strncpy(string, string+start, n);
@@ -13021,8 +13020,8 @@ char *bSliceS(char *string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bLSliceS(char *string, size_t stringSize, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -13066,7 +13065,7 @@ char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
   else {
     // start < end < len
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = end - start;
     if (start) {
       strncpy(string, string+start, n);
@@ -13096,9 +13095,9 @@ char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char *cropS(char *string, intmax_t start, intmax_t end) {
+char *cropS(char *string, int64_t start, int64_t end) {
   char *l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13131,7 +13130,7 @@ char *cropS(char *string, intmax_t start, intmax_t end) {
 
   if (start < end) {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char));
     if (!l) {
@@ -13167,9 +13166,9 @@ char *cropS(char *string, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char *iCropS(char **string, intmax_t start, intmax_t end) {
+char *iCropS(char **string, int64_t start, int64_t end) {
   char *l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -13202,7 +13201,7 @@ char *iCropS(char **string, intmax_t start, intmax_t end) {
 
   if (start < end) {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char));
     if (!l) {
@@ -13219,8 +13218,8 @@ char *iCropS(char **string, intmax_t start, intmax_t end) {
   return(l);
 }
 
-char cropElemS(char *string, intmax_t index) {
-  intmax_t len;
+char cropElemS(char *string, int64_t index) {
+  int64_t len;
 
   if (!string) {
     return(0);
@@ -13249,7 +13248,7 @@ char cropElemS(char *string, intmax_t index) {
   return(r);
 }
 
-char iCropElemS(char **string, intmax_t index) {
+char iCropElemS(char **string, int64_t index) {
 
   if (!string) {
     return(0);
@@ -13275,9 +13274,9 @@ char iCropElemS(char **string, intmax_t index) {
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *insertS(const char *string, intmax_t index, const char *toInsert) {
+char *insertS(const char *string, int64_t index, const char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13344,9 +13343,9 @@ char *insertS(const char *string, intmax_t index, const char *toInsert) {
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *insertNFreeS(const char *string, intmax_t index, char *toInsert) {
+char *insertNFreeS(const char *string, int64_t index, char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13422,9 +13421,9 @@ char *insertNFreeS(const char *string, intmax_t index, char *toInsert) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInsertS(char **string, intmax_t index, const char *toInsert) {
+char *iInsertS(char **string, int64_t index, const char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13501,9 +13500,9 @@ char *iInsertS(char **string, intmax_t index, const char *toInsert) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInsertNFreeS(char **string, intmax_t index, char *toInsert) {
+char *iInsertNFreeS(char **string, int64_t index, char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13583,8 +13582,8 @@ char *iInsertNFreeS(char **string, intmax_t index, char *toInsert) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bInsertS(char *string, intmax_t index, const char *toInsert) {
-  intmax_t len;
+char *bInsertS(char *string, int64_t index, const char *toInsert) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13652,8 +13651,8 @@ char *bInsertS(char *string, intmax_t index, const char *toInsert) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bLInsertS(char *string, size_t stringSize, intmax_t index, const char *toInsert) {
-  intmax_t len;
+char *bLInsertS(char *string, size_t stringSize, int64_t index, const char *toInsert) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13727,9 +13726,9 @@ char *bLInsertS(char *string, size_t stringSize, intmax_t index, const char *toI
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *injectS(const char *string, intmax_t index, char toInject) {
+char *injectS(const char *string, int64_t index, char toInject) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13797,9 +13796,9 @@ char *injectS(const char *string, intmax_t index, char toInject) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInjectS(char **string, intmax_t index, char toInject) {
+char *iInjectS(char **string, int64_t index, char toInject) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13874,8 +13873,8 @@ char *iInjectS(char **string, intmax_t index, char toInject) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bInjectS(char *string, intmax_t index, char toInject) {
-  intmax_t len;
+char *bInjectS(char *string, int64_t index, char toInject) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13940,8 +13939,8 @@ char *bInjectS(char *string, intmax_t index, char toInject) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bLInjectS(char *string, size_t stringSize, intmax_t index, char toInject) {
-  intmax_t len;
+char *bLInjectS(char *string, size_t stringSize, int64_t index, char toInject) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -14011,9 +14010,9 @@ char *bLInjectS(char *string, size_t stringSize, intmax_t index, char toInject) 
  *   new identical string when start=end or when start and end are not set correctly
  *   NULL when input string is NULL or when malloc failed or when end is under start
  */
-char *delS(const char *string, intmax_t start, intmax_t end) {
+char *delS(const char *string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -14050,7 +14049,7 @@ char *delS(const char *string, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = end - start;
   s = MALLOC(len-n+1);
   if (!s) {
@@ -14081,9 +14080,9 @@ char *delS(const char *string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *iDelS(char **string, intmax_t start, intmax_t end) {
+char *iDelS(char **string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -14120,7 +14119,7 @@ char *iDelS(char **string, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = end - start;
   s = MALLOC(len-n+1);
   if (!s) {
@@ -14153,8 +14152,8 @@ char *iDelS(char **string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *bDelS(char *string, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bDelS(char *string, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -14191,7 +14190,7 @@ char *bDelS(char *string, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = end - start;
   strncpy(string+start, string+start+n, len-n-start);
   string[len-n] = 0;
@@ -14219,8 +14218,8 @@ char *bDelS(char *string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bLDelS(char *string, size_t stringSize, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -14233,16 +14232,16 @@ char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
   }
 
   // compute string length without NUL
-  if (start >= (intmax_t)len) {
+  if (start >= (int64_t)len) {
     start = len;
   }
-  if (end > (intmax_t)len) {
+  if (end > (int64_t)len) {
     end = len;
   }
-  if (start <= -(intmax_t)len) {
+  if (start <= -(int64_t)len) {
     start = -len;
   }
-  if (end <= -(intmax_t)len) {
+  if (end <= -(int64_t)len) {
     end = -len;
   }
   if (start < 0) {
@@ -14261,7 +14260,7 @@ char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = end - start;
   strncpy(string+start, string+start+n, len-n-start);
   string[len-n] = 0;
@@ -14283,9 +14282,9 @@ char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
  *   new string (you must free the pointer)
  *   NULL when input string is NULL or when malloc failed
  */
-char *delElemS(const char *string, intmax_t index) {
+char *delElemS(const char *string, int64_t index) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -14326,9 +14325,9 @@ char *delElemS(const char *string, intmax_t index) {
  *   new string (you must free the pointer)
  *   NULL when input string is NULL or when malloc failed
  */
-char *iDelElemS(char **string, intmax_t index) {
+char *iDelElemS(char **string, int64_t index) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -14373,8 +14372,8 @@ char *iDelElemS(char **string, intmax_t index) {
  *   string with one less character
  *   NULL when input string is NULL or when malloc failed
  */
-char *bDelElemS(char *string, intmax_t index) {
-  intmax_t len;
+char *bDelElemS(char *string, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -14414,8 +14413,8 @@ char *bDelElemS(char *string, intmax_t index) {
  *   string with one less character
  *   NULL when input string is NULL or when malloc failed
  */
-char *bLDelElemS(char *string, size_t stringSize, intmax_t index) {
-  intmax_t len;
+char *bLDelElemS(char *string, size_t stringSize, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -14428,14 +14427,14 @@ char *bLDelElemS(char *string, size_t stringSize, intmax_t index) {
   }
 
   // compute string length without NUL
-  if (index >= (intmax_t)len) {
+  if (index >= (int64_t)len) {
     return(NULL);
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (index < 0) {
-    index = (intmax_t)len + index;
+    index = (int64_t)len + index;
   }
 
   strncpy(string+index, string+index+1, len-1-index);
@@ -44865,13 +44864,13 @@ local char *bPrevUTF8Tiny(const char *string, const char *utf8) {
  *   pointer to character at index
  *   NULL when index is outside the string
  */
-char *idx2PtrUTF8(const char *utf8, intmax_t index) {
+char *idx2PtrUTF8(const char *utf8, int64_t index) {
 
   if (!utf8 || !*utf8 || !index) {
     return((char *)utf8);
   }
 
-  intmax_t len = strlen(utf8);
+  int64_t len = strlen(utf8);
 
   if (index > 0) {
     if (index > len) {
@@ -44881,7 +44880,7 @@ char *idx2PtrUTF8(const char *utf8, intmax_t index) {
 
     // go forward
     char *end = (char *)utf8 + len;;
-    intmax_t i = 0;;
+    int64_t i = 0;;
     while (i != index) {
       nxCodeUTF8(utf8);
       if (utf8 > end) {
@@ -44899,7 +44898,7 @@ char *idx2PtrUTF8(const char *utf8, intmax_t index) {
     // go from the end
     char *start = (char *)utf8;;
     utf8 += len;;
-    intmax_t i = 0;;
+    int64_t i = 0;;
     while (i != index) {
       utf8 = bPrevUTF8Tiny(start, utf8);;
       i--;
@@ -44908,7 +44907,7 @@ char *idx2PtrUTF8(const char *utf8, intmax_t index) {
   return((char *)utf8);
 }
 
-char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
+char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, int64_t index) {
 
   if (!utf8 || !*utf8 || !utf8Size || !index) {
     return((char *)utf8);
@@ -44922,7 +44921,7 @@ char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
 
     // go forward
     char *end = (char *)utf8 + utf8Size;;
-    intmax_t i = 0;;
+    int64_t i = 0;;
     while (i != index) {
       nxCodeUTF8(utf8);
       if (utf8 >= end) {
@@ -44932,7 +44931,7 @@ char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
   }
     }
   else {
-    if (index < -(intmax_t)utf8Size) {
+    if (index < -(int64_t)utf8Size) {
       // index is outside the string
       return(NULL);
     }
@@ -44947,7 +44946,7 @@ char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
     // go from the end
     char *start = (char *)utf8;;
     utf8 += len;;
-    intmax_t i = 0;;
+    int64_t i = 0;;
     while (i != index) {
       utf8 = bPrevUTF8Tiny(start, utf8);;
       i--;
@@ -44973,13 +44972,13 @@ char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
  *   When pos < utf8, the result is negative
  *   0 failed or index 0
  */
-intmax_t ptr2IdxUTF8(const char *utf8, const char *pos) {
+int64_t ptr2IdxUTF8(const char *utf8, const char *pos) {
 
   if (!utf8 || !pos || utf8 == pos) {
     return(0);
   }
 
-  intmax_t r = 0;
+  int64_t r = 0;
 
   if (pos > utf8) {
     // there is at least one code point
@@ -45046,13 +45045,13 @@ intmax_t ptr2IdxUTF8(const char *utf8, const char *pos) {
  *   When pos < utf8, the result is negative
  *   0 failed or index 0
  */
-intmax_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos) {
+int64_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos) {
 
   if (!utf8 || !pos || utf8 == pos || !start || pos < start) {
     return(0);
   }
 
-  intmax_t r = 0;
+  int64_t r = 0;
 
   if (pos > utf8) {
     // there is at least one code point
@@ -45107,13 +45106,13 @@ intmax_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos) {
  *   Number of code points from utf8 to pos, positive
  *   -1 failed
  */
-intmax_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
+int64_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
 
   if (!utf8 || !utf8Size || !pos || (pos < utf8) || (pos >= (utf8+utf8Size))) {
     return(-1);
   }
 
-  intmax_t r = 0;
+  int64_t r = 0;
 
   // return 0 if utf8 = pos
   if (pos > utf8) {
@@ -45158,13 +45157,13 @@ intmax_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
  *   Number of code points from utf8 end to pos, negative
  *   0 failed
  */
-intmax_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
+int64_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
 
   if (!utf8 || !utf8Size || !pos || (pos < utf8) || (pos >= (utf8+utf8Size))) {
     return(0);
   }
 
-  intmax_t r = 0;
+  int64_t r = 0;
 
   char *end = (char *)(utf8+utf8Size-1);
 
@@ -45914,24 +45913,24 @@ char *bLicReplaceManyUTF8F(char *s UNUSED, size_t sSize UNUSED, char *paramType 
  *   true string1 at index is equal to string2
  *   false they differ
  */
-bool eqIUTF8(const char *string1, const char *string2, intmax_t index) {
+bool eqIUTF8(const char *string1, const char *string2, int64_t index) {
 
   if (!string1) {
     return(false);
   }
 
   char *i = idx2PtrUTF8(string1, index);
-  return(eqIS(string1, string2, (intmax_t)(i-string1)));
+  return(eqIS(string1, string2, (int64_t)(i-string1)));
 }
 
-bool eqICharUTF8(const char *string1, char c, intmax_t index) {
+bool eqICharUTF8(const char *string1, char c, int64_t index) {
 
   if (!string1) {
     return(false);
   }
 
   char *i = idx2PtrUTF8(string1, index);
-  return(eqICharS(string1, c, (intmax_t)(i-string1)));
+  return(eqICharS(string1, c, (int64_t)(i-string1)));
 }
 
 
@@ -45998,13 +45997,13 @@ bool icEqUTF8Char(const char *string1, char c) {
  *   true string1 at index is equal to string2
  *   false they differ
  */
-bool icEqIUTF8(const char *string1 UNUSED, const char *string2 UNUSED, intmax_t index UNUSED) {
+bool icEqIUTF8(const char *string1 UNUSED, const char *string2 UNUSED, int64_t index UNUSED) {
 
   // TODO casefold changes the number of character, index might change
   return(false);
 }
 
-bool icEqICharUTF8(const char *string1 UNUSED, char c UNUSED, intmax_t index UNUSED) {
+bool icEqICharUTF8(const char *string1 UNUSED, char c UNUSED, int64_t index UNUSED) {
 
   // TODO casefold changes the number of character, index might change
   return(false);
@@ -47162,8 +47161,8 @@ char *bicUniqUTF8(char *string UNUSED, char c UNUSED) {
  * get char at python index
  *
  */
-rune getUTF8(const char *string, intmax_t index) {
-  intmax_t len;
+rune getUTF8(const char *string, int64_t index) {
+  int64_t len;
 
   if (!string) {
     return(0);
@@ -47193,8 +47192,8 @@ rune getUTF8(const char *string, intmax_t index) {
  * TODO this function might make the string invalid UTF8
  *      check codeSizeUTF8 and adjust the buffer
  */
-char *setUTF8(char *string, intmax_t index, rune c) {
-  intmax_t len;
+char *setUTF8(char *string, int64_t index, rune c) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -47236,9 +47235,9 @@ char *setUTF8(char *string, intmax_t index, rune c) {
  *   "" when start=end
  *   NULL when start and end are not set correctly
  */
-char *sliceUTF8(const char *string, intmax_t start, intmax_t end) {
+char *sliceUTF8(const char *string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47277,7 +47276,7 @@ char *sliceUTF8(const char *string, intmax_t start, intmax_t end) {
     // copy range to a new string
     const char *startp = idx2PtrUTF8(string, start);
     const char *endp   = idx2PtrUTF8(string, end);
-    intmax_t n;
+    int64_t n;
     n = endp - startp;
     s = MALLOC(n+1);
     if (!s) {
@@ -47307,9 +47306,9 @@ char *sliceUTF8(const char *string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *iSliceUTF8(char **string, intmax_t start, intmax_t end) {
+char *iSliceUTF8(char **string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -47354,7 +47353,7 @@ char *iSliceUTF8(char **string, intmax_t start, intmax_t end) {
     // copy range to a new string
     char *startp = idx2PtrUTF8(*string, start);
     char *endp   = idx2PtrUTF8(*string, end);
-    intmax_t n;
+    int64_t n;
     n = endp - startp;
     s = MALLOC(n+1);
     if (!s) {
@@ -47386,8 +47385,8 @@ char *iSliceUTF8(char **string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *bSliceUTF8(char *string, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bSliceUTF8(char *string, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47429,7 +47428,7 @@ char *bSliceUTF8(char *string, intmax_t start, intmax_t end) {
     // copy range to a new string
     char *startp = idx2PtrUTF8(string, start);
     char *endp   = idx2PtrUTF8(string, end);
-    intmax_t n;
+    int64_t n;
     n = endp - startp;
     strncpy(string, string+(size_t)(startp-string), n);
     string[n] = 0;
@@ -47457,8 +47456,8 @@ char *bSliceUTF8(char *string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bLSliceUTF8(char *string, size_t stringSize, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -47524,7 +47523,7 @@ char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end)
   else {
     // start < end < stringSize
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = endp - startp;
     strncpy(string, string+starto, n);
     string[n] = 0;
@@ -47551,9 +47550,9 @@ char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end)
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *insertUTF8(const char *string, intmax_t index, const char *toInsert) {
+char *insertUTF8(const char *string, int64_t index, const char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47624,9 +47623,9 @@ char *insertUTF8(const char *string, intmax_t index, const char *toInsert) {
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *insertNFreeUTF8(const char *string, intmax_t index, char *toInsert) {
+char *insertNFreeUTF8(const char *string, int64_t index, char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47705,9 +47704,9 @@ char *insertNFreeUTF8(const char *string, intmax_t index, char *toInsert) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInsertUTF8(char **string, intmax_t index, const char *toInsert) {
+char *iInsertUTF8(char **string, int64_t index, const char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47786,9 +47785,9 @@ char *iInsertUTF8(char **string, intmax_t index, const char *toInsert) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInsertNFreeUTF8(char **string, intmax_t index, char *toInsert) {
+char *iInsertNFreeUTF8(char **string, int64_t index, char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47870,8 +47869,8 @@ char *iInsertNFreeUTF8(char **string, intmax_t index, char *toInsert) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bInsertUTF8(char *string, intmax_t index, const char *toInsert) {
-  intmax_t len;
+char *bInsertUTF8(char *string, int64_t index, const char *toInsert) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47942,8 +47941,8 @@ char *bInsertUTF8(char *string, intmax_t index, const char *toInsert) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bLInsertUTF8(char *string, size_t stringSize, intmax_t index, const char *toInsert) {
-  intmax_t len;
+char *bLInsertUTF8(char *string, size_t stringSize, int64_t index, const char *toInsert) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -48019,9 +48018,9 @@ char *bLInsertUTF8(char *string, size_t stringSize, intmax_t index, const char *
  *   new identical string when start=end or when start and end are not set correctly
  *   NULL when input string is NULL or when malloc failed or when end is under start
  */
-char *delUTF8(const char *string, intmax_t start, intmax_t end) {
+char *delUTF8(const char *string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -48062,7 +48061,7 @@ char *delUTF8(const char *string, intmax_t start, intmax_t end) {
   const char *startp = idx2PtrUTF8(string, start);
   const char *endp   = idx2PtrUTF8(string, end);
   size_t starto      = (size_t)(startp-string);
-  intmax_t n;
+  int64_t n;
   n = endp - startp;
   s = MALLOC(len-n+1);
   if (!s) {
@@ -48094,9 +48093,9 @@ char *delUTF8(const char *string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *iDelUTF8(char **string, intmax_t start, intmax_t end) {
+char *iDelUTF8(char **string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -48137,7 +48136,7 @@ char *iDelUTF8(char **string, intmax_t start, intmax_t end) {
   char *startp  = idx2PtrUTF8(*string, start);
   char *endp    = idx2PtrUTF8(*string, end);
   size_t starto = (size_t)(startp-*string);
-  intmax_t n;
+  int64_t n;
   n = endp - startp;
   s = MALLOC(len-n+1);
   if (!s) {
@@ -48171,8 +48170,8 @@ char *iDelUTF8(char **string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *bDelUTF8(char *string, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bDelUTF8(char *string, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -48213,7 +48212,7 @@ char *bDelUTF8(char *string, intmax_t start, intmax_t end) {
   const char *startp = idx2PtrUTF8(string, start);
   const char *endp   = idx2PtrUTF8(string, end);
   size_t starto      = (size_t)(startp-string);
-  intmax_t n;
+  int64_t n;
   n = endp - startp;
   strncpy(string+starto, string+starto+n, len-n-starto);
   string[len-n] = 0;
@@ -48242,8 +48241,8 @@ char *bDelUTF8(char *string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *bLDelUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bLDelUTF8(char *string, size_t stringSize, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -48303,7 +48302,7 @@ char *bLDelUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = endp - startp;
   strncpy(string+starto, string+starto+n, len-n-starto);
   string[len-n] = 0;
@@ -48874,7 +48873,7 @@ bool isBlankS(const char *string) {
  *   positive index
  *   -1 when length is 0 or index is not set correctly
  */
-ssize_t intIndex(intmax_t index, intmax_t length) {
+ssize_t intIndex(int64_t index, int64_t length) {
   ssize_t  r;
 
   // sanity checks
@@ -49418,9 +49417,9 @@ ssize_t listStrLengthS(char **list) {
  *   positive index
  *   -1 when list is NULL or index is not set correctly
  */
-ssize_t listIntIndexS(char **list, intmax_t index) {
+ssize_t listIntIndexS(char **list, int64_t index) {
   ssize_t  r;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -49455,9 +49454,9 @@ ssize_t listIntIndexS(char **list, intmax_t index) {
  *   pointer to char* at index
  *   NULL when list is NULL or index is not set correctly
  */
-char **listAddrS(char **list, intmax_t index) {
+char **listAddrS(char **list, int64_t index) {
   size_t  r;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -49493,8 +49492,8 @@ char **listAddrS(char **list, intmax_t index) {
  *   duplicated string (you must free the pointer)
  *   NULL when list is NULL or index is not set correctly
  */
-char *listGetS(char **list, intmax_t index) {
-  intmax_t len;
+char *listGetS(char **list, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -49527,8 +49526,8 @@ char *listGetS(char **list, intmax_t index) {
  *   string
  *   NULL when list is NULL or index is not set correctly
  */
-char *iListGetS(char **list, intmax_t index) {
-  intmax_t len;
+char *iListGetS(char **list, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -49567,8 +49566,8 @@ char *iListGetS(char **list, intmax_t index) {
  * Does nothing when:
  * when list is NULL, index is not set correctly or s is NULL
  */
-char **listSetS(char **list, intmax_t index, const char *s) {
-  intmax_t len;
+char **listSetS(char **list, int64_t index, const char *s) {
+  int64_t len;
 
   // sanity checks
   if (!list || !s) {
@@ -49591,7 +49590,7 @@ char **listSetS(char **list, intmax_t index, const char *s) {
   return(list);
 }
 
-char **listSetCharS(char **list, intmax_t index, char c) {
+char **listSetCharS(char **list, int64_t index, char c) {
 
   charToS(s, c);
   return(listSetS(list, index, s));
@@ -49615,8 +49614,8 @@ char **listSetCharS(char **list, intmax_t index, char c) {
  * Does nothing when:
  * when list is NULL, index is not set correctly or s is NULL
  */
-char **iListSetS(char **list, intmax_t index, char *s) {
-  intmax_t len;
+char **iListSetS(char **list, int64_t index, char *s) {
+  int64_t len;
 
   // sanity checks
   if (!list || !s) {
@@ -49652,8 +49651,8 @@ char **iListSetS(char **list, intmax_t index, char *s) {
  * new list with elements swapped at index1 and index2 (you must free this pointer)
  * NULL when list is NULL or when index1 or index2 are outside the list
  */
-char **listSwapS(char **list, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char **listSwapS(char **list, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!list) {
     return(NULL);
@@ -49702,8 +49701,8 @@ char **listSwapS(char **list, intmax_t index1, intmax_t index2) {
  * updated list with characters swapped at index1 and index2 (you must free this pointer)
  * NULL when list is NULL or when index1 or index2 are outside the list
  */
-char **iListSwapS(char **list, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char **iListSwapS(char **list, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!list) {
     return(NULL);
@@ -50670,9 +50669,9 @@ char **listAddS(char **list1, char **list2) {
  *   NULL when list is empty
  *   NULL when list is NULL or when start and end are not set correctly
  */
-char **listSliceS(char **list, intmax_t start, intmax_t end) {
+char **listSliceS(char **list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -50710,13 +50709,13 @@ char **listSliceS(char **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((n+1) * sizeof(char *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < n;i++) {
+  for (int64_t i=0;i < n;i++) {
     l[i] = strdup(*(list+start+i));
   }
   l[n] = NULL;
@@ -50743,9 +50742,9 @@ char **listSliceS(char **list, intmax_t start, intmax_t end) {
  *   NULL when list is empty
  *   NULL when list is NULL or when start and end are not set correctly
  */
-char **iListCopyS(char **list, intmax_t start, intmax_t end) {
+char **iListCopyS(char **list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -50783,13 +50782,13 @@ char **iListCopyS(char **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((n+1) * sizeof(char *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < n;i++) {
+  for (int64_t i=0;i < n;i++) {
     l[i] = *(list+start+i);
   }
   l[n] = NULL;
@@ -50814,9 +50813,9 @@ char **iListCopyS(char **list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char **iListSliceS(char ***list, intmax_t start, intmax_t end) {
+char **iListSliceS(char ***list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -50861,22 +50860,22 @@ char **iListSliceS(char ***list, intmax_t start, intmax_t end) {
   }
   else {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char *));
     if (!l) {
       return(NULL);
     }
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       l[i] = *((*list)+start+i);
     }
     l[n] = NULL;
     // free 0 < start
-    for (intmax_t i=0;i < start;i++) {
+    for (int64_t i=0;i < start;i++) {
       free((*list)[i]);
     }
     // free end < len
-    for (intmax_t i=end;i < len;i++) {
+    for (int64_t i=end;i < len;i++) {
       free((*list)[i]);
     }
     free(*list);
@@ -50908,9 +50907,9 @@ char **iListSliceS(char ***list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char **listCropS(char **list, intmax_t start, intmax_t end) {
+char **listCropS(char **list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -50948,18 +50947,18 @@ char **listCropS(char **list, intmax_t start, intmax_t end) {
   }
   else {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char *));
     if (!l) {
       return(NULL);
     }
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       l[i] = *(list+start+i);
     }
     l[n] = NULL;
     // free end < len
-    for (intmax_t i=0;i < (len - end);i++) {
+    for (int64_t i=0;i < (len - end);i++) {
       list[i+start] = *(list+i+end);
     }
     list[len-n] = NULL;
@@ -50990,9 +50989,9 @@ char **listCropS(char **list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char **iListCropS(char ***list, intmax_t start, intmax_t end) {
+char **iListCropS(char ***list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -51030,18 +51029,18 @@ char **iListCropS(char ***list, intmax_t start, intmax_t end) {
   }
   else {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char *));
     if (!l) {
       return(NULL);
     }
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       l[i] = *((*list)+start+i);
     }
     l[n] = NULL;
     // free end < len
-    for (intmax_t i=0;i < (len - end);i++) {
+    for (int64_t i=0;i < (len - end);i++) {
       (*list)[i+start] = *((*list)+i+end);
     }
     (*list)[len-n] = NULL;
@@ -51070,9 +51069,9 @@ char **iListCropS(char ***list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char *listCropElemS(char **list, intmax_t index) {
+char *listCropElemS(char **list, int64_t index) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -51096,7 +51095,7 @@ char *listCropElemS(char **list, intmax_t index) {
   }
 
   r = *(list+index);
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     list[i] = *(list+1+i);
   }
   list[len-1] = NULL;
@@ -51124,9 +51123,9 @@ char *listCropElemS(char **list, intmax_t index) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char *iListCropElemS(char ***list, intmax_t index) {
+char *iListCropElemS(char ***list, int64_t index) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -51150,7 +51149,7 @@ char *iListCropElemS(char ***list, intmax_t index) {
   }
 
   r = *((*list)+index);
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     (*list)[i] = *((*list)+1+i);
   }
   (*list)[len-1] = NULL;
@@ -51177,9 +51176,9 @@ char *iListCropElemS(char ***list, intmax_t index) {
  *   new list (you must free the pointer with listFreeS)
  *   NULL when list is NULL or invalid index
  */
-char **listInsertS(char **list, intmax_t index, char **toInsert) {
+char **listInsertS(char **list, int64_t index, char **toInsert) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list) {
@@ -51251,9 +51250,9 @@ char **listInsertS(char **list, intmax_t index, char **toInsert) {
  *   unchanged list when list is NULL or invalid index
  *   NULL error
  */
-char **iListInsertS(char ***list, intmax_t index, char **toInsert) {
+char **iListInsertS(char ***list, int64_t index, char **toInsert) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list || !toInsert) {
@@ -51352,9 +51351,9 @@ char **iListInsertS(char ***list, intmax_t index, char **toInsert) {
  *   unchanged list when list is NULL or invalid index
  *   NULL error
  */
-char **iListInsertNFreeS(char ***list, intmax_t index, char **toInsert) {
+char **iListInsertNFreeS(char ***list, int64_t index, char **toInsert) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list || !toInsert) {
@@ -51445,9 +51444,9 @@ char **iListInsertNFreeS(char ***list, intmax_t index, char **toInsert) {
  *   new list (you must free the pointer with listFreeS)
  *   NULL when list is NULL or invalid index
  */
-char **listInjectS(char **list, intmax_t index, char *toInject) {
+char **listInjectS(char **list, int64_t index, char *toInject) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list) {
@@ -51504,7 +51503,7 @@ char **listInjectS(char **list, intmax_t index, char *toInject) {
   return(r);
 }
 
-char **listInjectCharS(char **list, intmax_t index, char toInject) {
+char **listInjectCharS(char **list, int64_t index, char toInject) {
 
   charToS(s, toInject);
   return(listInjectS(list, index, s));
@@ -51530,9 +51529,9 @@ char **listInjectCharS(char **list, intmax_t index, char toInject) {
  *   unchanged list when list is NULL or invalid index
  *   NULL error
  */
-char **iListInjectS(char ***list, intmax_t index, char *toInject) {
+char **iListInjectS(char ***list, int64_t index, char *toInject) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list || !toInject) {
@@ -51594,7 +51593,7 @@ char **iListInjectS(char ***list, intmax_t index, char *toInject) {
   return(r);
 }
 
-char **iListInjectCharS(char ***list, intmax_t index, char toInject) {
+char **iListInjectCharS(char ***list, int64_t index, char toInject) {
 
   if (!list) {
     return(NULL);
@@ -51626,9 +51625,9 @@ char **iListInjectCharS(char ***list, intmax_t index, char toInject) {
  *   NULL when list is empty
  *   NULL when list is NULL or when end is under start
  */
-char **listDelS(char **list, intmax_t start, intmax_t end) {
+char **listDelS(char **list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -51668,16 +51667,16 @@ char **listDelS(char **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(char *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = strdup(*(list+i));
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = strdup(*(list+n+i));
   }
   l[len-n] = NULL;
@@ -51703,9 +51702,9 @@ char **listDelS(char **list, intmax_t start, intmax_t end) {
  *   NULL when list is NULL or when end is under start
  *   NULL error
  */
-char **iListDelS(char ***list, intmax_t start, intmax_t end) {
+char **iListDelS(char ***list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -51745,19 +51744,19 @@ char **iListDelS(char ***list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(char *));
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = *((*list)+i);
   }
-  for (intmax_t i=0;i < n;i++) {
+  for (int64_t i=0;i < n;i++) {
     free(*((*list)+start+i));
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = *((*list)+n+i);
   }
   l[len-n] = NULL;
@@ -51786,9 +51785,9 @@ char **iListDelS(char ***list, intmax_t start, intmax_t end) {
  *   NULL when list is NULL or when end is under start
  *   NULL error
  */
-char **iListRemoveS(char ***list, intmax_t start, intmax_t end) {
+char **iListRemoveS(char ***list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -51828,16 +51827,16 @@ char **iListRemoveS(char ***list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(char *));
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = *((*list)+i);
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = *((*list)+n+i);
   }
   l[len-n] = NULL;
@@ -51861,9 +51860,9 @@ char **iListRemoveS(char ***list, intmax_t start, intmax_t end) {
  *   NULL when list is empty
  *   NULL when list is NULL
  */
-char **listDelElemS(char **list, intmax_t index) {
+char **listDelElemS(char **list, int64_t index) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -51890,10 +51889,10 @@ char **listDelElemS(char **list, intmax_t index) {
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < index;i++) {
+  for (int64_t i=0;i < index;i++) {
     l[i] = strdup(*(list+i));
   }
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     l[i] = strdup(*(list+1+i));
   }
   l[len-1] = NULL;
@@ -51916,9 +51915,9 @@ char **listDelElemS(char **list, intmax_t index) {
  *   NULL when list is NULL
  *   NULL error
  */
-char **iListDelElemS(char ***list, intmax_t index) {
+char **iListDelElemS(char ***list, int64_t index) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -51945,11 +51944,11 @@ char **iListDelElemS(char ***list, intmax_t index) {
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < index;i++) {
+  for (int64_t i=0;i < index;i++) {
     l[i] = *((*list)+i);
   }
   free(*((*list)+index));
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     l[i] = *((*list)+1+i);
   }
   l[len-1] = NULL;
@@ -51976,9 +51975,9 @@ char **iListDelElemS(char ***list, intmax_t index) {
  *   NULL when list is NULL
  *   NULL error
  */
-char **iListRemoveElemS(char ***list, intmax_t index) {
+char **iListRemoveElemS(char ***list, int64_t index) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -52005,10 +52004,10 @@ char **iListRemoveElemS(char ***list, intmax_t index) {
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < index;i++) {
+  for (int64_t i=0;i < index;i++) {
     l[i] = *((*list)+i);
   }
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     l[i] = *((*list)+1+i);
   }
   l[len-1] = NULL;
@@ -53764,8 +53763,8 @@ size_t listLength(void **list) {
  *   element
  *   NULL when list is NULL or index is not set correctly
  */
-void *listGet(void **list, intmax_t index) {
-  intmax_t len;
+void *listGet(void **list, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -53808,8 +53807,8 @@ void *listGet(void **list, intmax_t index) {
  * Does nothing when:
  * when list is NULL, index is not set correctly or s is NULL
  */
-void **listSet(void **list, intmax_t index, void *s) {
-  intmax_t len;
+void **listSet(void **list, int64_t index, void *s) {
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -54109,9 +54108,9 @@ void **listAdd(void **list1, void **list2) {
  *   NULL when list is empty
  *   NULL when list is NULL or when start and end are not set correctly
  */
-void **listSlice(void **list, intmax_t start, intmax_t end) {
+void **listSlice(void **list, int64_t start, int64_t end) {
   void **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -54149,13 +54148,13 @@ void **listSlice(void **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((n+1) * sizeof(void *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < n;i++) {
+  for (int64_t i=0;i < n;i++) {
     l[i] = *(list+start+i);
   }
   l[n] = NULL;
@@ -54180,9 +54179,9 @@ void **listSlice(void **list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-void **iListSlice(void ***list, intmax_t start, intmax_t end) {
+void **iListSlice(void ***list, int64_t start, int64_t end) {
   void **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -54225,13 +54224,13 @@ void **iListSlice(void ***list, intmax_t start, intmax_t end) {
   }
   else {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(void *));
     if (!l) {
       return(NULL);
     }
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       l[i] = *((*list)+start+i);
     }
     l[n] = NULL;
@@ -54261,9 +54260,9 @@ void **iListSlice(void ***list, intmax_t start, intmax_t end) {
  *   new list (you must free the pointer)
  *   NULL when list is NULL or invalid index
  */
-void **listInsert(void **list, intmax_t index, void **toInsert) {
+void **listInsert(void **list, int64_t index, void **toInsert) {
   void **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list) {
@@ -54341,9 +54340,9 @@ void **listInsert(void **list, intmax_t index, void **toInsert) {
  *   unchanged list when list is NULL or invalid index
  *   NULL error
  */
-void **iListInsert(void ***list, intmax_t index, void **toInsert) {
+void **iListInsert(void ***list, int64_t index, void **toInsert) {
   void **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list || !toInsert) {
@@ -54423,9 +54422,9 @@ void **iListInsert(void ***list, intmax_t index, void **toInsert) {
  *   NULL when list is empty
  *   NULL when list is NULL or when end is under start
  */
-void **listDel(void **list, intmax_t start, intmax_t end) {
+void **listDel(void **list, int64_t start, int64_t end) {
   void **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -54465,16 +54464,16 @@ void **listDel(void **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(void *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = *(list+i);
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = *(list+n+i);
   }
   l[len-n] = NULL;
@@ -54500,9 +54499,9 @@ void **listDel(void **list, intmax_t start, intmax_t end) {
  *   NULL when list is NULL or when end is under start
  *   NULL error
  */
-void **iListDel(void ***list, intmax_t start, intmax_t end) {
+void **iListDel(void ***list, int64_t start, int64_t end) {
   void **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -54542,16 +54541,16 @@ void **iListDel(void ***list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(void *));
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = *((*list)+i);
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = *((*list)+n+i);
   }
   l[len-n] = NULL;
diff --git a/release/libsheepy.h b/release/libsheepy.h
@@ -691,7 +691,7 @@ extern jmp_buf tryJumpBuffers[maxTryThrowCount];
  *   AT;
  *   libsheepy.c, main:9149
  */
-#define AT pLog(LOG_INFO, __FILE__", %s:"stringifyExpr(__LINE__)"\n",__func__);
+#define AT pLog(LOG_DEBUG, __FILE__", %s:"stringifyExpr(__LINE__)"\n",__func__);
 
 /**
  * print a todo message in log
@@ -1945,9 +1945,9 @@ bool eqCharS(char c, const char *string2);
 bool eqSChar(const char *string1, char c);
 
 // string equal at index (compare content)
-bool eqIS(const char *string1, const char *string2, intmax_t index);
+bool eqIS(const char *string1, const char *string2, int64_t index);
 #define strIEq eqIS
-bool eqICharS(const char *string1, char c, intmax_t index);
+bool eqICharS(const char *string1, char c, int64_t index);
 
 // look for string2 at string1 start
 bool startsWithS(const char *string1, const char *string2);
@@ -1967,8 +1967,8 @@ bool icEqCharS(char c, const char *string2);
 bool icEqSChar(const char *string1, char c);
 
 // ignore case string equal at index (compare content)
-bool icEqIS(const char *string1, const char *string2, intmax_t index);
-bool icEqICharS(const char *string1, char c, intmax_t index);
+bool icEqIS(const char *string1, const char *string2, int64_t index);
+bool icEqICharS(const char *string1, char c, int64_t index);
 
 // ignore case and look for string2 at string1 start
 bool icStartsWithS(const char *string1, const char *string2);
@@ -1997,8 +1997,8 @@ bool isNumber(const char *string);
 bool isInt(const char *string);
 
 // parseInt
-intmax_t parseInt(const char *string);
-intmax_t parseIntChar(char c);
+int64_t parseInt(const char *string);
+int64_t parseIntChar(char c);
 int64_t parseI64(const char *string);
 int64_t parseI64Char(char c);
 
@@ -2011,8 +2011,8 @@ uint64_t parseHex(const char *string);
 // TODO parseHexChar
 
 // convert int to string
-char *intToS(intmax_t n);
-char *bIntToS(char *s, intmax_t n);
+char *intToS(int64_t n);
+char *bIntToS(char *s, int64_t n);
 
 // convert double to string
 char *doubleToS(double n);
@@ -2129,56 +2129,56 @@ char *bLPadEndCharS(char *dest, size_t destSize, const char *string, size_t targ
 ssize_t padEndLenS(const char *string, size_t targetLength, const char *padString);
 
 // get char at python index
-char getS(const char *string, intmax_t index);
+char getS(const char *string, int64_t index);
 
 // set char at python index
-char *setS(char *string, intmax_t index, char c);
+char *setS(char *string, int64_t index, char c);
 
 // swap characters in a string
-char *swapS(char *string, intmax_t index1, intmax_t index2);
-char *iSwapS(char **string, intmax_t index1, intmax_t index2);
-char *bSwapS(char *string, intmax_t index1, intmax_t index2);
-char *bLSwapS(char *string, size_t size, intmax_t index1, intmax_t index2);
+char *swapS(char *string, int64_t index1, int64_t index2);
+char *iSwapS(char **string, int64_t index1, int64_t index2);
+char *bSwapS(char *string, int64_t index1, int64_t index2);
+char *bLSwapS(char *string, size_t size, int64_t index1, int64_t index2);
 
 // slice string
 // function to slice parts of a string [1:10] - python style indexes 0..len-1 -1..-len+1
-char *sliceS(const char *string, intmax_t start, intmax_t end);
-char *iSliceS(char **string, intmax_t start, intmax_t end);
-char *bSliceS(char *string, intmax_t start, intmax_t end);
-char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end);
+char *sliceS(const char *string, int64_t start, int64_t end);
+char *iSliceS(char **string, int64_t start, int64_t end);
+char *bSliceS(char *string, int64_t start, int64_t end);
+char *bLSliceS(char *string, size_t stringSize, int64_t start, int64_t end);
 
 // crop string (slice+del)
-char *cropS(char *string, intmax_t start, intmax_t end);
-char *iCropS(char **string, intmax_t start, intmax_t end);
-char cropElemS(char *string, intmax_t index);
-char iCropElemS(char **string, intmax_t index);
+char *cropS(char *string, int64_t start, int64_t end);
+char *iCropS(char **string, int64_t start, int64_t end);
+char cropElemS(char *string, int64_t index);
+char iCropElemS(char **string, int64_t index);
 
 // insert string in string
-char *insertS(const char *string, intmax_t index, const char *toInsert);
-char *insertNFreeS(const char *string, intmax_t index, char *toInsert);
-char *iInsertS(char **string, intmax_t index, const char *toInsert);
-char *iInsertNFreeS(char **string, intmax_t index, char *toInsert);
-char *bInsertS(char *string, intmax_t index, const char *toInsert);
-char *bLInsertS(char *string, size_t stringSize, intmax_t index, const char *toInsert);
+char *insertS(const char *string, int64_t index, const char *toInsert);
+char *insertNFreeS(const char *string, int64_t index, char *toInsert);
+char *iInsertS(char **string, int64_t index, const char *toInsert);
+char *iInsertNFreeS(char **string, int64_t index, char *toInsert);
+char *bInsertS(char *string, int64_t index, const char *toInsert);
+char *bLInsertS(char *string, size_t stringSize, int64_t index, const char *toInsert);
 
 // inject a char in string
-char *injectS(const char *string, intmax_t index, char toInject);
-char *iInjectS(char **string, intmax_t index, char toInject);
-char *bInjectS(char *string, intmax_t index, char toInject);
-char *bLInjectS(char *string, size_t stringSize, intmax_t index, char toInject);
+char *injectS(const char *string, int64_t index, char toInject);
+char *iInjectS(char **string, int64_t index, char toInject);
+char *bInjectS(char *string, int64_t index, char toInject);
+char *bLInjectS(char *string, size_t stringSize, int64_t index, char toInject);
 
 // del string
 // function to delete parts of a string [1:10] - python style indexes 0..len-1 -1..-len+1
-char *delS(const char *string, intmax_t start, intmax_t end);
-char *iDelS(char **string, intmax_t start, intmax_t end);
-char *bDelS(char *string, intmax_t start, intmax_t end);
-char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end);
+char *delS(const char *string, int64_t start, int64_t end);
+char *iDelS(char **string, int64_t start, int64_t end);
+char *bDelS(char *string, int64_t start, int64_t end);
+char *bLDelS(char *string, size_t stringSize, int64_t start, int64_t end);
 
 // del a character in string
-char *delElemS(const char *string, intmax_t index);
-char *iDelElemS(char **string, intmax_t index);
-char *bDelElemS(char *string, intmax_t index);
-char *bLDelElemS(char *string, size_t stringSize, intmax_t index);
+char *delElemS(const char *string, int64_t index);
+char *iDelElemS(char **string, int64_t index);
+char *bDelElemS(char *string, int64_t index);
+char *bLDelElemS(char *string, size_t stringSize, int64_t index);
 
 // find substring
 char *findS(const char *string, const char *needle);
@@ -2250,14 +2250,14 @@ char *prevUTF8(const char *utf8);
 char *bPrevUTF8(const char *string, const char *utf8);
 
 // character index to pointer
-char *idx2PtrUTF8(const char *utf8, intmax_t index);
-char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index);
+char *idx2PtrUTF8(const char *utf8, int64_t index);
+char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, int64_t index);
 
 // pointer to character index
-intmax_t ptr2IdxUTF8(const char *utf8, const char *pos);
-intmax_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos);
-intmax_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
-intmax_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
+int64_t ptr2IdxUTF8(const char *utf8, const char *pos);
+int64_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos);
+int64_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
+int64_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
 
 // make new valid UTF-8 encoded string
 char *makeValidUTF8(const char *utf8);
@@ -2309,10 +2309,10 @@ char *bicReplaceManyUTF8F(char *s, char *paramType, ...);
 char *bLicReplaceManyUTF8F(char *s, size_t sSize, char *paramType, ...);
 
 // UTF8 encoded string Index Equal
-bool eqIUTF8(const char *string1, const char *string2, intmax_t index);
+bool eqIUTF8(const char *string1, const char *string2, int64_t index);
 
 // UTF8 encoded string Index Equal
-bool eqICharUTF8(const char *string1, char c, intmax_t index);
+bool eqICharUTF8(const char *string1, char c, int64_t index);
 
 // ignore case UTF8 encoded string Equal
 bool icEqUTF8(const char *string1, const char *string2);
@@ -2320,9 +2320,9 @@ bool icEqCharUTF8(char c, const char *string2);
 bool icEqUTF8Char(const char *string1, char c);
 
 // TODO
-bool icEqIUTF8(const char *string1, const char *string2, intmax_t index);
+bool icEqIUTF8(const char *string1, const char *string2, int64_t index);
 // TODO
-bool icEqICharUTF8(const char *string1, char c, intmax_t index);
+bool icEqICharUTF8(const char *string1, char c, int64_t index);
 
 // starts with for UTF-8 encoded string
 bool icStartsWithUTF8(const char *string1, const char *string2);
@@ -2376,30 +2376,30 @@ char *iicUniqUTF8(char **string, const char *code);
 char *bicUniqUTF8(char *string, char c);
 
 // get rune in UTF8 encoded string
-rune getUTF8(const char *string, intmax_t index);
+rune getUTF8(const char *string, int64_t index);
 
 // TODO
-char *setUTF8(char *string, intmax_t index, rune c);
+char *setUTF8(char *string, int64_t index, rune c);
 
 // slice UTF8 encoded String
-char *sliceUTF8(const char *string, intmax_t start, intmax_t end);
-char *iSliceUTF8(char **string, intmax_t start, intmax_t end);
-char *bSliceUTF8(char *string, intmax_t start, intmax_t end);
-char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end);
+char *sliceUTF8(const char *string, int64_t start, int64_t end);
+char *iSliceUTF8(char **string, int64_t start, int64_t end);
+char *bSliceUTF8(char *string, int64_t start, int64_t end);
+char *bLSliceUTF8(char *string, size_t stringSize, int64_t start, int64_t end);
 
 // insert string in UTF8 encoded string at index
-char *insertUTF8(const char *string, intmax_t index, const char *toInsert);
-char *insertNFreeUTF8(const char *string, intmax_t index, char *toInsert);
-char *iInsertUTF8(char **string, intmax_t index, const char *toInsert);
-char *iInsertNFreeUTF8(char **string, intmax_t index, char *toInsert);
-char *bInsertUTF8(char *string, intmax_t index, const char *toInsert);
-char *bLInsertUTF8(char *string, size_t stringSize, intmax_t index, const char *toInsert);
+char *insertUTF8(const char *string, int64_t index, const char *toInsert);
+char *insertNFreeUTF8(const char *string, int64_t index, char *toInsert);
+char *iInsertUTF8(char **string, int64_t index, const char *toInsert);
+char *iInsertNFreeUTF8(char **string, int64_t index, char *toInsert);
+char *bInsertUTF8(char *string, int64_t index, const char *toInsert);
+char *bLInsertUTF8(char *string, size_t stringSize, int64_t index, const char *toInsert);
 
 // delete UTF8 encoded string
-char *delUTF8(const char *string, intmax_t start, intmax_t end);
-char *iDelUTF8(char **string, intmax_t start, intmax_t end);
-char *bDelUTF8(char *string, intmax_t start, intmax_t end);
-char *bLDelUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end);
+char *delUTF8(const char *string, int64_t start, int64_t end);
+char *iDelUTF8(char **string, int64_t start, int64_t end);
+char *bDelUTF8(char *string, int64_t start, int64_t end);
+char *bLDelUTF8(char *string, size_t stringSize, int64_t start, int64_t end);
 
 // indexOf UTF8 encoded String
 ssize_t indexOfUTF8(const char *string, const char *needle);
@@ -2477,7 +2477,7 @@ bool isBlankS(const char *string);
 
 
 // convert python index (int, positive and negative) to always positive index (uint), this function is more generic than listIntIndexS
-ssize_t intIndex(intmax_t index, intmax_t length);
+ssize_t intIndex(int64_t index, int64_t length);
 
 // create empty list
 #define listEmptyS(list) \
@@ -2535,23 +2535,23 @@ size_t listLengthS(char **list);
 ssize_t listStrLengthS(char **list);
 
 // convert python index (int) to always positive index (uint)
-ssize_t listIntIndexS(char **list, intmax_t index);
+ssize_t listIntIndexS(char **list, int64_t index);
 
 // pointer to the char* at python index
-char **listAddrS(char **list, intmax_t index);
+char **listAddrS(char **list, int64_t index);
 
 // list get - get a string at python index
-char *listGetS(char **list, intmax_t index);
-char *iListGetS(char **list, intmax_t index);
+char *listGetS(char **list, int64_t index);
+char *iListGetS(char **list, int64_t index);
 
 // list set - replace a string at python index
-char **listSetS(char **list, intmax_t index, const char *s);
-char **listSetCharS(char **list, intmax_t index, char c);
-char **iListSetS(char **list, intmax_t index, char *s);
+char **listSetS(char **list, int64_t index, const char *s);
+char **listSetCharS(char **list, int64_t index, char c);
+char **iListSetS(char **list, int64_t index, char *s);
 
 // swap elements in a list
-char **listSwapS(char **list, intmax_t index1, intmax_t index2);
-char **iListSwapS(char **list, intmax_t index1, intmax_t index2);
+char **listSwapS(char **list, int64_t index1, int64_t index2);
+char **iListSwapS(char **list, int64_t index1, int64_t index2);
 
 // split
 char **split(const char *string, const char* delim);
@@ -2610,36 +2610,36 @@ char **iListShiftNSmashS(char ***list1, char **list2);
 char **listAddS(char **list1, char **list2);
 
 // slice - python style indexes 0..len-1 -1..-len+1
-char **listSliceS(char **list, intmax_t start, intmax_t end);
-char **iListCopyS(char **list, intmax_t start, intmax_t end);
-char **iListSliceS(char ***list, intmax_t start, intmax_t end);
+char **listSliceS(char **list, int64_t start, int64_t end);
+char **iListCopyS(char **list, int64_t start, int64_t end);
+char **iListSliceS(char ***list, int64_t start, int64_t end);
 
 // crop list (slice+del)
-char **listCropS(char **list, intmax_t start, intmax_t end);
-char **iListCropS(char ***list, intmax_t start, intmax_t end);
-char *listCropElemS(char **list, intmax_t index);
-char *iListCropElemS(char ***list, intmax_t index);
+char **listCropS(char **list, int64_t start, int64_t end);
+char **iListCropS(char ***list, int64_t start, int64_t end);
+char *listCropElemS(char **list, int64_t index);
+char *iListCropElemS(char ***list, int64_t index);
 
 // insert list in list
-char **listInsertS(char **list, intmax_t index, char **toInsert);
-char **iListInsertS(char ***list, intmax_t index, char **toInsert);
-char **iListInsertNFreeS(char ***list, intmax_t index, char **toInsert);
+char **listInsertS(char **list, int64_t index, char **toInsert);
+char **iListInsertS(char ***list, int64_t index, char **toInsert);
+char **iListInsertNFreeS(char ***list, int64_t index, char **toInsert);
 
 // inject string in list
-char **listInjectS(char **list, intmax_t index, char *toInject);
-char **listInjectCharS(char **list, intmax_t index, char toInject);
-char **iListInjectS(char ***list, intmax_t index, char *toInject);
-char **iListInjectCharS(char ***list, intmax_t index, char toInject);
+char **listInjectS(char **list, int64_t index, char *toInject);
+char **listInjectCharS(char **list, int64_t index, char toInject);
+char **iListInjectS(char ***list, int64_t index, char *toInject);
+char **iListInjectCharS(char ***list, int64_t index, char toInject);
 
 // del - python style indexes 0..len-1 -1..-len+1
-char **listDelS(char **list, intmax_t start, intmax_t end);
-char **iListDelS(char ***list, intmax_t start, intmax_t end);
-char **iListRemoveS(char ***list, intmax_t start, intmax_t end);
+char **listDelS(char **list, int64_t start, int64_t end);
+char **iListDelS(char ***list, int64_t start, int64_t end);
+char **iListRemoveS(char ***list, int64_t start, int64_t end);
 
 // del element in list
-char **listDelElemS(char **list, intmax_t index);
-char **iListDelElemS(char ***list, intmax_t index);
-char **iListRemoveElemS(char ***list, intmax_t index);
+char **listDelElemS(char **list, int64_t index);
+char **iListDelElemS(char ***list, int64_t index);
+char **iListRemoveElemS(char ***list, int64_t index);
 
 // print list
 int listPrintS(char **list);
@@ -3139,10 +3139,10 @@ void listFreeManyF(void **paramType, ...);
 size_t listLength(void **list);
 
 // list get - get an element at python index
-void *listGet(void **list, intmax_t index);
+void *listGet(void **list, int64_t index);
 
 // list set - replace a string at python index
-void **listSet(void **list, intmax_t index, void *s);
+void **listSet(void **list, int64_t index, void *s);
 
 // duplicate list
 void **listDup(void **list);
@@ -3162,17 +3162,17 @@ void **listAppend(void ***list1, void **list2);
 void **listAdd(void **list1, void **list2);
 
 // slice - python style indexes 0..len-1 -1..-len+1
-void **listSlice(void **list, intmax_t start, intmax_t end);
-void **iListSlice(void ***list, intmax_t start, intmax_t end);
+void **listSlice(void **list, int64_t start, int64_t end);
+void **iListSlice(void ***list, int64_t start, int64_t end);
 
 // insert list in list
-void **listInsert(void **list, intmax_t index, void **toInsert);
-void **iListInsert(void ***list, intmax_t index, void **toInsert);
+void **listInsert(void **list, int64_t index, void **toInsert);
+void **iListInsert(void ***list, int64_t index, void **toInsert);
 
 // del - python style indexes 0..len-1 -1..-len+1
-void **listDel(void **list, intmax_t start, intmax_t end);
-void **iListDel(void ***list, intmax_t start, intmax_t end);
-//NOT NEEDED same as iListDel - void **iListRemove(void ***list, intmax_t start, intmax_t end);
+void **listDel(void **list, int64_t start, int64_t end);
+void **iListDel(void ***list, int64_t start, int64_t end);
+//NOT NEEDED same as iListDel - void **iListRemove(void ***list, int64_t start, int64_t end);
 
 // duplicate and sort
 //TODO void **listSort(void **list);
@@ -5568,8 +5568,8 @@ void **iListDel(void ***list, intmax_t start, intmax_t end);
  */
 #define dVectorT(typeName, elementType)\
   typedef struct {\
-    intmax_t    count;\
-    intmax_t    maxCount;\
+    int64_t    count;\
+    int64_t    maxCount;\
     void**      buffers;\
     elementType element;\
   } typeName
@@ -6798,9 +6798,9 @@ bool fiberPrepend(void *ctx, int thisSlot, fiberFT func);
  */
 #define dArrayT(typeName, elementType)\
   typedef struct {\
-    intmax_t    last;\
-    intmax_t    head;\
-    intmax_t    maxCount;\
+    int64_t    last;\
+    int64_t    head;\
+    int64_t    maxCount;\
     void**      buffers;\
     elementType element;\
   } typeName
@@ -7279,9 +7279,9 @@ bool fiberPrepend(void *ctx, int thisSlot, fiberFT func);
  */
 #define slabT(typeName, elementType)\
   typedef struct {\
-    intmax_t    last;\
-    intmax_t    head;\
-    intmax_t    maxCount;\
+    int64_t      last;\
+    int64_t      head;\
+    int64_t      maxCount;\
     elementType *array;\
   } typeName
 
diff --git a/release/libsheepyObject.h b/release/libsheepyObject.h
@@ -10366,7 +10366,7 @@ smallStringt *readLineO(FILE *fp);
 /**
  * call intToS for intToG
  */
-char *intToSG(char *retType UNUSED, intmax_t n);
+char *intToSG(char *retType UNUSED, int64_t n);
 
 /**
  * call doubleToS for doubleToG
@@ -10392,19 +10392,19 @@ char **listFromCArrayG(char **retType UNUSED, const char **array, size_t size);
 /**
  * call getS for getG
  */
-char getSG(const char *string, int retType UNUSED, intmax_t index);
+char getSG(const char *string, int retType UNUSED, int64_t index);
 
 /**
  * call listGetS for getG
  */
-char *listGetG(char **list, int retType UNUSED, intmax_t index);
-char *listGetCG(const char **list, int retType UNUSED, intmax_t index);
+char *listGetG(char **list, int retType UNUSED, int64_t index);
+char *listGetCG(const char **list, int retType UNUSED, int64_t index);
 
 /**
  * call iListGetS for getG
  */
-char *iListGetG(char **list, int retType UNUSED, intmax_t index);
-char *iListGetCG(const char **list, int retType UNUSED, intmax_t index);
+char *iListGetG(char **list, int retType UNUSED, int64_t index);
+char *iListGetCG(const char **list, int retType UNUSED, int64_t index);
 
 /**
  * call listPopS for popG
diff --git a/release/libsheepySmall.h b/release/libsheepySmall.h
@@ -253,19 +253,19 @@ sBytest* sArrayTypesTiny(sArrayt* obj);
 // forEach - loop macro on elements
 #define forEachSDict(dict, element) \
   sDictElemt *element = &((dict)->elements); \
-  for (size_t libsheepyInternalIndex = 0; libsheepyInternalIndex < (dict)->count ; libsheepyInternalIndex++, element = &((dict)->elements) + libsheepyInternalIndex)
+  for (size_t libsheepyInternalIndex = 0; libsheepyInternalIndex < (dict)->count ; libsheepyInternalIndex++, element = libsheepyInternalIndex < (dict)->count ? &((dict)->elements) + libsheepyInternalIndex : NULL)
 
 #define enumerateSDict(dict, element, index) \
   sDictElemt *element = &((dict)->elements); \
-  for (size_t index = 0; index < (dict)->count ; index++, element = &((dict)->elements) + index)
+  for (size_t index = 0; index < (dict)->count ; index++, index < (dict)->count ? element = &((dict)->elements) + index : NULL)
 
 #define forEachSArray(array, element) \
   smallt *element = ((smallt **) &((array)->data))[0]; \
-  for (size_t libsheepyInternalIndex = 0; libsheepyInternalIndex < (array)->count ; libsheepyInternalIndex++, element = ((smallt **) &((array)->data))[libsheepyInternalIndex])
+  for (size_t libsheepyInternalIndex = 0; libsheepyInternalIndex < (array)->count ; libsheepyInternalIndex++, element = libsheepyInternalIndex < (array)->count ? ((smallt **) &((array)->data))[libsheepyInternalIndex] : NULL)
 
 #define enumerateSArray(array, element, index) \
   smallt *element = ((smallt **) &((array)->data))[0]; \
-  for (size_t index = 0; index < (array)->count ; index++, element = ((smallt **) &((array)->data))[index])
+  for (size_t index = 0; index < (array)->count ; index++, element = index < (array)->count ? ((smallt **) &((array)->data))[index] : NULL)
 
 // TODO forEachSBytes
 
diff --git a/src/json/libsheepyCSmallArray.c b/src/json/libsheepyCSmallArray.c
@@ -184,66 +184,66 @@ internal smallArrayt* shiftSmallJsonSmallArray(smallArrayt *self, smallJsont *js
 internal smallArrayt* shiftNSmashSmallArray(smallArrayt *self, smallArrayt *array);
 internal smallArrayt* shiftNSmashSmallJsonSmallArray(smallArrayt *self, smallJsont *json);
 internal smallArrayt* addSmallArray(smallArrayt *self, smallArrayt *array);
-internal smallArrayt* sliceSmallArray(smallArrayt *self, intmax_t start, intmax_t end);
-internal smallArrayt* cropSmallArray(smallArrayt *self, intmax_t start, intmax_t end);
-internal baset* cropElemSmallArray(smallArrayt *self, intmax_t index);
-internal undefinedt* cropElemUndefinedSmallArray(smallArrayt *self, intmax_t index);
-internal bool cropElemBoolSmallArray(smallArrayt *self, intmax_t index);
-internal double cropElemDoubleSmallArray(smallArrayt *self, intmax_t index);
-internal int64_t cropElemIntSmallArray(smallArrayt *self, intmax_t index);
-internal int32_t cropElemInt32SmallArray(smallArrayt *self, intmax_t index);
-internal uint64_t cropElemUintSmallArray(smallArrayt *self, intmax_t index);
-internal uint32_t cropElemUint32SmallArray(smallArrayt *self, intmax_t index);
-internal char* cropElemSSmallArray(smallArrayt *self, intmax_t index);
-internal smallDictt* cropElemDictSmallArray(smallArrayt *self, intmax_t index);
-internal smallArrayt* cropElemArraySmallArray(smallArrayt *self, intmax_t index);
-internal smallBoolt* cropElemSmallBoolSmallArray(smallArrayt *self, intmax_t index);
-internal smallBytest* cropElemSmallBytesSmallArray(smallArrayt *self, intmax_t index);
-internal smallDoublet* cropElemSmallDoubleSmallArray(smallArrayt *self, intmax_t index);
-internal smallIntt* cropElemSmallIntSmallArray(smallArrayt *self, intmax_t index);
-internal smallJsont* cropElemSmallJsonSmallArray(smallArrayt *self, intmax_t index);
-internal smallStringt* cropElemSmallStringSmallArray(smallArrayt *self, intmax_t index);
-internal void* cropElemVoidSmallArray(smallArrayt *self, intmax_t index);
-internal smallContainert* cropElemSmallContainerSmallArray(smallArrayt *self, intmax_t index);
-internal smallArrayt* copySmallArray(smallArrayt *self, intmax_t start, intmax_t end);
-internal smallArrayt* insertSmallArray(smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-internal smallArrayt* insertSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *toInsert);
-internal smallArrayt* insertNSmashSmallArray(smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-internal smallArrayt* insertNSmashSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *toInsert);
-internal smallArrayt* injectSmallArray(smallArrayt *self, intmax_t index, baset *toInject);
-internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, intmax_t index);
-internal smallArrayt* injectBoolSmallArray(smallArrayt *self, intmax_t index, bool toInject);
-internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, intmax_t index, double toInject);
-internal smallArrayt* injectIntSmallArray(smallArrayt *self, intmax_t index, int64_t toInject);
-internal smallArrayt* injectSSmallArray(smallArrayt *self, intmax_t index, const char *toInject);
-internal smallArrayt* injectCharSmallArray(smallArrayt *self, intmax_t index, char c);
-internal smallArrayt* injectDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *toInject);
-internal smallArrayt* injectArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *toInject);
-internal smallArrayt* injectArraycSmallArray(smallArrayt *self, intmax_t index, char **toInject);
-internal smallArrayt* injectSmallBoolSmallArray(smallArrayt *self, intmax_t index, smallBoolt *toInject);
-internal smallArrayt* injectSmallBytesSmallArray(smallArrayt *self, intmax_t index, smallBytest *toInject);
-internal smallArrayt* injectSmallDoubleSmallArray(smallArrayt *self, intmax_t index, smallDoublet *toInject);
-internal smallArrayt* injectSmallIntSmallArray(smallArrayt *self, intmax_t index, smallIntt *toInject);
-internal smallArrayt* injectSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *toInject);
-internal smallArrayt* injectSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *toInject);
-internal smallArrayt* injectSmallContainerSmallArray(smallArrayt *self, intmax_t index, smallContainert *toInject);
-internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, intmax_t index, baset *toInject);
-internal smallArrayt* injectNFreeUndefinedSmallArray(smallArrayt *self, intmax_t index, undefinedt *undefined);
-internal smallArrayt* injectNFreeSSmallArray(smallArrayt *self, intmax_t index, char *toInject);
-internal smallArrayt* injectNFreeDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *toInject);
-internal smallArrayt* injectNFreeArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *toInject);
-internal smallArrayt* injectNFreeArraycSmallArray(smallArrayt *self, intmax_t index, char **toInject);
-internal smallArrayt* injectNFreeSmallBoolSmallArray(smallArrayt *self, intmax_t index, smallBoolt *toInject);
-internal smallArrayt* injectNFreeSmallBytesSmallArray(smallArrayt *self, intmax_t index, smallBytest *toInject);
-internal smallArrayt* injectNFreeSmallDoubleSmallArray(smallArrayt *self, intmax_t index, smallDoublet *toInject);
-internal smallArrayt* injectNFreeSmallIntSmallArray(smallArrayt *self, intmax_t index, smallIntt *toInject);
-internal smallArrayt* injectNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *toInject);
-internal smallArrayt* injectNFreeSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *toInject);
-internal smallArrayt* injectNFreeSmallContainerSmallArray(smallArrayt *self, intmax_t index, smallContainert *toInject);
-internal smallArrayt* delSmallArray(smallArrayt *self, intmax_t start, intmax_t end);
-internal smallArrayt* delElemSmallArray(smallArrayt *self, intmax_t index);
-internal smallArrayt* removeSmallArray(smallArrayt *self, intmax_t start, intmax_t end);
-internal smallArrayt* removeElemSmallArray(smallArrayt *self, intmax_t index);
+internal smallArrayt* sliceSmallArray(smallArrayt *self, int64_t start, int64_t end);
+internal smallArrayt* cropSmallArray(smallArrayt *self, int64_t start, int64_t end);
+internal baset* cropElemSmallArray(smallArrayt *self, int64_t index);
+internal undefinedt* cropElemUndefinedSmallArray(smallArrayt *self, int64_t index);
+internal bool cropElemBoolSmallArray(smallArrayt *self, int64_t index);
+internal double cropElemDoubleSmallArray(smallArrayt *self, int64_t index);
+internal int64_t cropElemIntSmallArray(smallArrayt *self, int64_t index);
+internal int32_t cropElemInt32SmallArray(smallArrayt *self, int64_t index);
+internal uint64_t cropElemUintSmallArray(smallArrayt *self, int64_t index);
+internal uint32_t cropElemUint32SmallArray(smallArrayt *self, int64_t index);
+internal char* cropElemSSmallArray(smallArrayt *self, int64_t index);
+internal smallDictt* cropElemDictSmallArray(smallArrayt *self, int64_t index);
+internal smallArrayt* cropElemArraySmallArray(smallArrayt *self, int64_t index);
+internal smallBoolt* cropElemSmallBoolSmallArray(smallArrayt *self, int64_t index);
+internal smallBytest* cropElemSmallBytesSmallArray(smallArrayt *self, int64_t index);
+internal smallDoublet* cropElemSmallDoubleSmallArray(smallArrayt *self, int64_t index);
+internal smallIntt* cropElemSmallIntSmallArray(smallArrayt *self, int64_t index);
+internal smallJsont* cropElemSmallJsonSmallArray(smallArrayt *self, int64_t index);
+internal smallStringt* cropElemSmallStringSmallArray(smallArrayt *self, int64_t index);
+internal void* cropElemVoidSmallArray(smallArrayt *self, int64_t index);
+internal smallContainert* cropElemSmallContainerSmallArray(smallArrayt *self, int64_t index);
+internal smallArrayt* copySmallArray(smallArrayt *self, int64_t start, int64_t end);
+internal smallArrayt* insertSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert);
+internal smallArrayt* insertSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert);
+internal smallArrayt* insertNSmashSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert);
+internal smallArrayt* insertNSmashSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert);
+internal smallArrayt* injectSmallArray(smallArrayt *self, int64_t index, baset *toInject);
+internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, int64_t index);
+internal smallArrayt* injectBoolSmallArray(smallArrayt *self, int64_t index, bool toInject);
+internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, int64_t index, double toInject);
+internal smallArrayt* injectIntSmallArray(smallArrayt *self, int64_t index, int64_t toInject);
+internal smallArrayt* injectSSmallArray(smallArrayt *self, int64_t index, const char *toInject);
+internal smallArrayt* injectCharSmallArray(smallArrayt *self, int64_t index, char c);
+internal smallArrayt* injectDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject);
+internal smallArrayt* injectArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject);
+internal smallArrayt* injectArraycSmallArray(smallArrayt *self, int64_t index, char **toInject);
+internal smallArrayt* injectSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject);
+internal smallArrayt* injectSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject);
+internal smallArrayt* injectSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject);
+internal smallArrayt* injectSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject);
+internal smallArrayt* injectSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject);
+internal smallArrayt* injectSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject);
+internal smallArrayt* injectSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject);
+internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, int64_t index, baset *toInject);
+internal smallArrayt* injectNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *undefined);
+internal smallArrayt* injectNFreeSSmallArray(smallArrayt *self, int64_t index, char *toInject);
+internal smallArrayt* injectNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject);
+internal smallArrayt* injectNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject);
+internal smallArrayt* injectNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **toInject);
+internal smallArrayt* injectNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject);
+internal smallArrayt* injectNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject);
+internal smallArrayt* injectNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject);
+internal smallArrayt* injectNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject);
+internal smallArrayt* injectNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject);
+internal smallArrayt* injectNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject);
+internal smallArrayt* injectNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject);
+internal smallArrayt* delSmallArray(smallArrayt *self, int64_t start, int64_t end);
+internal smallArrayt* delElemSmallArray(smallArrayt *self, int64_t index);
+internal smallArrayt* removeSmallArray(smallArrayt *self, int64_t start, int64_t end);
+internal smallArrayt* removeElemSmallArray(smallArrayt *self, int64_t index);
 internal int sortSCmp(const void * a, const void * b);
 internal smallArrayt* sortSmallArray(smallArrayt *self);
 #if (__APPLE__ || __FreeBSD__ || __DragonFly__)
@@ -268,89 +268,89 @@ bool icEqualSmallArrayArray(smallArrayt* self, char ** p2);
 bool icEqualSmallArrayBase(smallArrayt* self, baset* p2);
 internal size_t lenSmallArray(smallArrayt *self);
 internal smallArrayt* trimSmallArray(smallArrayt *self);
-baset* getAtSmallArray(smallArrayt *self, intmax_t index);
-internal undefinedt* getAtUndefinedSmallArray(smallArrayt *self, intmax_t index);
-internal bool getAtBoolSmallArray(smallArrayt *self, intmax_t index);
-internal bool* getAtBoolPSmallArray(smallArrayt *self, intmax_t index);
-internal double getAtDoubleSmallArray(smallArrayt *self, intmax_t index);
-internal double* getAtDoublePSmallArray(smallArrayt *self, intmax_t index);
-internal int64_t getAtIntSmallArray(smallArrayt *self, intmax_t index);
-internal int64_t* getAtIntPSmallArray(smallArrayt *self, intmax_t index);
-internal int32_t getAtInt32SmallArray(smallArrayt *self, intmax_t index);
-internal int32_t* getAtInt32PSmallArray(smallArrayt *self, intmax_t index);
-internal uint64_t getAtUintSmallArray(smallArrayt *self, intmax_t index);
-internal uint64_t* getAtUintPSmallArray(smallArrayt *self, intmax_t index);
-internal uint32_t getAtUint32SmallArray(smallArrayt *self, intmax_t index);
-internal uint32_t* getAtUint32PSmallArray(smallArrayt *self, intmax_t index);
-internal char* getAtSSmallArray(smallArrayt *self, intmax_t index);
-internal smallDictt* getAtDictSmallArray(smallArrayt *self, intmax_t index);
-internal smallArrayt* getAtArraySmallArray(smallArrayt *self, intmax_t index);
-internal smallBoolt* getAtSmallBoolSmallArray(smallArrayt *self, intmax_t index);
-internal smallBytest* getAtSmallBytesSmallArray(smallArrayt *self, intmax_t index);
-internal smallDoublet* getAtSmallDoubleSmallArray(smallArrayt *self, intmax_t index);
-internal smallIntt* getAtSmallIntSmallArray(smallArrayt *self, intmax_t index);
-internal smallJsont* getAtSmallJsonSmallArray(smallArrayt *self, intmax_t index);
-internal smallStringt* getAtSmallStringSmallArray(smallArrayt *self, intmax_t index);
-internal void* getAtVoidSmallArray(smallArrayt *self, intmax_t index);
-internal smallContainert* getAtSmallContainerSmallArray(smallArrayt *self, intmax_t index);
-baset* getAtNDupSmallArray(smallArrayt *self, intmax_t index);
-internal undefinedt* getAtNDupUndefinedSmallArray(smallArrayt *self, intmax_t index);
-internal bool getAtNDupBoolSmallArray(smallArrayt *self, intmax_t index);
-internal double getAtNDupDoubleSmallArray(smallArrayt *self, intmax_t index);
-internal int64_t getAtNDupIntSmallArray(smallArrayt *self, intmax_t index);
-internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, intmax_t index);
-internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, intmax_t index);
-internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, intmax_t index);
-internal char* getAtNDupSSmallArray(smallArrayt *self, intmax_t index);
-internal smallDictt* getAtNDupDictSmallArray(smallArrayt *self, intmax_t index);
-internal smallArrayt* getAtNDupArraySmallArray(smallArrayt *self, intmax_t index);
-internal smallBoolt* getAtNDupSmallBoolSmallArray(smallArrayt *self, intmax_t index);
-internal smallBytest* getAtNDupSmallBytesSmallArray(smallArrayt *self, intmax_t index);
-internal smallDoublet* getAtNDupSmallDoubleSmallArray(smallArrayt *self, intmax_t index);
-internal smallIntt* getAtNDupSmallIntSmallArray(smallArrayt *self, intmax_t index);
-internal smallJsont* getAtNDupSmallJsonSmallArray(smallArrayt *self, intmax_t index);
-internal smallStringt* getAtNDupSmallStringSmallArray(smallArrayt *self, intmax_t index);
-internal void* getAtNDupVoidSmallArray(smallArrayt *self, intmax_t index);
-internal smallContainert* getAtNDupSmallContainerSmallArray(smallArrayt *self, intmax_t index);
-internal smallArrayt* setAtSmallArray(smallArrayt *self, intmax_t index, baset *value);
-internal smallArrayt* setAtUndefinedSmallArray(smallArrayt *self, intmax_t index);
-internal smallArrayt* setAtBoolSmallArray(smallArrayt *self, intmax_t index, bool value);
-internal smallArrayt* setAtDoubleSmallArray(smallArrayt *self, intmax_t index, double value);
-internal smallArrayt* setAtIntSmallArray(smallArrayt *self, intmax_t index, int64_t value);
-internal smallArrayt* setAtSSmallArray(smallArrayt *self, intmax_t index, const char *string);
-internal smallArrayt* setAtCharSmallArray(smallArrayt *self, intmax_t index, char c);
-internal smallArrayt* setAtDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *dict);
-internal smallArrayt* setAtArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *array);
-internal smallArrayt* setAtArraycSmallArray(smallArrayt *self, intmax_t index, char **array);
-internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, intmax_t index, smallBoolt *value);
-internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, intmax_t index, smallBytest *value);
-internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, intmax_t index, smallDoublet *value);
-internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, intmax_t index, smallIntt *value);
-internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *value);
-internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *string);
-internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, intmax_t index, smallContainert *container);
-internal smallArrayt* setAtNFreeSmallArray(smallArrayt *self, intmax_t index, baset *value);
-internal smallArrayt* setAtNFreeUndefinedSmallArray(smallArrayt *self, intmax_t index, undefinedt *undefined);
-internal smallArrayt* setAtNFreeSSmallArray(smallArrayt *self, intmax_t index, char *string);
-internal smallArrayt* setAtNFreeDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *dict);
-internal smallArrayt* setAtNFreeArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *array);
-internal smallArrayt* setAtNFreeArraycSmallArray(smallArrayt *self, intmax_t index, char **array);
-internal smallArrayt* setAtNFreeSmallBoolSmallArray(smallArrayt *self, intmax_t index, smallBoolt *value);
-internal smallArrayt* setAtNFreeSmallBytesSmallArray(smallArrayt *self, intmax_t index, smallBytest *value);
-internal smallArrayt* setAtNFreeSmallDoubleSmallArray(smallArrayt *self, intmax_t index, smallDoublet *value);
-internal smallArrayt* setAtNFreeSmallIntSmallArray(smallArrayt *self, intmax_t index, smallIntt *value);
-internal smallArrayt* setAtNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *value);
-internal smallArrayt* setAtNFreeSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *string);
-internal smallArrayt* setAtNFreeSmallContainerSmallArray(smallArrayt *self, intmax_t index, smallContainert *container);
-internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *dict);
-internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *array);
-internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *json);
-internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *string);
-internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *dict);
-internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *array);
-internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *json);
-internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *string);
-internal double getNumSmallArray(smallArrayt *self, intmax_t index);
+baset* getAtSmallArray(smallArrayt *self, int64_t index);
+internal undefinedt* getAtUndefinedSmallArray(smallArrayt *self, int64_t index);
+internal bool getAtBoolSmallArray(smallArrayt *self, int64_t index);
+internal bool* getAtBoolPSmallArray(smallArrayt *self, int64_t index);
+internal double getAtDoubleSmallArray(smallArrayt *self, int64_t index);
+internal double* getAtDoublePSmallArray(smallArrayt *self, int64_t index);
+internal int64_t getAtIntSmallArray(smallArrayt *self, int64_t index);
+internal int64_t* getAtIntPSmallArray(smallArrayt *self, int64_t index);
+internal int32_t getAtInt32SmallArray(smallArrayt *self, int64_t index);
+internal int32_t* getAtInt32PSmallArray(smallArrayt *self, int64_t index);
+internal uint64_t getAtUintSmallArray(smallArrayt *self, int64_t index);
+internal uint64_t* getAtUintPSmallArray(smallArrayt *self, int64_t index);
+internal uint32_t getAtUint32SmallArray(smallArrayt *self, int64_t index);
+internal uint32_t* getAtUint32PSmallArray(smallArrayt *self, int64_t index);
+internal char* getAtSSmallArray(smallArrayt *self, int64_t index);
+internal smallDictt* getAtDictSmallArray(smallArrayt *self, int64_t index);
+internal smallArrayt* getAtArraySmallArray(smallArrayt *self, int64_t index);
+internal smallBoolt* getAtSmallBoolSmallArray(smallArrayt *self, int64_t index);
+internal smallBytest* getAtSmallBytesSmallArray(smallArrayt *self, int64_t index);
+internal smallDoublet* getAtSmallDoubleSmallArray(smallArrayt *self, int64_t index);
+internal smallIntt* getAtSmallIntSmallArray(smallArrayt *self, int64_t index);
+internal smallJsont* getAtSmallJsonSmallArray(smallArrayt *self, int64_t index);
+internal smallStringt* getAtSmallStringSmallArray(smallArrayt *self, int64_t index);
+internal void* getAtVoidSmallArray(smallArrayt *self, int64_t index);
+internal smallContainert* getAtSmallContainerSmallArray(smallArrayt *self, int64_t index);
+baset* getAtNDupSmallArray(smallArrayt *self, int64_t index);
+internal undefinedt* getAtNDupUndefinedSmallArray(smallArrayt *self, int64_t index);
+internal bool getAtNDupBoolSmallArray(smallArrayt *self, int64_t index);
+internal double getAtNDupDoubleSmallArray(smallArrayt *self, int64_t index);
+internal int64_t getAtNDupIntSmallArray(smallArrayt *self, int64_t index);
+internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, int64_t index);
+internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, int64_t index);
+internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, int64_t index);
+internal char* getAtNDupSSmallArray(smallArrayt *self, int64_t index);
+internal smallDictt* getAtNDupDictSmallArray(smallArrayt *self, int64_t index);
+internal smallArrayt* getAtNDupArraySmallArray(smallArrayt *self, int64_t index);
+internal smallBoolt* getAtNDupSmallBoolSmallArray(smallArrayt *self, int64_t index);
+internal smallBytest* getAtNDupSmallBytesSmallArray(smallArrayt *self, int64_t index);
+internal smallDoublet* getAtNDupSmallDoubleSmallArray(smallArrayt *self, int64_t index);
+internal smallIntt* getAtNDupSmallIntSmallArray(smallArrayt *self, int64_t index);
+internal smallJsont* getAtNDupSmallJsonSmallArray(smallArrayt *self, int64_t index);
+internal smallStringt* getAtNDupSmallStringSmallArray(smallArrayt *self, int64_t index);
+internal void* getAtNDupVoidSmallArray(smallArrayt *self, int64_t index);
+internal smallContainert* getAtNDupSmallContainerSmallArray(smallArrayt *self, int64_t index);
+internal smallArrayt* setAtSmallArray(smallArrayt *self, int64_t index, baset *value);
+internal smallArrayt* setAtUndefinedSmallArray(smallArrayt *self, int64_t index);
+internal smallArrayt* setAtBoolSmallArray(smallArrayt *self, int64_t index, bool value);
+internal smallArrayt* setAtDoubleSmallArray(smallArrayt *self, int64_t index, double value);
+internal smallArrayt* setAtIntSmallArray(smallArrayt *self, int64_t index, int64_t value);
+internal smallArrayt* setAtSSmallArray(smallArrayt *self, int64_t index, const char *string);
+internal smallArrayt* setAtCharSmallArray(smallArrayt *self, int64_t index, char c);
+internal smallArrayt* setAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict);
+internal smallArrayt* setAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array);
+internal smallArrayt* setAtArraycSmallArray(smallArrayt *self, int64_t index, char **array);
+internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value);
+internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value);
+internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value);
+internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value);
+internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value);
+internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string);
+internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container);
+internal smallArrayt* setAtNFreeSmallArray(smallArrayt *self, int64_t index, baset *value);
+internal smallArrayt* setAtNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *undefined);
+internal smallArrayt* setAtNFreeSSmallArray(smallArrayt *self, int64_t index, char *string);
+internal smallArrayt* setAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict);
+internal smallArrayt* setAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array);
+internal smallArrayt* setAtNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **array);
+internal smallArrayt* setAtNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value);
+internal smallArrayt* setAtNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value);
+internal smallArrayt* setAtNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value);
+internal smallArrayt* setAtNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value);
+internal smallArrayt* setAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value);
+internal smallArrayt* setAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string);
+internal smallArrayt* setAtNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container);
+internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict);
+internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array);
+internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json);
+internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string);
+internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict);
+internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array);
+internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json);
+internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string);
+internal double getNumSmallArray(smallArrayt *self, int64_t index);
 internal bool hasSmallArray(smallArrayt *self, baset *value);
 internal bool hasUndefinedSmallArray(smallArrayt *self, undefinedt *undefined);
 internal bool hasBoolSmallArray(smallArrayt *self, bool value);
@@ -436,12 +436,12 @@ internal void forEachSmallArrayF(smallArrayt *self, void *closure, forEachElemen
 internal void enumerateSmallArrayF(smallArrayt *self, void *closure, enumerateElementSmallArrayFt funcElem);
 internal baset* iterStartSmallArray(smallArrayt *self);
 internal baset* iterStartLastSmallArray(smallArrayt *self);
-internal baset* iterStartFromSmallArray(smallArrayt *self, intmax_t index);
-internal baset* iterStartFromStepSmallArray(smallArrayt *self, intmax_t index, intmax_t step);
+internal baset* iterStartFromSmallArray(smallArrayt *self, int64_t index);
+internal baset* iterStartFromStepSmallArray(smallArrayt *self, int64_t index, int64_t step);
 internal baset* iterNextSmallArray(smallArrayt *self);
 internal baset* iterElementSmallArray(smallArrayt *self);
 internal ssize_t iterIndexSmallArray(smallArrayt *self);
-internal intmax_t iterStepSmallArray(smallArrayt *self);
+internal int64_t iterStepSmallArray(smallArrayt *self);
 internal smallStringt* joinSmallArray(smallArrayt *self, const char* delim);
 internal smallStringt* joinCharSmallArray(smallArrayt *self, char c);
 internal smallStringt* joinSmallJsonSmallArray(smallArrayt *self, smallJsont* delim);
@@ -477,23 +477,23 @@ internal bool writeTextSmallStringSmallArray(smallArrayt *self, smallStringt *fi
 internal bool writeStreamSmallArray(smallArrayt *self, FILE *fp);
 internal bool appendTextSmallArray(smallArrayt *self, const char *filePath);
 internal bool appendTextSmallStringSmallArray(smallArrayt *self, smallStringt *filePath);
-internal const char* typeStringSmallArray(smallArrayt *self, intmax_t index);
-internal smallStringt* typeSmallStringSmallArray(smallArrayt *self, intmax_t index);
-internal char typeSmallArray(smallArrayt *self, intmax_t index);
+internal const char* typeStringSmallArray(smallArrayt *self, int64_t index);
+internal smallStringt* typeSmallStringSmallArray(smallArrayt *self, int64_t index);
+internal char typeSmallArray(smallArrayt *self, int64_t index);
 internal char** typeStringsSmallArray(smallArrayt *self);
 internal smallArrayt* typeSmallStringsSmallArray(smallArrayt *self);
 internal smallBytest* typesSmallArray(smallArrayt *self);
-internal bool isETypeSmallArray(smallArrayt *self, intmax_t index, const char *type);
-internal bool isEUndefinedSmallArray(smallArrayt *self, intmax_t index);
-internal bool isEBoolSmallArray(smallArrayt *self, intmax_t index);
-internal bool isEContainerSmallArray(smallArrayt *self, intmax_t index);
-internal bool isEDictSmallArray(smallArrayt *self, intmax_t index);
-internal bool isEDoubleSmallArray(smallArrayt *self, intmax_t index);
-internal bool isEIntSmallArray(smallArrayt *self, intmax_t index);
-internal bool isEStringSmallArray(smallArrayt *self, intmax_t index);
-internal bool isEFaststringSmallArray(smallArrayt *self, intmax_t index);
-internal bool isEArraySmallArray(smallArrayt *self, intmax_t index);
-internal bool isEBytesSmallArray(smallArrayt *self, intmax_t index);
+internal bool isETypeSmallArray(smallArrayt *self, int64_t index, const char *type);
+internal bool isEUndefinedSmallArray(smallArrayt *self, int64_t index);
+internal bool isEBoolSmallArray(smallArrayt *self, int64_t index);
+internal bool isEContainerSmallArray(smallArrayt *self, int64_t index);
+internal bool isEDictSmallArray(smallArrayt *self, int64_t index);
+internal bool isEDoubleSmallArray(smallArrayt *self, int64_t index);
+internal bool isEIntSmallArray(smallArrayt *self, int64_t index);
+internal bool isEStringSmallArray(smallArrayt *self, int64_t index);
+internal bool isEFaststringSmallArray(smallArrayt *self, int64_t index);
+internal bool isEArraySmallArray(smallArrayt *self, int64_t index);
+internal bool isEBytesSmallArray(smallArrayt *self, int64_t index);
 internal bool areAllETypeSmallArray(smallArrayt *self, const char *type);
 internal bool areAllEUndefinedSmallArray(smallArrayt *self);
 internal bool areAllEBoolSmallArray(smallArrayt *self);
@@ -613,91 +613,91 @@ smallJsont*      dequeueSmallJsonSmallArrayG     (smallArrayt *self, smallJsont*
 smallStringt*    dequeueSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED);
 void*            dequeueVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED);
 smallContainert* dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED);
-baset*           getAtSmallArrayG              (smallArrayt *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, intmax_t index);
-bool*            getAtBoolPSmallArrayG         (smallArrayt *self, bool* retType UNUSED, intmax_t index);
-double           getAtDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, intmax_t index);
-double*          getAtDoublePSmallArrayG       (smallArrayt *self, double* retType UNUSED, intmax_t index);
-int64_t          getAtIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, intmax_t index);
-int64_t*         getAtIntPSmallArrayG          (smallArrayt *self, int64_t* retType UNUSED, intmax_t index);
-int32_t          getAtInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, intmax_t index);
-int32_t*         getAtInt32PSmallArrayG        (smallArrayt *self, int32_t* retType UNUSED, intmax_t index);
-uint64_t         getAtUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, intmax_t index);
-uint64_t*        getAtUintPSmallArrayG         (smallArrayt *self, uint64_t* retType UNUSED, intmax_t index);
-uint32_t         getAtUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, intmax_t index);
-uint32_t*        getAtUint32PSmallArrayG       (smallArrayt *self, uint32_t* retType UNUSED, intmax_t index);
-char*            getAtSSmallArrayG             (smallArrayt *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*      getAtSmallBytesSmallArrayG     (smallArrayt *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont* getAtSmallJsonSmallArrayG(smallArrayt *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, intmax_t index);
-baset*           getAtNDupSmallArrayG              (smallArrayt *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtNDupUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtNDupBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, intmax_t index);
-double           getAtNDupDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, intmax_t index);
-int64_t          getAtNDupIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, intmax_t index);
-int32_t          getAtNDupInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, intmax_t index);
-uint64_t         getAtNDupUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, intmax_t index);
-uint32_t         getAtNDupUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, intmax_t index);
-char*            getAtNDupSSmallArrayG             (smallArrayt *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtNDupDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtNDupArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtNDupSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*      getAtNDupSmallBytesSmallArrayG     (smallArrayt *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtNDupSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtNDupSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*      getAtNDupSmallJsonSmallArrayG      (smallArrayt *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtNDupSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtNDupVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, intmax_t index);
-smallArrayt* setAtSmallArrayG         (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value UNUSED);
-smallArrayt* setAtBoolSmallArrayG     (smallArrayt *self, intmax_t index, bool value);
-smallArrayt* setAtDoubleSmallArrayG   (smallArrayt *self, intmax_t index, double value);
-smallArrayt* setAtIntSmallArrayG      (smallArrayt *self, intmax_t index, int64_t value);
-smallArrayt* setAtSSmallArrayG        (smallArrayt *self, intmax_t index, const char *string);
-smallArrayt* setAtCharSmallArrayG(smallArrayt *self, intmax_t index, char c);
-smallArrayt* setAtDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setAtArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setAtArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* setAtCArraycSmallArrayG  (smallArrayt *self, intmax_t index, const char **array);
-smallArrayt* setAtVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* setAtSmallBytesSmallArrayG     (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* setAtSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* setAtSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* setAtSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *value);
-smallArrayt* setAtSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-smallArrayt* setAtNFreeSmallArrayG    (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtNFreeSSmallArrayG        (smallArrayt *self, intmax_t index, char *string);
-smallArrayt* setAtNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setAtNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setAtNFreeArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* setAtNFreeSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* setAtNFreeSmallBytesSmallArrayG     (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* setAtNFreeSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* setAtNFreeSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* setAtNFreeSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *value);
-smallArrayt* setAtNFreeSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-smallArrayt* setPAtDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setPAtArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setPAtSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *json);
-smallArrayt* setPAtSmallStringSmallArrayG     (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* setPAtNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setPAtNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setPAtNFreeSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *json);
-smallArrayt* setPAtNFreeSmallStringSmallArrayG     (smallArrayt *self, intmax_t index, smallStringt *string);
-double getNumSmallArrayG(smallArrayt *self, intmax_t index);
+baset*           getAtSmallArrayG              (smallArrayt *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, int64_t index);
+bool*            getAtBoolPSmallArrayG         (smallArrayt *self, bool* retType UNUSED, int64_t index);
+double           getAtDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, int64_t index);
+double*          getAtDoublePSmallArrayG       (smallArrayt *self, double* retType UNUSED, int64_t index);
+int64_t          getAtIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, int64_t index);
+int64_t*         getAtIntPSmallArrayG          (smallArrayt *self, int64_t* retType UNUSED, int64_t index);
+int32_t          getAtInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, int64_t index);
+int32_t*         getAtInt32PSmallArrayG        (smallArrayt *self, int32_t* retType UNUSED, int64_t index);
+uint64_t         getAtUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, int64_t index);
+uint64_t*        getAtUintPSmallArrayG         (smallArrayt *self, uint64_t* retType UNUSED, int64_t index);
+uint32_t         getAtUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, int64_t index);
+uint32_t*        getAtUint32PSmallArrayG       (smallArrayt *self, uint32_t* retType UNUSED, int64_t index);
+char*            getAtSSmallArrayG             (smallArrayt *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*      getAtSmallBytesSmallArrayG     (smallArrayt *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont* getAtSmallJsonSmallArrayG(smallArrayt *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index);
+baset*           getAtNDupSmallArrayG              (smallArrayt *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtNDupUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtNDupBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, int64_t index);
+double           getAtNDupDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, int64_t index);
+int64_t          getAtNDupIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, int64_t index);
+int32_t          getAtNDupInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, int64_t index);
+uint64_t         getAtNDupUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, int64_t index);
+uint32_t         getAtNDupUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, int64_t index);
+char*            getAtNDupSSmallArrayG             (smallArrayt *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtNDupDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtNDupArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtNDupSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*      getAtNDupSmallBytesSmallArrayG     (smallArrayt *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtNDupSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtNDupSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*      getAtNDupSmallJsonSmallArrayG      (smallArrayt *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtNDupSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtNDupVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index);
+smallArrayt* setAtSmallArrayG         (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED);
+smallArrayt* setAtBoolSmallArrayG     (smallArrayt *self, int64_t index, bool value);
+smallArrayt* setAtDoubleSmallArrayG   (smallArrayt *self, int64_t index, double value);
+smallArrayt* setAtIntSmallArrayG      (smallArrayt *self, int64_t index, int64_t value);
+smallArrayt* setAtSSmallArrayG        (smallArrayt *self, int64_t index, const char *string);
+smallArrayt* setAtCharSmallArrayG(smallArrayt *self, int64_t index, char c);
+smallArrayt* setAtDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setAtArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setAtArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* setAtCArraycSmallArrayG  (smallArrayt *self, int64_t index, const char **array);
+smallArrayt* setAtVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* setAtSmallBytesSmallArrayG     (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* setAtSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* setAtSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* setAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value);
+smallArrayt* setAtSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+smallArrayt* setAtNFreeSmallArrayG    (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtNFreeSSmallArrayG        (smallArrayt *self, int64_t index, char *string);
+smallArrayt* setAtNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setAtNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setAtNFreeArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* setAtNFreeSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* setAtNFreeSmallBytesSmallArrayG     (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* setAtNFreeSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* setAtNFreeSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* setAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value);
+smallArrayt* setAtNFreeSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+smallArrayt* setPAtDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setPAtArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setPAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json);
+smallArrayt* setPAtSmallStringSmallArrayG     (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* setPAtNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setPAtNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setPAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json);
+smallArrayt* setPAtNFreeSmallStringSmallArrayG     (smallArrayt *self, int64_t index, smallStringt *string);
+double getNumSmallArrayG(smallArrayt *self, int64_t index);
 smallArrayt* reverseSmallArrayG       (smallArrayt *self);
 smallArrayt* appendSmallArrayG        (smallArrayt *self, smallArrayt *array);
 smallArrayt* appendSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json);
@@ -711,68 +711,68 @@ smallArrayt* shiftSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json);
 smallArrayt* shiftNSmashSmallArrayG   (smallArrayt *self, smallArrayt *array);
 smallArrayt* shiftNSmashSmallJsonSmallArrayG(smallArrayt *self, smallJsont *json);
 smallArrayt* addSmallArrayG  (smallArrayt *self, smallArrayt *array);
-smallArrayt*          sliceSmallArrayG(smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* cropSmallArrayG                      (smallArrayt *self, intmax_t start, intmax_t end);
-baset* cropElemSmallArrayG                        (smallArrayt *self, intmax_t index);
-undefinedt* cropElemUndefinedSmallArrayG          (smallArrayt *self, intmax_t index);
-bool cropElemBoolSmallArrayG                      (smallArrayt *self, intmax_t index);
-double cropElemDoubleSmallArrayG                  (smallArrayt *self, intmax_t index);
-int64_t cropElemIntSmallArrayG                    (smallArrayt *self, intmax_t index);
-int32_t cropElemInt32SmallArrayG                  (smallArrayt *self, intmax_t index);
-uint64_t cropElemUintSmallArrayG                  (smallArrayt *self, intmax_t index);
-uint32_t cropElemUint32SmallArrayG                (smallArrayt *self, intmax_t index);
-char* cropElemSSmallArrayG                        (smallArrayt *self, intmax_t index);
-smallDictt* cropElemDictSmallArrayG               (smallArrayt *self, intmax_t index);
-smallArrayt* cropElemArraySmallArrayG             (smallArrayt *self, intmax_t index);
-smallBoolt* cropElemSmallBoolSmallArrayG          (smallArrayt *self, intmax_t index);
-smallBytest* cropElemSmallBytesSmallArrayG        (smallArrayt *self, intmax_t index);
-smallDoublet* cropElemSmallDoubleSmallArrayG      (smallArrayt *self, intmax_t index);
-smallIntt* cropElemSmallIntSmallArrayG            (smallArrayt *self, intmax_t index);
-smallJsont* cropElemSmallJsonSmallArrayG          (smallArrayt *self, intmax_t index);
-smallStringt* cropElemSmallStringSmallArrayG      (smallArrayt *self, intmax_t index);
-void* cropElemVoidSmallArrayG                     (smallArrayt *self, intmax_t index);
-smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, intmax_t index);
-smallArrayt* copySmallArrayG (smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt*          insertSmallArrayG(smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-smallArrayt* insertSmallJsonSmallArrayG      (smallArrayt *self, intmax_t index, smallJsont *toInsert);
-smallArrayt*          insertNSmashSmallArrayG(smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *toInsert);
-smallArrayt* injectSmallArrayG         (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value UNUSED);
-smallArrayt* injectBoolSmallArrayG     (smallArrayt *self, intmax_t index, bool value);
-smallArrayt* injectDoubleSmallArrayG   (smallArrayt *self, intmax_t index, double value);
-smallArrayt* injectIntSmallArrayG      (smallArrayt *self, intmax_t index, int64_t value);
-smallArrayt* injectSSmallArrayG        (smallArrayt *self, intmax_t index, const char *string);
-smallArrayt* injectCharSmallArrayG(smallArrayt *self, intmax_t index, char c);
-smallArrayt* injectDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* injectArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* injectArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* injectCArraycSmallArrayG   (smallArrayt *self, intmax_t index, const char **array);
-smallArrayt* injectVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* injectSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* injectSmallBytesSmallArrayG     (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* injectSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* injectSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* injectSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *string);
-smallArrayt* injectSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-smallArrayt* injectNFreeSmallArrayG    (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, intmax_t index, undefinedt *value);
-smallArrayt* injectNFreeSSmallArrayG        (smallArrayt *self, intmax_t index, char *string);
-smallArrayt* injectNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* injectNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* injectNFreeArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* injectNFreeSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* injectNFreeSmallBytesSmallArrayG     (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* injectNFreeSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* injectNFreeSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* injectNFreeSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *string);
-smallArrayt* injectNFreeSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-smallArrayt* delSmallArrayG           (smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* delElemSmallArrayG       (smallArrayt *self, intmax_t index);
-smallArrayt* removeSmallArrayG        (smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* removeElemSmallArrayG    (smallArrayt *self, intmax_t index);
+smallArrayt*          sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* cropSmallArrayG                      (smallArrayt *self, int64_t start, int64_t end);
+baset* cropElemSmallArrayG                        (smallArrayt *self, int64_t index);
+undefinedt* cropElemUndefinedSmallArrayG          (smallArrayt *self, int64_t index);
+bool cropElemBoolSmallArrayG                      (smallArrayt *self, int64_t index);
+double cropElemDoubleSmallArrayG                  (smallArrayt *self, int64_t index);
+int64_t cropElemIntSmallArrayG                    (smallArrayt *self, int64_t index);
+int32_t cropElemInt32SmallArrayG                  (smallArrayt *self, int64_t index);
+uint64_t cropElemUintSmallArrayG                  (smallArrayt *self, int64_t index);
+uint32_t cropElemUint32SmallArrayG                (smallArrayt *self, int64_t index);
+char* cropElemSSmallArrayG                        (smallArrayt *self, int64_t index);
+smallDictt* cropElemDictSmallArrayG               (smallArrayt *self, int64_t index);
+smallArrayt* cropElemArraySmallArrayG             (smallArrayt *self, int64_t index);
+smallBoolt* cropElemSmallBoolSmallArrayG          (smallArrayt *self, int64_t index);
+smallBytest* cropElemSmallBytesSmallArrayG        (smallArrayt *self, int64_t index);
+smallDoublet* cropElemSmallDoubleSmallArrayG      (smallArrayt *self, int64_t index);
+smallIntt* cropElemSmallIntSmallArrayG            (smallArrayt *self, int64_t index);
+smallJsont* cropElemSmallJsonSmallArrayG          (smallArrayt *self, int64_t index);
+smallStringt* cropElemSmallStringSmallArrayG      (smallArrayt *self, int64_t index);
+void* cropElemVoidSmallArrayG                     (smallArrayt *self, int64_t index);
+smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index);
+smallArrayt* copySmallArrayG (smallArrayt *self, int64_t start, int64_t end);
+smallArrayt*          insertSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert);
+smallArrayt* insertSmallJsonSmallArrayG      (smallArrayt *self, int64_t index, smallJsont *toInsert);
+smallArrayt*          insertNSmashSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert);
+smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert);
+smallArrayt* injectSmallArrayG         (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED);
+smallArrayt* injectBoolSmallArrayG     (smallArrayt *self, int64_t index, bool value);
+smallArrayt* injectDoubleSmallArrayG   (smallArrayt *self, int64_t index, double value);
+smallArrayt* injectIntSmallArrayG      (smallArrayt *self, int64_t index, int64_t value);
+smallArrayt* injectSSmallArrayG        (smallArrayt *self, int64_t index, const char *string);
+smallArrayt* injectCharSmallArrayG(smallArrayt *self, int64_t index, char c);
+smallArrayt* injectDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* injectArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* injectArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* injectCArraycSmallArrayG   (smallArrayt *self, int64_t index, const char **array);
+smallArrayt* injectVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* injectSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* injectSmallBytesSmallArrayG     (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* injectSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* injectSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* injectSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *string);
+smallArrayt* injectSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+smallArrayt* injectNFreeSmallArrayG    (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value);
+smallArrayt* injectNFreeSSmallArrayG        (smallArrayt *self, int64_t index, char *string);
+smallArrayt* injectNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* injectNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* injectNFreeArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* injectNFreeSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* injectNFreeSmallBytesSmallArrayG     (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* injectNFreeSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* injectNFreeSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* injectNFreeSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *string);
+smallArrayt* injectNFreeSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+smallArrayt* delSmallArrayG           (smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* delElemSmallArrayG       (smallArrayt *self, int64_t index);
+smallArrayt* removeSmallArrayG        (smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* removeElemSmallArrayG    (smallArrayt *self, int64_t index);
 smallArrayt* sortSmallArrayG          (smallArrayt *self);
 smallArrayt* sortFSmallArrayG(smallArrayt *self, shCmpt compareFunction);
 smallArrayt* icSortSmallArrayG          (smallArrayt *self);
@@ -910,7 +910,7 @@ bool writeTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath);
 bool writeStreamSmallArrayG          (smallArrayt *self, FILE *fp);
 bool appendTextSmallArrayG(smallArrayt *self, const char *filePath);
 bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath);
-smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, intmax_t index);
+smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, int64_t index);
 smallArrayt* typeSmallStringsSmallArrayG(smallArrayt *self);
 
 void initiateSmallArray(smallArrayt *self) {
@@ -3782,7 +3782,7 @@ internal smallArrayt* addSmallArray(smallArrayt *self, smallArrayt *array) {
   return(r);
 }
 
-internal smallArrayt* sliceSmallArray(smallArrayt *self, intmax_t start, intmax_t end) {
+internal smallArrayt* sliceSmallArray(smallArrayt *self, int64_t start, int64_t end) {
   size_t len;
 
   len = lenSmallArray(self);
@@ -3791,17 +3791,17 @@ internal smallArrayt* sliceSmallArray(smallArrayt *self, intmax_t start, intmax_
     return(NULL);
   }
 
-  if (start > (intmax_t)len) {
+  if (start > (int64_t)len) {
     emptySmallArray(self);
     return(NULL);
   }
-  if (end > (intmax_t)len) {
+  if (end > (int64_t)len) {
     end = len;
   }
-  if (start <= -(intmax_t)len) {
+  if (start <= -(int64_t)len) {
     start = -len;
   }
-  if (end <= -(intmax_t)len) {
+  if (end <= -(int64_t)len) {
     emptySmallArray(self);
     return(NULL);
   }
@@ -3831,7 +3831,7 @@ internal smallArrayt* sliceSmallArray(smallArrayt *self, intmax_t start, intmax_
   return(self);
 }
 
-internal smallArrayt* cropSmallArray(smallArrayt *self, intmax_t start, intmax_t end) {
+internal smallArrayt* cropSmallArray(smallArrayt *self, int64_t start, int64_t end) {
   size_t len;
   smallt *o = NULL;
 
@@ -3841,16 +3841,16 @@ internal smallArrayt* cropSmallArray(smallArrayt *self, intmax_t start, intmax_t
     return(NULL);
   }
 
-  if (start > (intmax_t)len) {
+  if (start > (int64_t)len) {
     return(NULL);
   }
-  if (end > (intmax_t)len) {
+  if (end > (int64_t)len) {
     end = len;
   }
-  if (start <= -(intmax_t)len) {
+  if (start <= -(int64_t)len) {
     start = -len;
   }
-  if (end <= -(intmax_t)len) {
+  if (end <= -(int64_t)len) {
     return(NULL);
   }
   if (start < 0) {
@@ -3870,10 +3870,10 @@ internal smallArrayt* cropSmallArray(smallArrayt *self, intmax_t start, intmax_t
 
   if (start < end) {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
 
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       o = sArrayGetTiny(self->a, start+i);
       sArrayPushTiny(&(r->a), o);
     }
@@ -3891,13 +3891,13 @@ internal smallArrayt* cropSmallArray(smallArrayt *self, intmax_t start, intmax_t
   return(r);
 }
 
-internal baset* cropElemSmallArray(smallArrayt *self, intmax_t index) {
+internal baset* cropElemSmallArray(smallArrayt *self, int64_t index) {
   baset *r = NULL;
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -3941,12 +3941,12 @@ internal baset* cropElemSmallArray(smallArrayt *self, intmax_t index) {
 }
 
 
-internal undefinedt* cropElemUndefinedSmallArray(smallArrayt *self, intmax_t index) {
+internal undefinedt* cropElemUndefinedSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -3977,12 +3977,12 @@ internal undefinedt* cropElemUndefinedSmallArray(smallArrayt *self, intmax_t ind
 }
 
 
-internal bool cropElemBoolSmallArray(smallArrayt *self, intmax_t index) {
+internal bool cropElemBoolSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(false);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(false);
   }
   if (index < 0) {
@@ -4019,12 +4019,12 @@ internal bool cropElemBoolSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal double cropElemDoubleSmallArray(smallArrayt *self, intmax_t index) {
+internal double cropElemDoubleSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(0);
   }
   if (index < 0) {
@@ -4061,12 +4061,12 @@ internal double cropElemDoubleSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal int64_t cropElemIntSmallArray(smallArrayt *self, intmax_t index) {
+internal int64_t cropElemIntSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(0);
   }
   if (index < 0) {
@@ -4104,12 +4104,12 @@ internal int64_t cropElemIntSmallArray(smallArrayt *self, intmax_t index) {
 }
 
 
-internal int32_t cropElemInt32SmallArray(smallArrayt *self, intmax_t index) {
+internal int32_t cropElemInt32SmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(0);
   }
   if (index < 0) {
@@ -4146,12 +4146,12 @@ internal int32_t cropElemInt32SmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal uint64_t cropElemUintSmallArray(smallArrayt *self, intmax_t index) {
+internal uint64_t cropElemUintSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(0);
   }
   if (index < 0) {
@@ -4188,12 +4188,12 @@ internal uint64_t cropElemUintSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal uint32_t cropElemUint32SmallArray(smallArrayt *self, intmax_t index) {
+internal uint32_t cropElemUint32SmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(0);
   }
   if (index < 0) {
@@ -4230,12 +4230,12 @@ internal uint32_t cropElemUint32SmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal char* cropElemSSmallArray(smallArrayt *self, intmax_t index) {
+internal char* cropElemSSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4272,12 +4272,12 @@ internal char* cropElemSSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal smallDictt* cropElemDictSmallArray(smallArrayt *self, intmax_t index) {
+internal smallDictt* cropElemDictSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4309,12 +4309,12 @@ internal smallDictt* cropElemDictSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal smallArrayt* cropElemArraySmallArray(smallArrayt *self, intmax_t index) {
+internal smallArrayt* cropElemArraySmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4346,12 +4346,12 @@ internal smallArrayt* cropElemArraySmallArray(smallArrayt *self, intmax_t index)
   return(r);
 }
 
-internal smallBoolt* cropElemSmallBoolSmallArray(smallArrayt *self, intmax_t index) {
+internal smallBoolt* cropElemSmallBoolSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4383,12 +4383,12 @@ internal smallBoolt* cropElemSmallBoolSmallArray(smallArrayt *self, intmax_t ind
   return(r);
 }
 
-internal smallBytest* cropElemSmallBytesSmallArray(smallArrayt *self, intmax_t index) {
+internal smallBytest* cropElemSmallBytesSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4420,12 +4420,12 @@ internal smallBytest* cropElemSmallBytesSmallArray(smallArrayt *self, intmax_t i
   return(r);
 }
 
-internal smallDoublet* cropElemSmallDoubleSmallArray(smallArrayt *self, intmax_t index) {
+internal smallDoublet* cropElemSmallDoubleSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4457,12 +4457,12 @@ internal smallDoublet* cropElemSmallDoubleSmallArray(smallArrayt *self, intmax_t
   return(r);
 }
 
-internal smallIntt* cropElemSmallIntSmallArray(smallArrayt *self, intmax_t index) {
+internal smallIntt* cropElemSmallIntSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4494,12 +4494,12 @@ internal smallIntt* cropElemSmallIntSmallArray(smallArrayt *self, intmax_t index
   return(r);
 }
 
-internal smallJsont* cropElemSmallJsonSmallArray(smallArrayt *self, intmax_t index) {
+internal smallJsont* cropElemSmallJsonSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4537,12 +4537,12 @@ internal smallJsont* cropElemSmallJsonSmallArray(smallArrayt *self, intmax_t ind
   return(r);
 }
 
-internal smallStringt* cropElemSmallStringSmallArray(smallArrayt *self, intmax_t index) {
+internal smallStringt* cropElemSmallStringSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4574,12 +4574,12 @@ internal smallStringt* cropElemSmallStringSmallArray(smallArrayt *self, intmax_t
   return(r);
 }
 
-internal void* cropElemVoidSmallArray(smallArrayt *self, intmax_t index) {
+internal void* cropElemVoidSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4616,12 +4616,12 @@ internal void* cropElemVoidSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal smallContainert* cropElemSmallContainerSmallArray(smallArrayt *self, intmax_t index) {
+internal smallContainert* cropElemSmallContainerSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4653,7 +4653,7 @@ internal smallContainert* cropElemSmallContainerSmallArray(smallArrayt *self, in
   return(r);
 }
 
-internal smallArrayt* copySmallArray(smallArrayt *self, intmax_t start, intmax_t end) {
+internal smallArrayt* copySmallArray(smallArrayt *self, int64_t start, int64_t end) {
   size_t len;
   smallt *o = NULL;
 
@@ -4663,16 +4663,16 @@ internal smallArrayt* copySmallArray(smallArrayt *self, intmax_t start, intmax_t
     return(NULL);
   }
 
-  if (start >= (intmax_t)len) {
+  if (start >= (int64_t)len) {
     return(NULL);
   }
-  if (end > (intmax_t)len) {
+  if (end > (int64_t)len) {
     end = len;
   }
-  if (start <= -(intmax_t)len) {
+  if (start <= -(int64_t)len) {
     start = -len;
   }
-  if (end <= -(intmax_t)len) {
+  if (end <= -(int64_t)len) {
     return(NULL);
   }
   if (start < 0) {
@@ -4696,10 +4696,10 @@ internal smallArrayt* copySmallArray(smallArrayt *self, intmax_t start, intmax_t
   }
   else {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
 
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       o = sArrayGetTiny(self->a, start+i);
       sArrayPushTiny(&(r->a), sDuplicate(o));
   }
@@ -4708,7 +4708,7 @@ internal smallArrayt* copySmallArray(smallArrayt *self, intmax_t start, intmax_t
   return(r);
 }
 
-internal smallArrayt* insertSmallArray(smallArrayt *self, intmax_t index, smallArrayt *toInsert) {
+internal smallArrayt* insertSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert) {
   size_t len;;
 
   //sanity checks
@@ -4735,13 +4735,13 @@ internal smallArrayt* insertSmallArray(smallArrayt *self, intmax_t index, smallA
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -4761,26 +4761,26 @@ internal smallArrayt* insertSmallArray(smallArrayt *self, intmax_t index, smallA
   smallt *o;
   if (index == 0) {
     // insert at beginning
-    for (intmax_t i=0;i < (intmax_t)toInsert->f->len(toInsert);i++) {
+    for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) {
       o = sArrayGetTiny(toInsert->a, i);
       sArrayPushTiny(&a, o);
     }
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
     }
   else {
 
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
     }
-    for (intmax_t i=0;i < (intmax_t)toInsert->f->len(toInsert);i++) {
+    for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) {
       o = sArrayGetTiny(toInsert->a, i);
       sArrayPushTiny(&a, o);
     }
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -4791,7 +4791,7 @@ internal smallArrayt* insertSmallArray(smallArrayt *self, intmax_t index, smallA
   return(self);
 }
 
-internal smallArrayt* insertSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *toInsert) {
+internal smallArrayt* insertSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert) {
 
   if (!toInsert) {
     return(NULL);
@@ -4816,7 +4816,7 @@ internal smallArrayt* insertSmallJsonSmallArray(smallArrayt *self, intmax_t inde
   return(insertSmallArray(self, index, &a));
 }
 
-internal smallArrayt* insertNSmashSmallArray(smallArrayt *self, intmax_t index, smallArrayt *toInsert) {
+internal smallArrayt* insertNSmashSmallArray(smallArrayt *self, int64_t index, smallArrayt *toInsert) {
   smallArrayt *r = NULL;
 
   r = insertSmallArray(self, index, toInsert);
@@ -4826,7 +4826,7 @@ internal smallArrayt* insertNSmashSmallArray(smallArrayt *self, intmax_t index, 
   return(r);
 }
 
-internal smallArrayt* insertNSmashSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *toInsert) {
+internal smallArrayt* insertNSmashSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInsert) {
   smallArrayt *r = NULL;
 
   r = insertSmallJsonSmallArray(self, index, toInsert);
@@ -4837,7 +4837,7 @@ internal smallArrayt* insertNSmashSmallJsonSmallArray(smallArrayt *self, intmax_
 }
 
 
-internal smallArrayt* injectSmallArray(smallArrayt *self, intmax_t index, baset *toInject) {
+internal smallArrayt* injectSmallArray(smallArrayt *self, int64_t index, baset *toInject) {
   size_t len;
 
   if (!toInject) {
@@ -4855,13 +4855,13 @@ internal smallArrayt* injectSmallArray(smallArrayt *self, intmax_t index, baset 
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -4879,7 +4879,7 @@ internal smallArrayt* injectSmallArray(smallArrayt *self, intmax_t index, baset 
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -4887,12 +4887,12 @@ internal smallArrayt* injectSmallArray(smallArrayt *self, intmax_t index, baset 
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -4903,7 +4903,7 @@ internal smallArrayt* injectSmallArray(smallArrayt *self, intmax_t index, baset 
   return(self);
 }
 
-internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, intmax_t index) {
+internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, int64_t index) {
   size_t len;
 
   len = lenSmallArray(self);
@@ -4917,13 +4917,13 @@ internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, intmax_t inde
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -4941,7 +4941,7 @@ internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, intmax_t inde
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -4949,12 +4949,12 @@ internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, intmax_t inde
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -4965,7 +4965,7 @@ internal smallArrayt* injectUndefinedSmallArray(smallArrayt *self, intmax_t inde
   return(self);
 }
 
-internal smallArrayt* injectBoolSmallArray(smallArrayt *self, intmax_t index, bool toInject) {
+internal smallArrayt* injectBoolSmallArray(smallArrayt *self, int64_t index, bool toInject) {
   size_t len;
 
   len = lenSmallArray(self);
@@ -4979,13 +4979,13 @@ internal smallArrayt* injectBoolSmallArray(smallArrayt *self, intmax_t index, bo
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -5004,7 +5004,7 @@ internal smallArrayt* injectBoolSmallArray(smallArrayt *self, intmax_t index, bo
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5012,12 +5012,12 @@ internal smallArrayt* injectBoolSmallArray(smallArrayt *self, intmax_t index, bo
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5028,7 +5028,7 @@ internal smallArrayt* injectBoolSmallArray(smallArrayt *self, intmax_t index, bo
   return(self);
 }
 
-internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, intmax_t index, double toInject) {
+internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, int64_t index, double toInject) {
   size_t len;
 
   len = lenSmallArray(self);
@@ -5042,13 +5042,13 @@ internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, intmax_t index, 
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -5067,7 +5067,7 @@ internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, intmax_t index, 
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5075,12 +5075,12 @@ internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, intmax_t index, 
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5091,7 +5091,7 @@ internal smallArrayt* injectDoubleSmallArray(smallArrayt *self, intmax_t index, 
   return(self);
 }
 
-internal smallArrayt* injectIntSmallArray(smallArrayt *self, intmax_t index, int64_t toInject) {
+internal smallArrayt* injectIntSmallArray(smallArrayt *self, int64_t index, int64_t toInject) {
   size_t len;
 
   len = lenSmallArray(self);
@@ -5105,13 +5105,13 @@ internal smallArrayt* injectIntSmallArray(smallArrayt *self, intmax_t index, int
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -5130,7 +5130,7 @@ internal smallArrayt* injectIntSmallArray(smallArrayt *self, intmax_t index, int
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5138,12 +5138,12 @@ internal smallArrayt* injectIntSmallArray(smallArrayt *self, intmax_t index, int
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5154,7 +5154,7 @@ internal smallArrayt* injectIntSmallArray(smallArrayt *self, intmax_t index, int
   return(self);
 }
 
-internal smallArrayt* injectSSmallArray(smallArrayt *self, intmax_t index, const char *toInject) {
+internal smallArrayt* injectSSmallArray(smallArrayt *self, int64_t index, const char *toInject) {
   size_t len;
 
   if (!toInject) {
@@ -5172,13 +5172,13 @@ internal smallArrayt* injectSSmallArray(smallArrayt *self, intmax_t index, const
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -5196,7 +5196,7 @@ internal smallArrayt* injectSSmallArray(smallArrayt *self, intmax_t index, const
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5204,12 +5204,12 @@ internal smallArrayt* injectSSmallArray(smallArrayt *self, intmax_t index, const
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5220,13 +5220,13 @@ internal smallArrayt* injectSSmallArray(smallArrayt *self, intmax_t index, const
   return(self);
 }
 
-internal smallArrayt* injectCharSmallArray(smallArrayt *self, intmax_t index, char c) {
+internal smallArrayt* injectCharSmallArray(smallArrayt *self, int64_t index, char c) {
 
   charToS(s, c);
   return(injectSSmallArray(self, index, s));
 }
 
-internal smallArrayt* injectDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *toInject) {
+internal smallArrayt* injectDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject) {
   size_t len;
 
   if (!toInject) {
@@ -5248,13 +5248,13 @@ internal smallArrayt* injectDictSmallArray(smallArrayt *self, intmax_t index, sm
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -5276,7 +5276,7 @@ internal smallArrayt* injectDictSmallArray(smallArrayt *self, intmax_t index, sm
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5284,12 +5284,12 @@ internal smallArrayt* injectDictSmallArray(smallArrayt *self, intmax_t index, sm
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5300,7 +5300,7 @@ internal smallArrayt* injectDictSmallArray(smallArrayt *self, intmax_t index, sm
   return(self);
 }
 
-internal smallArrayt* injectArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *toInject) {
+internal smallArrayt* injectArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject) {
   size_t len;
 
   if (!toInject) {
@@ -5322,13 +5322,13 @@ internal smallArrayt* injectArraySmallArray(smallArrayt *self, intmax_t index, s
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -5350,7 +5350,7 @@ internal smallArrayt* injectArraySmallArray(smallArrayt *self, intmax_t index, s
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5358,12 +5358,12 @@ internal smallArrayt* injectArraySmallArray(smallArrayt *self, intmax_t index, s
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5374,7 +5374,7 @@ internal smallArrayt* injectArraySmallArray(smallArrayt *self, intmax_t index, s
   return(self);
 }
 
-internal smallArrayt* injectArraycSmallArray(smallArrayt *self, intmax_t index, char **toInject) {
+internal smallArrayt* injectArraycSmallArray(smallArrayt *self, int64_t index, char **toInject) {
   size_t len;
 
   if (!toInject) {
@@ -5392,13 +5392,13 @@ internal smallArrayt* injectArraycSmallArray(smallArrayt *self, intmax_t index, 
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -5432,7 +5432,7 @@ internal smallArrayt* injectArraycSmallArray(smallArrayt *self, intmax_t index, 
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5440,12 +5440,12 @@ internal smallArrayt* injectArraycSmallArray(smallArrayt *self, intmax_t index, 
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5456,7 +5456,7 @@ internal smallArrayt* injectArraycSmallArray(smallArrayt *self, intmax_t index, 
   return(self);
 }
 
-internal smallArrayt* injectSmallBoolSmallArray(smallArrayt *self, intmax_t index, smallBoolt *toInject) {
+internal smallArrayt* injectSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -5473,7 +5473,7 @@ internal smallArrayt* injectSmallBoolSmallArray(smallArrayt *self, intmax_t inde
   return(injectSmallArray(self, index, (baset*)toInject));
 }
 
-internal smallArrayt* injectSmallBytesSmallArray(smallArrayt *self, intmax_t index, smallBytest *toInject) {
+internal smallArrayt* injectSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -5490,7 +5490,7 @@ internal smallArrayt* injectSmallBytesSmallArray(smallArrayt *self, intmax_t ind
   return(injectSmallArray(self, index, (baset*)toInject));
 }
 
-internal smallArrayt* injectSmallDoubleSmallArray(smallArrayt *self, intmax_t index, smallDoublet *toInject) {
+internal smallArrayt* injectSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -5507,7 +5507,7 @@ internal smallArrayt* injectSmallDoubleSmallArray(smallArrayt *self, intmax_t in
   return(injectSmallArray(self, index, (baset*)toInject));
 }
 
-internal smallArrayt* injectSmallIntSmallArray(smallArrayt *self, intmax_t index, smallIntt *toInject) {
+internal smallArrayt* injectSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -5524,7 +5524,7 @@ internal smallArrayt* injectSmallIntSmallArray(smallArrayt *self, intmax_t index
   return(injectSmallArray(self, index, (baset*)toInject));
 }
 
-internal smallArrayt* injectSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *toInject) {
+internal smallArrayt* injectSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -5548,7 +5548,7 @@ internal smallArrayt* injectSmallJsonSmallArray(smallArrayt *self, intmax_t inde
   return(r);
 }
 
-internal smallArrayt* injectSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *toInject) {
+internal smallArrayt* injectSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -5565,7 +5565,7 @@ internal smallArrayt* injectSmallStringSmallArray(smallArrayt *self, intmax_t in
   return(injectSmallArray(self, index, (baset*)toInject));
 }
 
-internal smallArrayt* injectSmallContainerSmallArray(smallArrayt *self, intmax_t index, smallContainert *toInject) {
+internal smallArrayt* injectSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -5582,7 +5582,7 @@ internal smallArrayt* injectSmallContainerSmallArray(smallArrayt *self, intmax_t
   return(injectSmallArray(self, index, (baset*)toInject));
 }
 
-internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, intmax_t index, baset *toInject) {
+internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, int64_t index, baset *toInject) {
   size_t len;
 
   if (!toInject) {
@@ -5600,13 +5600,13 @@ internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, intmax_t index, b
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -5628,7 +5628,7 @@ internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, intmax_t index, b
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5636,12 +5636,12 @@ internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, intmax_t index, b
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->a, i);
       sArrayPushTiny(&a, o);
   }
@@ -5653,7 +5653,7 @@ internal smallArrayt* injectNFreeSmallArray(smallArrayt *self, intmax_t index, b
   return(self);
 }
 
-internal smallArrayt* injectNFreeUndefinedSmallArray(smallArrayt *self, intmax_t index, undefinedt *undefined) {
+internal smallArrayt* injectNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *undefined) {
 
   smallArrayt *r = injectUndefinedSmallArray(self, index);
   if (r) {
@@ -5662,7 +5662,7 @@ internal smallArrayt* injectNFreeUndefinedSmallArray(smallArrayt *self, intmax_t
   return(r);
 }
 
-internal smallArrayt* injectNFreeSSmallArray(smallArrayt *self, intmax_t index, char *toInject) {
+internal smallArrayt* injectNFreeSSmallArray(smallArrayt *self, int64_t index, char *toInject) {
 
   smallArrayt *r = injectSSmallArray(self, index, toInject);
   if (r) {
@@ -5671,7 +5671,7 @@ internal smallArrayt* injectNFreeSSmallArray(smallArrayt *self, intmax_t index, 
   return(r);
 }
 
-internal smallArrayt* injectNFreeDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *toInject) {
+internal smallArrayt* injectNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *toInject) {
 
   smallArrayt *r = injectDictSmallArray(self, index, toInject);
   if (r) {
@@ -5680,7 +5680,7 @@ internal smallArrayt* injectNFreeDictSmallArray(smallArrayt *self, intmax_t inde
   return(r);
 }
 
-internal smallArrayt* injectNFreeArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *toInject) {
+internal smallArrayt* injectNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *toInject) {
 
   smallArrayt *r = injectArraySmallArray(self, index, toInject);
   if (r) {
@@ -5689,7 +5689,7 @@ internal smallArrayt* injectNFreeArraySmallArray(smallArrayt *self, intmax_t ind
   return(r);
 }
 
-internal smallArrayt* injectNFreeArraycSmallArray(smallArrayt *self, intmax_t index, char **toInject) {
+internal smallArrayt* injectNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **toInject) {
 
   smallArrayt *r = injectArraycSmallArray(self, index, toInject);
   if (r) {
@@ -5698,7 +5698,7 @@ internal smallArrayt* injectNFreeArraycSmallArray(smallArrayt *self, intmax_t in
   return(r);
 }
 
-internal smallArrayt* injectNFreeSmallBoolSmallArray(smallArrayt *self, intmax_t index, smallBoolt *toInject) {
+internal smallArrayt* injectNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *toInject) {
 
   smallArrayt *r = injectSmallBoolSmallArray(self, index, toInject);
   if (r) {
@@ -5707,7 +5707,7 @@ internal smallArrayt* injectNFreeSmallBoolSmallArray(smallArrayt *self, intmax_t
   return(r);
 }
 
-internal smallArrayt* injectNFreeSmallBytesSmallArray(smallArrayt *self, intmax_t index, smallBytest *toInject) {
+internal smallArrayt* injectNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *toInject) {
 
   smallArrayt *r = injectSmallBytesSmallArray(self, index, toInject);
   if (r) {
@@ -5716,7 +5716,7 @@ internal smallArrayt* injectNFreeSmallBytesSmallArray(smallArrayt *self, intmax_
   return(r);
 }
 
-internal smallArrayt* injectNFreeSmallDoubleSmallArray(smallArrayt *self, intmax_t index, smallDoublet *toInject) {
+internal smallArrayt* injectNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *toInject) {
 
   smallArrayt *r = injectSmallDoubleSmallArray(self, index, toInject);
   if (r) {
@@ -5725,7 +5725,7 @@ internal smallArrayt* injectNFreeSmallDoubleSmallArray(smallArrayt *self, intmax
   return(r);
 }
 
-internal smallArrayt* injectNFreeSmallIntSmallArray(smallArrayt *self, intmax_t index, smallIntt *toInject) {
+internal smallArrayt* injectNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *toInject) {
 
   smallArrayt *r = injectSmallIntSmallArray(self, index, toInject);
   if (r) {
@@ -5734,7 +5734,7 @@ internal smallArrayt* injectNFreeSmallIntSmallArray(smallArrayt *self, intmax_t 
   return(r);
 }
 
-internal smallArrayt* injectNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *toInject) {
+internal smallArrayt* injectNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *toInject) {
 
   smallArrayt *r = injectSmallJsonSmallArray(self, index, toInject);
   if (r) {
@@ -5743,7 +5743,7 @@ internal smallArrayt* injectNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t
   return(r);
 }
 
-internal smallArrayt* injectNFreeSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *toInject) {
+internal smallArrayt* injectNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *toInject) {
 
   smallArrayt *r = injectSmallStringSmallArray(self, index, toInject);
   if (r) {
@@ -5752,7 +5752,7 @@ internal smallArrayt* injectNFreeSmallStringSmallArray(smallArrayt *self, intmax
   return(r);
 }
 
-internal smallArrayt* injectNFreeSmallContainerSmallArray(smallArrayt *self, intmax_t index, smallContainert *toInject) {
+internal smallArrayt* injectNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *toInject) {
 
   smallArrayt *r = injectSmallContainerSmallArray(self, index, toInject);
   if (r) {
@@ -5761,7 +5761,7 @@ internal smallArrayt* injectNFreeSmallContainerSmallArray(smallArrayt *self, int
   return(r);
 }
 
-internal smallArrayt* delSmallArray(smallArrayt *self, intmax_t start, intmax_t end) {
+internal smallArrayt* delSmallArray(smallArrayt *self, int64_t start, int64_t end) {
   size_t len;;
 
   len = lenSmallArray(self);
@@ -5771,16 +5771,16 @@ internal smallArrayt* delSmallArray(smallArrayt *self, intmax_t start, intmax_t 
     return(NULL);
   }
 
-  if (start >= (intmax_t)len) {
+  if (start >= (int64_t)len) {
     start = len;
   }
-  if (end > (intmax_t)len) {
+  if (end > (int64_t)len) {
     end = len;
   }
-  if (start <= -(intmax_t)len) {
+  if (start <= -(int64_t)len) {
     start = -len;
   }
-  if (end <= -(intmax_t)len) {
+  if (end <= -(int64_t)len) {
     end = -len;
   }
   if (start < 0) {
@@ -5803,15 +5803,15 @@ internal smallArrayt* delSmallArray(smallArrayt *self, intmax_t start, intmax_t 
   return(self);
 }
 
-internal smallArrayt* delElemSmallArray(smallArrayt *self, intmax_t index) {
+internal smallArrayt* delElemSmallArray(smallArrayt *self, int64_t index) {
   size_t len;;
 
   len = lenSmallArray(self);
 
-  if (index >= (intmax_t)len) {
+  if (index >= (int64_t)len) {
     return(NULL);
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (index < 0) {
@@ -5822,7 +5822,7 @@ internal smallArrayt* delElemSmallArray(smallArrayt *self, intmax_t index) {
   return(self);
 }
 
-internal smallArrayt* removeSmallArray(smallArrayt *self, intmax_t start, intmax_t end) {
+internal smallArrayt* removeSmallArray(smallArrayt *self, int64_t start, int64_t end) {
   size_t len;;
 
   len = lenSmallArray(self);
@@ -5832,16 +5832,16 @@ internal smallArrayt* removeSmallArray(smallArrayt *self, intmax_t start, intmax
     return(NULL);
   }
 
-  if (start >= (intmax_t)len) {
+  if (start >= (int64_t)len) {
     start = len;
   }
-  if (end > (intmax_t)len) {
+  if (end > (int64_t)len) {
     end = len;
   }
-  if (start <= -(intmax_t)len) {
+  if (start <= -(int64_t)len) {
     start = -len;
   }
-  if (end <= -(intmax_t)len) {
+  if (end <= -(int64_t)len) {
     end = -len;
   }
   if (start < 0) {
@@ -5866,15 +5866,15 @@ internal smallArrayt* removeSmallArray(smallArrayt *self, intmax_t start, intmax
   return(self);
 }
 
-internal smallArrayt* removeElemSmallArray(smallArrayt *self, intmax_t index) {
+internal smallArrayt* removeElemSmallArray(smallArrayt *self, int64_t index) {
   size_t len;;
 
   len = lenSmallArray(self);
 
-  if (index >= (intmax_t)len) {
+  if (index >= (int64_t)len) {
     return(NULL);
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (index < 0) {
@@ -6544,12 +6544,12 @@ internal smallArrayt* trimSmallArray(smallArrayt *self) {
   return(self);
 }
 
-baset* getAtSmallArray(smallArrayt *self, intmax_t index) {
+baset* getAtSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6565,12 +6565,12 @@ baset* getAtSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal undefinedt* getAtUndefinedSmallArray(smallArrayt *self, intmax_t index) {
+internal undefinedt* getAtUndefinedSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6587,7 +6587,7 @@ internal undefinedt* getAtUndefinedSmallArray(smallArrayt *self, intmax_t index)
   return(allocUndefined());
 }
 
-internal bool getAtBoolSmallArray(smallArrayt *self, intmax_t index) {
+internal bool getAtBoolSmallArray(smallArrayt *self, int64_t index) {
   smallBoolt *e = NULL;
   bool r = false;;
 
@@ -6599,7 +6599,7 @@ internal bool getAtBoolSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal bool* getAtBoolPSmallArray(smallArrayt *self, intmax_t index) {
+internal bool* getAtBoolPSmallArray(smallArrayt *self, int64_t index) {
   smallBoolt *e = NULL;
   bool* r = NULL;
 
@@ -6611,7 +6611,7 @@ internal bool* getAtBoolPSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal double getAtDoubleSmallArray(smallArrayt *self, intmax_t index) {
+internal double getAtDoubleSmallArray(smallArrayt *self, int64_t index) {
   smallDoublet *e = NULL;
   double r = 0;;
 
@@ -6623,7 +6623,7 @@ internal double getAtDoubleSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal double* getAtDoublePSmallArray(smallArrayt *self, intmax_t index) {
+internal double* getAtDoublePSmallArray(smallArrayt *self, int64_t index) {
   smallDoublet *e = NULL;
   double* r = NULL;
 
@@ -6635,7 +6635,7 @@ internal double* getAtDoublePSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal int64_t getAtIntSmallArray(smallArrayt *self, intmax_t index) {
+internal int64_t getAtIntSmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   int64_t r = 0;;
 
@@ -6647,7 +6647,7 @@ internal int64_t getAtIntSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal int64_t* getAtIntPSmallArray(smallArrayt *self, intmax_t index) {
+internal int64_t* getAtIntPSmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   int64_t* r = NULL;
 
@@ -6659,7 +6659,7 @@ internal int64_t* getAtIntPSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal int32_t getAtInt32SmallArray(smallArrayt *self, intmax_t index) {
+internal int32_t getAtInt32SmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   int32_t r = 0;;
 
@@ -6671,7 +6671,7 @@ internal int32_t getAtInt32SmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal int32_t* getAtInt32PSmallArray(smallArrayt *self, intmax_t index) {
+internal int32_t* getAtInt32PSmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   int32_t* r = NULL;
 
@@ -6683,7 +6683,7 @@ internal int32_t* getAtInt32PSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal uint64_t getAtUintSmallArray(smallArrayt *self, intmax_t index) {
+internal uint64_t getAtUintSmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   uint64_t r = 0;;
 
@@ -6695,7 +6695,7 @@ internal uint64_t getAtUintSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal uint64_t* getAtUintPSmallArray(smallArrayt *self, intmax_t index) {
+internal uint64_t* getAtUintPSmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   uint64_t* r = NULL;
 
@@ -6707,7 +6707,7 @@ internal uint64_t* getAtUintPSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal uint32_t getAtUint32SmallArray(smallArrayt *self, intmax_t index) {
+internal uint32_t getAtUint32SmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   uint32_t r = 0;;
 
@@ -6719,7 +6719,7 @@ internal uint32_t getAtUint32SmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal uint32_t* getAtUint32PSmallArray(smallArrayt *self, intmax_t index) {
+internal uint32_t* getAtUint32PSmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   uint32_t* r = NULL;
 
@@ -6731,7 +6731,7 @@ internal uint32_t* getAtUint32PSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal char* getAtSSmallArray(smallArrayt *self, intmax_t index) {
+internal char* getAtSSmallArray(smallArrayt *self, int64_t index) {
   smallStringt *e = NULL;
   char* r = NULL;
 
@@ -6743,12 +6743,12 @@ internal char* getAtSSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal smallDictt* getAtDictSmallArray(smallArrayt *self, intmax_t index) {
+internal smallDictt* getAtDictSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6765,12 +6765,12 @@ internal smallDictt* getAtDictSmallArray(smallArrayt *self, intmax_t index) {
   return((smallDictt*) toBaset(o));
 }
 
-internal smallArrayt* getAtArraySmallArray(smallArrayt *self, intmax_t index) {
+internal smallArrayt* getAtArraySmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6787,12 +6787,12 @@ internal smallArrayt* getAtArraySmallArray(smallArrayt *self, intmax_t index) {
   return((smallArrayt*) toBaset(o));
 }
 
-internal smallBoolt* getAtSmallBoolSmallArray(smallArrayt *self, intmax_t index) {
+internal smallBoolt* getAtSmallBoolSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6809,12 +6809,12 @@ internal smallBoolt* getAtSmallBoolSmallArray(smallArrayt *self, intmax_t index)
   return((smallBoolt*) toBaset(o));
 }
 
-internal smallBytest* getAtSmallBytesSmallArray(smallArrayt *self, intmax_t index) {
+internal smallBytest* getAtSmallBytesSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6831,12 +6831,12 @@ internal smallBytest* getAtSmallBytesSmallArray(smallArrayt *self, intmax_t inde
   return((smallBytest*) toBaset(o));
 }
 
-internal smallDoublet* getAtSmallDoubleSmallArray(smallArrayt *self, intmax_t index) {
+internal smallDoublet* getAtSmallDoubleSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6853,12 +6853,12 @@ internal smallDoublet* getAtSmallDoubleSmallArray(smallArrayt *self, intmax_t in
   return((smallDoublet*) toBaset(o));
 }
 
-internal smallIntt* getAtSmallIntSmallArray(smallArrayt *self, intmax_t index) {
+internal smallIntt* getAtSmallIntSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6875,12 +6875,12 @@ internal smallIntt* getAtSmallIntSmallArray(smallArrayt *self, intmax_t index) {
   return((smallIntt*) toBaset(o));
 }
 
-internal smallJsont* getAtSmallJsonSmallArray(smallArrayt *self, intmax_t index) {
+internal smallJsont* getAtSmallJsonSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6905,12 +6905,12 @@ internal smallJsont* getAtSmallJsonSmallArray(smallArrayt *self, intmax_t index)
   return(r);
 }
 
-internal smallStringt* getAtSmallStringSmallArray(smallArrayt *self, intmax_t index) {
+internal smallStringt* getAtSmallStringSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6927,7 +6927,7 @@ internal smallStringt* getAtSmallStringSmallArray(smallArrayt *self, intmax_t in
   return((smallStringt*) toBaset(o));
 }
 
-internal void* getAtVoidSmallArray(smallArrayt *self, intmax_t index) {
+internal void* getAtVoidSmallArray(smallArrayt *self, int64_t index) {
   smallContainert *e = NULL;
   void* r = NULL;
 
@@ -6939,12 +6939,12 @@ internal void* getAtVoidSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal smallContainert* getAtSmallContainerSmallArray(smallArrayt *self, intmax_t index) {
+internal smallContainert* getAtSmallContainerSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6964,12 +6964,12 @@ internal smallContainert* getAtSmallContainerSmallArray(smallArrayt *self, intma
   return((smallContainert*) toBaset(o));
 }
 
-baset* getAtNDupSmallArray(smallArrayt *self, intmax_t index) {
+baset* getAtNDupSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -6992,12 +6992,12 @@ baset* getAtNDupSmallArray(smallArrayt *self, intmax_t index) {
   return(toBaset(sDuplicate(o)));
 }
 
-internal undefinedt* getAtNDupUndefinedSmallArray(smallArrayt *self, intmax_t index) {
+internal undefinedt* getAtNDupUndefinedSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7014,7 +7014,7 @@ internal undefinedt* getAtNDupUndefinedSmallArray(smallArrayt *self, intmax_t in
   return(allocUndefined());
 }
 
-internal bool getAtNDupBoolSmallArray(smallArrayt *self, intmax_t index) {
+internal bool getAtNDupBoolSmallArray(smallArrayt *self, int64_t index) {
   smallBoolt *e = NULL;
   bool r = false;;
 
@@ -7026,7 +7026,7 @@ internal bool getAtNDupBoolSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal double getAtNDupDoubleSmallArray(smallArrayt *self, intmax_t index) {
+internal double getAtNDupDoubleSmallArray(smallArrayt *self, int64_t index) {
   smallDoublet *e = NULL;
   double r = 0;;
 
@@ -7038,7 +7038,7 @@ internal double getAtNDupDoubleSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal int64_t getAtNDupIntSmallArray(smallArrayt *self, intmax_t index) {
+internal int64_t getAtNDupIntSmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   int64_t r = 0;;
 
@@ -7050,7 +7050,7 @@ internal int64_t getAtNDupIntSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, intmax_t index) {
+internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   int32_t r = 0;;
 
@@ -7062,7 +7062,7 @@ internal int32_t getAtNDupInt32SmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, intmax_t index) {
+internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   uint64_t r = 0;;
 
@@ -7074,7 +7074,7 @@ internal uint64_t getAtNDupUintSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, intmax_t index) {
+internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, int64_t index) {
   smallIntt *e = NULL;
   uint32_t r = 0;;
 
@@ -7086,7 +7086,7 @@ internal uint32_t getAtNDupUint32SmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal char* getAtNDupSSmallArray(smallArrayt *self, intmax_t index) {
+internal char* getAtNDupSSmallArray(smallArrayt *self, int64_t index) {
   smallStringt *e = NULL;
   char* r = NULL;
 
@@ -7098,12 +7098,12 @@ internal char* getAtNDupSSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal smallDictt* getAtNDupDictSmallArray(smallArrayt *self, intmax_t index) {
+internal smallDictt* getAtNDupDictSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7120,12 +7120,12 @@ internal smallDictt* getAtNDupDictSmallArray(smallArrayt *self, intmax_t index) 
   return((smallDictt*)toBaset(sDuplicate(o)));
 }
 
-internal smallArrayt* getAtNDupArraySmallArray(smallArrayt *self, intmax_t index) {
+internal smallArrayt* getAtNDupArraySmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7142,12 +7142,12 @@ internal smallArrayt* getAtNDupArraySmallArray(smallArrayt *self, intmax_t index
   return((smallArrayt*)toBaset(sDuplicate(o)));
 }
 
-internal smallBoolt* getAtNDupSmallBoolSmallArray(smallArrayt *self, intmax_t index) {
+internal smallBoolt* getAtNDupSmallBoolSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7164,12 +7164,12 @@ internal smallBoolt* getAtNDupSmallBoolSmallArray(smallArrayt *self, intmax_t in
   return((smallBoolt*)toBaset(sDuplicate(o)));
 }
 
-internal smallBytest* getAtNDupSmallBytesSmallArray(smallArrayt *self, intmax_t index) {
+internal smallBytest* getAtNDupSmallBytesSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7186,12 +7186,12 @@ internal smallBytest* getAtNDupSmallBytesSmallArray(smallArrayt *self, intmax_t 
   return((smallBytest*)toBaset(sDuplicate(o)));
 }
 
-internal smallDoublet* getAtNDupSmallDoubleSmallArray(smallArrayt *self, intmax_t index) {
+internal smallDoublet* getAtNDupSmallDoubleSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7208,12 +7208,12 @@ internal smallDoublet* getAtNDupSmallDoubleSmallArray(smallArrayt *self, intmax_
   return((smallDoublet*)toBaset(sDuplicate(o)));
 }
 
-internal smallIntt* getAtNDupSmallIntSmallArray(smallArrayt *self, intmax_t index) {
+internal smallIntt* getAtNDupSmallIntSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7230,12 +7230,12 @@ internal smallIntt* getAtNDupSmallIntSmallArray(smallArrayt *self, intmax_t inde
   return((smallIntt*)toBaset(sDuplicate(o)));
 }
 
-internal smallJsont* getAtNDupSmallJsonSmallArray(smallArrayt *self, intmax_t index) {
+internal smallJsont* getAtNDupSmallJsonSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7261,12 +7261,12 @@ internal smallJsont* getAtNDupSmallJsonSmallArray(smallArrayt *self, intmax_t in
   return(r);
 }
 
-internal smallStringt* getAtNDupSmallStringSmallArray(smallArrayt *self, intmax_t index) {
+internal smallStringt* getAtNDupSmallStringSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7283,7 +7283,7 @@ internal smallStringt* getAtNDupSmallStringSmallArray(smallArrayt *self, intmax_
   return((smallStringt*)toBaset(sDuplicate(o)));
 }
 
-internal void* getAtNDupVoidSmallArray(smallArrayt *self, intmax_t index) {
+internal void* getAtNDupVoidSmallArray(smallArrayt *self, int64_t index) {
   smallContainert *e = NULL;
   void* r = NULL;
 
@@ -7295,12 +7295,12 @@ internal void* getAtNDupVoidSmallArray(smallArrayt *self, intmax_t index) {
   return(r);
 }
 
-internal smallContainert* getAtNDupSmallContainerSmallArray(smallArrayt *self, intmax_t index) {
+internal smallContainert* getAtNDupSmallContainerSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7323,16 +7323,16 @@ internal smallContainert* getAtNDupSmallContainerSmallArray(smallArrayt *self, i
   return(r);
 }
 
-internal smallArrayt* setAtSmallArray(smallArrayt *self, intmax_t index, baset *value) {
+internal smallArrayt* setAtSmallArray(smallArrayt *self, int64_t index, baset *value) {
 
   if (!value) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7343,12 +7343,12 @@ internal smallArrayt* setAtSmallArray(smallArrayt *self, intmax_t index, baset *
   return(self);
 }
 
-internal smallArrayt* setAtUndefinedSmallArray(smallArrayt *self, intmax_t index) {
+internal smallArrayt* setAtUndefinedSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7363,12 +7363,12 @@ internal smallArrayt* setAtUndefinedSmallArray(smallArrayt *self, intmax_t index
   return(self);
 }
 
-internal smallArrayt* setAtBoolSmallArray(smallArrayt *self, intmax_t index, bool value) {
+internal smallArrayt* setAtBoolSmallArray(smallArrayt *self, int64_t index, bool value) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7383,12 +7383,12 @@ internal smallArrayt* setAtBoolSmallArray(smallArrayt *self, intmax_t index, boo
   return(self);
 }
 
-internal smallArrayt* setAtDoubleSmallArray(smallArrayt *self, intmax_t index, double value) {
+internal smallArrayt* setAtDoubleSmallArray(smallArrayt *self, int64_t index, double value) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7403,12 +7403,12 @@ internal smallArrayt* setAtDoubleSmallArray(smallArrayt *self, intmax_t index, d
   return(self);
 }
 
-internal smallArrayt* setAtIntSmallArray(smallArrayt *self, intmax_t index, int64_t value) {
+internal smallArrayt* setAtIntSmallArray(smallArrayt *self, int64_t index, int64_t value) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7423,16 +7423,16 @@ internal smallArrayt* setAtIntSmallArray(smallArrayt *self, intmax_t index, int6
   return(self);
 }
 
-internal smallArrayt* setAtSSmallArray(smallArrayt *self, intmax_t index, const char *string) {
+internal smallArrayt* setAtSSmallArray(smallArrayt *self, int64_t index, const char *string) {
 
   if (!string) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7445,13 +7445,13 @@ internal smallArrayt* setAtSSmallArray(smallArrayt *self, intmax_t index, const 
   return(self);
 }
 
-internal smallArrayt* setAtCharSmallArray(smallArrayt *self, intmax_t index, char c) {
+internal smallArrayt* setAtCharSmallArray(smallArrayt *self, int64_t index, char c) {
 
   charToS(s, c);
   return(setAtSSmallArray(self, index, s));
 }
 
-internal smallArrayt* setAtDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *dict) {
+internal smallArrayt* setAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) {
 
   if (!dict) {
     return(NULL);
@@ -7461,10 +7461,10 @@ internal smallArrayt* setAtDictSmallArray(smallArrayt *self, intmax_t index, sma
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7480,7 +7480,7 @@ internal smallArrayt* setAtDictSmallArray(smallArrayt *self, intmax_t index, sma
 }
 
 
-internal smallArrayt* setAtArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *array) {
+internal smallArrayt* setAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) {
 
   if (!array) {
     return(NULL);
@@ -7490,10 +7490,10 @@ internal smallArrayt* setAtArraySmallArray(smallArrayt *self, intmax_t index, sm
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7509,16 +7509,16 @@ internal smallArrayt* setAtArraySmallArray(smallArrayt *self, intmax_t index, sm
   return(self);
 }
 
-internal smallArrayt* setAtArraycSmallArray(smallArrayt *self, intmax_t index, char **array) {
+internal smallArrayt* setAtArraycSmallArray(smallArrayt *self, int64_t index, char **array) {
 
   if (!array) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7545,7 +7545,7 @@ internal smallArrayt* setAtArraycSmallArray(smallArrayt *self, intmax_t index, c
   return(self);
 }
 
-internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, intmax_t index, smallBoolt *value) {
+internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value) {
 
   if (!value) {
     return(NULL);
@@ -7555,10 +7555,10 @@ internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, intmax_t index
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7572,7 +7572,7 @@ internal smallArrayt* setAtSmallBoolSmallArray(smallArrayt *self, intmax_t index
   return(self);
 }
 
-internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, intmax_t index, smallBytest *value) {
+internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value) {
 
   if (!value) {
     return(NULL);
@@ -7582,10 +7582,10 @@ internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, intmax_t inde
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7599,7 +7599,7 @@ internal smallArrayt* setAtSmallBytesSmallArray(smallArrayt *self, intmax_t inde
   return(self);
 }
 
-internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, intmax_t index, smallDoublet *value) {
+internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value) {
 
   if (!value) {
     return(NULL);
@@ -7609,10 +7609,10 @@ internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, intmax_t ind
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7626,7 +7626,7 @@ internal smallArrayt* setAtSmallDoubleSmallArray(smallArrayt *self, intmax_t ind
   return(self);
 }
 
-internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, intmax_t index, smallIntt *value) {
+internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value) {
 
   if (!value) {
     return(NULL);
@@ -7636,10 +7636,10 @@ internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, intmax_t index,
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7653,7 +7653,7 @@ internal smallArrayt* setAtSmallIntSmallArray(smallArrayt *self, intmax_t index,
   return(self);
 }
 
-internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *value) {
+internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value) {
 
   if (!value) {
     return(NULL);
@@ -7663,10 +7663,10 @@ internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, intmax_t index
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7684,7 +7684,7 @@ internal smallArrayt* setAtSmallJsonSmallArray(smallArrayt *self, intmax_t index
   return(self);
 }
 
-internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *string) {
+internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) {
 
   if (!string) {
     return(NULL);
@@ -7694,10 +7694,10 @@ internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, intmax_t ind
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7711,7 +7711,7 @@ internal smallArrayt* setAtSmallStringSmallArray(smallArrayt *self, intmax_t ind
   return(self);
 }
 
-internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, intmax_t index, smallContainert *container) {
+internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container) {
 
   if (!container) {
     return(NULL);
@@ -7721,10 +7721,10 @@ internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, intmax_t 
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7738,16 +7738,16 @@ internal smallArrayt* setAtSmallContainerSmallArray(smallArrayt *self, intmax_t 
   return(self);
 }
 
-internal smallArrayt* setAtNFreeSmallArray(smallArrayt *self, intmax_t index, baset *value) {
+internal smallArrayt* setAtNFreeSmallArray(smallArrayt *self, int64_t index, baset *value) {
 
   if (!value) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7763,7 +7763,7 @@ internal smallArrayt* setAtNFreeSmallArray(smallArrayt *self, intmax_t index, ba
   return(self);
 }
 
-internal smallArrayt* setAtNFreeUndefinedSmallArray(smallArrayt *self, intmax_t index, undefinedt *undefined) {
+internal smallArrayt* setAtNFreeUndefinedSmallArray(smallArrayt *self, int64_t index, undefinedt *undefined) {
 
   smallArrayt *r = setAtUndefinedSmallArray(self, index);
   if (r) {
@@ -7772,7 +7772,7 @@ internal smallArrayt* setAtNFreeUndefinedSmallArray(smallArrayt *self, intmax_t 
   return(r);
 }
 
-internal smallArrayt* setAtNFreeSSmallArray(smallArrayt *self, intmax_t index, char *string) {
+internal smallArrayt* setAtNFreeSSmallArray(smallArrayt *self, int64_t index, char *string) {
 
   smallArrayt *r = setAtSSmallArray(self, index, string);
   if (r) {
@@ -7781,7 +7781,7 @@ internal smallArrayt* setAtNFreeSSmallArray(smallArrayt *self, intmax_t index, c
   return(r);
 }
 
-internal smallArrayt* setAtNFreeDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *dict) {
+internal smallArrayt* setAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) {
 
   smallArrayt *r = setAtDictSmallArray(self, index, dict);
   if (r) {
@@ -7790,7 +7790,7 @@ internal smallArrayt* setAtNFreeDictSmallArray(smallArrayt *self, intmax_t index
   return(r);
 }
 
-internal smallArrayt* setAtNFreeArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *array) {
+internal smallArrayt* setAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) {
 
   smallArrayt *r = setAtArraySmallArray(self, index, array);
   if (r) {
@@ -7799,7 +7799,7 @@ internal smallArrayt* setAtNFreeArraySmallArray(smallArrayt *self, intmax_t inde
   return(r);
 }
 
-internal smallArrayt* setAtNFreeArraycSmallArray(smallArrayt *self, intmax_t index, char **array) {
+internal smallArrayt* setAtNFreeArraycSmallArray(smallArrayt *self, int64_t index, char **array) {
 
   smallArrayt *r = setAtArraycSmallArray(self, index, array);
   if (r) {
@@ -7808,7 +7808,7 @@ internal smallArrayt* setAtNFreeArraycSmallArray(smallArrayt *self, intmax_t ind
   return(r);
 }
 
-internal smallArrayt* setAtNFreeSmallBoolSmallArray(smallArrayt *self, intmax_t index, smallBoolt *value) {
+internal smallArrayt* setAtNFreeSmallBoolSmallArray(smallArrayt *self, int64_t index, smallBoolt *value) {
 
   smallArrayt *r = setAtSmallBoolSmallArray(self, index, value);
   if (r) {
@@ -7817,7 +7817,7 @@ internal smallArrayt* setAtNFreeSmallBoolSmallArray(smallArrayt *self, intmax_t 
   return(r);
 }
 
-internal smallArrayt* setAtNFreeSmallBytesSmallArray(smallArrayt *self, intmax_t index, smallBytest *value) {
+internal smallArrayt* setAtNFreeSmallBytesSmallArray(smallArrayt *self, int64_t index, smallBytest *value) {
 
   smallArrayt *r = setAtSmallBytesSmallArray(self, index, value);
   if (r) {
@@ -7826,7 +7826,7 @@ internal smallArrayt* setAtNFreeSmallBytesSmallArray(smallArrayt *self, intmax_t
   return(r);
 }
 
-internal smallArrayt* setAtNFreeSmallDoubleSmallArray(smallArrayt *self, intmax_t index, smallDoublet *value) {
+internal smallArrayt* setAtNFreeSmallDoubleSmallArray(smallArrayt *self, int64_t index, smallDoublet *value) {
 
   smallArrayt *r = setAtSmallDoubleSmallArray(self, index, value);
   if (r) {
@@ -7835,7 +7835,7 @@ internal smallArrayt* setAtNFreeSmallDoubleSmallArray(smallArrayt *self, intmax_
   return(r);
 }
 
-internal smallArrayt* setAtNFreeSmallIntSmallArray(smallArrayt *self, intmax_t index, smallIntt *value) {
+internal smallArrayt* setAtNFreeSmallIntSmallArray(smallArrayt *self, int64_t index, smallIntt *value) {
 
   smallArrayt *r = setAtSmallIntSmallArray(self, index, value);
   if (r) {
@@ -7844,7 +7844,7 @@ internal smallArrayt* setAtNFreeSmallIntSmallArray(smallArrayt *self, intmax_t i
   return(r);
 }
 
-internal smallArrayt* setAtNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *value) {
+internal smallArrayt* setAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *value) {
 
   smallArrayt *r = setAtSmallJsonSmallArray(self, index, value);
   if (r) {
@@ -7853,7 +7853,7 @@ internal smallArrayt* setAtNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t 
   return(r);
 }
 
-internal smallArrayt* setAtNFreeSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *string) {
+internal smallArrayt* setAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) {
 
   smallArrayt *r = setAtSmallStringSmallArray(self, index, string);
   if (r) {
@@ -7862,7 +7862,7 @@ internal smallArrayt* setAtNFreeSmallStringSmallArray(smallArrayt *self, intmax_
   return(r);
 }
 
-internal smallArrayt* setAtNFreeSmallContainerSmallArray(smallArrayt *self, intmax_t index, smallContainert *container) {
+internal smallArrayt* setAtNFreeSmallContainerSmallArray(smallArrayt *self, int64_t index, smallContainert *container) {
 
   smallArrayt *r = setAtSmallContainerSmallArray(self, index, container);
   if (r) {
@@ -7872,7 +7872,7 @@ internal smallArrayt* setAtNFreeSmallContainerSmallArray(smallArrayt *self, intm
 }
 
 
-internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *dict) {
+internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) {
 
   if (!dict) {
     return(NULL);
@@ -7882,10 +7882,10 @@ internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, intmax_t index, sm
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7901,7 +7901,7 @@ internal smallArrayt* setPAtDictSmallArray(smallArrayt *self, intmax_t index, sm
   return(self);
 }
 
-internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *array) {
+internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) {
 
   if (!array) {
     return(NULL);
@@ -7911,10 +7911,10 @@ internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, intmax_t index, s
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7930,7 +7930,7 @@ internal smallArrayt* setPAtArraySmallArray(smallArrayt *self, intmax_t index, s
   return(self);
 }
 
-internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *json) {
+internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json) {
 
   if (!json) {
     return(NULL);
@@ -7940,10 +7940,10 @@ internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, intmax_t inde
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7960,7 +7960,7 @@ internal smallArrayt* setPAtSmallJsonSmallArray(smallArrayt *self, intmax_t inde
   return(self);
 }
 
-internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *string) {
+internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) {
 
   if (!string) {
     return(NULL);
@@ -7970,10 +7970,10 @@ internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, intmax_t in
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -7990,7 +7990,7 @@ internal smallArrayt* setPAtSmallStringSmallArray(smallArrayt *self, intmax_t in
   return(self);
 }
 
-internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, intmax_t index, smallDictt *dict) {
+internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, int64_t index, smallDictt *dict) {
 
   if (!dict) {
     return(NULL);
@@ -8000,10 +8000,10 @@ internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, intmax_t inde
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8021,7 +8021,7 @@ internal smallArrayt* setPAtNFreeDictSmallArray(smallArrayt *self, intmax_t inde
 }
 
 
-internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, intmax_t index, smallArrayt *array) {
+internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, int64_t index, smallArrayt *array) {
 
   if (!array) {
     return(NULL);
@@ -8031,10 +8031,10 @@ internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, intmax_t ind
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8051,7 +8051,7 @@ internal smallArrayt* setPAtNFreeArraySmallArray(smallArrayt *self, intmax_t ind
   return(self);
 }
 
-internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t index, smallJsont *json) {
+internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, int64_t index, smallJsont *json) {
 
   if (!json) {
     return(NULL);
@@ -8061,10 +8061,10 @@ internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8082,7 +8082,7 @@ internal smallArrayt* setPAtNFreeSmallJsonSmallArray(smallArrayt *self, intmax_t
   return(self);
 }
 
-internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, intmax_t index, smallStringt *string) {
+internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, int64_t index, smallStringt *string) {
 
   if (!string) {
     return(NULL);
@@ -8092,10 +8092,10 @@ internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, intmax
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8113,12 +8113,12 @@ internal smallArrayt* setPAtNFreeSmallStringSmallArray(smallArrayt *self, intmax
   return(self);
 }
 
-internal double getNumSmallArray(smallArrayt *self, intmax_t index) {
+internal double getNumSmallArray(smallArrayt *self, int64_t index) {
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(0);
   }
   if (index < 0) {
@@ -10610,7 +10610,7 @@ internal baset* iterStartLastSmallArray(smallArrayt *self) {
   return(self->iterElement);
 }
 
-internal baset* iterStartFromSmallArray(smallArrayt *self, intmax_t index) {
+internal baset* iterStartFromSmallArray(smallArrayt *self, int64_t index) {
 
   // reset iterIndex to a known value
   self->iterIndex = -1;
@@ -10619,10 +10619,10 @@ internal baset* iterStartFromSmallArray(smallArrayt *self, intmax_t index) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -10656,7 +10656,7 @@ internal baset* iterStartFromSmallArray(smallArrayt *self, intmax_t index) {
   return(self->iterElement);
 }
 
-internal baset* iterStartFromStepSmallArray(smallArrayt *self, intmax_t index, intmax_t step) {
+internal baset* iterStartFromStepSmallArray(smallArrayt *self, int64_t index, int64_t step) {
 
   // reset iterIndex to a known value
   self->iterIndex = -1;
@@ -10670,10 +10670,10 @@ internal baset* iterStartFromStepSmallArray(smallArrayt *self, intmax_t index, i
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallArray(self)) {
+  if (index >= (int64_t)lenSmallArray(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallArray(self)) {
+  if (index < -(int64_t)lenSmallArray(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -10754,7 +10754,7 @@ internal ssize_t iterIndexSmallArray(smallArrayt *self) {
   return(self->iterIndex);
 }
 
-internal intmax_t iterStepSmallArray(smallArrayt *self) {
+internal int64_t iterStepSmallArray(smallArrayt *self) {
 
   return(self->iterStep);
 }
@@ -11623,17 +11623,17 @@ internal bool appendTextSmallStringSmallArray(smallArrayt *self, smallStringt *f
 }
 
 
-internal const char* typeStringSmallArray(smallArrayt *self, intmax_t index) {
+internal const char* typeStringSmallArray(smallArrayt *self, int64_t index) {
 
   return(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)]);
 }
 
-internal smallStringt* typeSmallStringSmallArray(smallArrayt *self, intmax_t index) {
+internal smallStringt* typeSmallStringSmallArray(smallArrayt *self, int64_t index) {
 
   return(allocSmallString(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)]));
 }
 
-internal char typeSmallArray(smallArrayt *self, intmax_t index) {
+internal char typeSmallArray(smallArrayt *self, int64_t index) {
   size_t len;
 
   len = lenSmallArray(self);
@@ -11642,10 +11642,10 @@ internal char typeSmallArray(smallArrayt *self, intmax_t index) {
     return(0);
   }
 
-  if (index >= (intmax_t)len) {
+  if (index >= (int64_t)len) {
     return(0);
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(0);
   }
   if (index < 0) {
@@ -11697,7 +11697,7 @@ internal smallBytest* typesSmallArray(smallArrayt *self) {
   return(r);
 }
 
-internal bool isETypeSmallArray(smallArrayt *self, intmax_t index, const char *type) {
+internal bool isETypeSmallArray(smallArrayt *self, int64_t index, const char *type) {
 
   if (!type) {
     return(false);
@@ -11706,52 +11706,52 @@ internal bool isETypeSmallArray(smallArrayt *self, intmax_t index, const char *t
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], type));
 }
 
-internal bool isEUndefinedSmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEUndefinedSmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "undefined"));
 }
 
-internal bool isEBoolSmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEBoolSmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "bool"));
 }
 
-internal bool isEContainerSmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEContainerSmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "container"));
 }
 
-internal bool isEDictSmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEDictSmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "dict"));
 }
 
-internal bool isEDoubleSmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEDoubleSmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "double"));
 }
 
-internal bool isEIntSmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEIntSmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "int"));
 }
 
-internal bool isEStringSmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEStringSmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "string"));
 }
 
-internal bool isEFaststringSmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEFaststringSmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "faststring"));
 }
 
-internal bool isEArraySmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEArraySmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "array"));
 }
 
-internal bool isEBytesSmallArray(smallArrayt *self, intmax_t index) {
+internal bool isEBytesSmallArray(smallArrayt *self, int64_t index) {
 
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeSmallArray(self, index)], "bytes"));
 }
@@ -12396,283 +12396,283 @@ smallContainert* dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContai
 
 
 
-baset*           getAtSmallArrayG              (smallArrayt *self, baset* retType UNUSED, intmax_t index) {
+baset*           getAtSmallArrayG              (smallArrayt *self, baset* retType UNUSED, int64_t index) {
 
   return(self->f->getAt(self,index));
 }
 
-undefinedt*      getAtUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, intmax_t index) {
+undefinedt*      getAtUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtUndefined(self,index));
 }
 
-bool             getAtBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, intmax_t index) {
+bool             getAtBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, int64_t index) {
 
   return(self->f->getAtBool(self,index));
 }
 
-bool*            getAtBoolPSmallArrayG         (smallArrayt *self, bool* retType UNUSED, intmax_t index) {
+bool*            getAtBoolPSmallArrayG         (smallArrayt *self, bool* retType UNUSED, int64_t index) {
 
   return(self->f->getAtBoolP(self,index));
 }
 
-double           getAtDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, intmax_t index) {
+double           getAtDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, int64_t index) {
 
   return(self->f->getAtDouble(self,index));
 }
 
-double*          getAtDoublePSmallArrayG       (smallArrayt *self, double* retType UNUSED, intmax_t index) {
+double*          getAtDoublePSmallArrayG       (smallArrayt *self, double* retType UNUSED, int64_t index) {
 
   return(self->f->getAtDoubleP(self,index));
 }
 
-int64_t          getAtIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, intmax_t index) {
+int64_t          getAtIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtInt(self,index));
 }
 
-int64_t*         getAtIntPSmallArrayG          (smallArrayt *self, int64_t* retType UNUSED, intmax_t index) {
+int64_t*         getAtIntPSmallArrayG          (smallArrayt *self, int64_t* retType UNUSED, int64_t index) {
 
   return(self->f->getAtIntP(self,index));
 }
 
-int32_t          getAtInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, intmax_t index) {
+int32_t          getAtInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtInt32(self,index));
 }
 
-int32_t*         getAtInt32PSmallArrayG        (smallArrayt *self, int32_t* retType UNUSED, intmax_t index) {
+int32_t*         getAtInt32PSmallArrayG        (smallArrayt *self, int32_t* retType UNUSED, int64_t index) {
 
   return(self->f->getAtInt32P(self,index));
 }
 
-uint64_t         getAtUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, intmax_t index) {
+uint64_t         getAtUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtUint(self,index));
 }
 
-uint64_t*        getAtUintPSmallArrayG         (smallArrayt *self, uint64_t* retType UNUSED, intmax_t index) {
+uint64_t*        getAtUintPSmallArrayG         (smallArrayt *self, uint64_t* retType UNUSED, int64_t index) {
 
   return(self->f->getAtUintP(self,index));
 }
 
-uint32_t         getAtUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, intmax_t index) {
+uint32_t         getAtUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtUint32(self,index));
 }
 
-uint32_t*        getAtUint32PSmallArrayG       (smallArrayt *self, uint32_t* retType UNUSED, intmax_t index) {
+uint32_t*        getAtUint32PSmallArrayG       (smallArrayt *self, uint32_t* retType UNUSED, int64_t index) {
 
   return(self->f->getAtUint32P(self,index));
 }
 
-char*            getAtSSmallArrayG             (smallArrayt *self, char* retType UNUSED, intmax_t index) {
+char*            getAtSSmallArrayG             (smallArrayt *self, char* retType UNUSED, int64_t index) {
 
   return(self->f->getAtS(self,index));
 }
 
-smallDictt*      getAtDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, intmax_t index) {
+smallDictt*      getAtDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtDict(self,index));
 }
 
-smallArrayt*     getAtArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, intmax_t index) {
+smallArrayt*     getAtArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtArray(self,index));
 }
 
-smallBoolt*      getAtSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, intmax_t index) {
+smallBoolt*      getAtSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallBool(self,index));
 }
 
-smallBytest*      getAtSmallBytesSmallArrayG     (smallArrayt *self, smallBytest* retType UNUSED, intmax_t index) {
+smallBytest*      getAtSmallBytesSmallArrayG     (smallArrayt *self, smallBytest* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallBytes(self,index));
 }
 
-smallDoublet*    getAtSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, intmax_t index) {
+smallDoublet*    getAtSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallDouble(self,index));
 }
 
-smallIntt*       getAtSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, intmax_t index) {
+smallIntt*       getAtSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallInt(self,index));
 }
 
-smallJsont* getAtSmallJsonSmallArrayG(smallArrayt *self, smallJsont* retType UNUSED, intmax_t index) {
+smallJsont* getAtSmallJsonSmallArrayG(smallArrayt *self, smallJsont* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallJson(self,index));
 }
 
-smallStringt*    getAtSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, intmax_t index) {
+smallStringt*    getAtSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallString(self,index));
 }
 
-void*            getAtVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, intmax_t index) {
+void*            getAtVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, int64_t index) {
 
   return(self->f->getAtVoid(self,index));
 }
 
-smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, intmax_t index) {
+smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallContainer(self,index));
 }
 
 
-baset*           getAtNDupSmallArrayG              (smallArrayt *self, baset* retType UNUSED, intmax_t index) {
+baset*           getAtNDupSmallArrayG              (smallArrayt *self, baset* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDup(self,index));
 }
 
-undefinedt*      getAtNDupUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, intmax_t index) {
+undefinedt*      getAtNDupUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupUndefined(self,index));
 }
 
-bool             getAtNDupBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, intmax_t index) {
+bool             getAtNDupBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupBool(self,index));
 }
 
-double           getAtNDupDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, intmax_t index) {
+double           getAtNDupDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupDouble(self,index));
 }
 
-int64_t          getAtNDupIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, intmax_t index) {
+int64_t          getAtNDupIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupInt(self,index));
 }
 
-int32_t          getAtNDupInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, intmax_t index) {
+int32_t          getAtNDupInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupInt32(self,index));
 }
 
-uint64_t         getAtNDupUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, intmax_t index) {
+uint64_t         getAtNDupUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupUint(self,index));
 }
 
-uint32_t         getAtNDupUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, intmax_t index) {
+uint32_t         getAtNDupUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupUint32(self,index));
 }
 
-char*            getAtNDupSSmallArrayG             (smallArrayt *self, char* retType UNUSED, intmax_t index) {
+char*            getAtNDupSSmallArrayG             (smallArrayt *self, char* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupS(self,index));
 }
 
-smallDictt*      getAtNDupDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, intmax_t index) {
+smallDictt*      getAtNDupDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupDict(self,index));
 }
 
-smallArrayt*     getAtNDupArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, intmax_t index) {
+smallArrayt*     getAtNDupArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupArray(self,index));
 }
 
-smallBoolt*      getAtNDupSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, intmax_t index) {
+smallBoolt*      getAtNDupSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallBool(self,index));
 }
 
-smallBytest*      getAtNDupSmallBytesSmallArrayG     (smallArrayt *self, smallBytest* retType UNUSED, intmax_t index) {
+smallBytest*      getAtNDupSmallBytesSmallArrayG     (smallArrayt *self, smallBytest* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallBytes(self,index));
 }
 
-smallDoublet*    getAtNDupSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, intmax_t index) {
+smallDoublet*    getAtNDupSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallDouble(self,index));
 }
 
-smallIntt*       getAtNDupSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, intmax_t index) {
+smallIntt*       getAtNDupSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallInt(self,index));
 }
 
-smallJsont*      getAtNDupSmallJsonSmallArrayG      (smallArrayt *self, smallJsont* retType UNUSED, intmax_t index) {
+smallJsont*      getAtNDupSmallJsonSmallArrayG      (smallArrayt *self, smallJsont* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallJson(self,index));
 }
 
-smallStringt*    getAtNDupSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, intmax_t index) {
+smallStringt*    getAtNDupSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallString(self,index));
 }
 
-void*            getAtNDupVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, intmax_t index) {
+void*            getAtNDupVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupVoid(self,index));
 }
 
-smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, intmax_t index) {
+smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallContainer(self,index));
 }
 
-smallArrayt* setAtSmallArrayG         (smallArrayt *self, intmax_t index, baset *value) {
+smallArrayt* setAtSmallArrayG         (smallArrayt *self, int64_t index, baset *value) {
 
   return(self->f->setAt(self, index, value));
 }
 
-smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value UNUSED) {
+smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED) {
 
   return(self->f->setAtUndefined(self,index));
 }
 
-smallArrayt* setAtBoolSmallArrayG     (smallArrayt *self, intmax_t index, bool value) {
+smallArrayt* setAtBoolSmallArrayG     (smallArrayt *self, int64_t index, bool value) {
 
   return(self->f->setAtBool(self,index,value));
 }
 
-smallArrayt* setAtDoubleSmallArrayG   (smallArrayt *self, intmax_t index, double value) {
+smallArrayt* setAtDoubleSmallArrayG   (smallArrayt *self, int64_t index, double value) {
 
   return(self->f->setAtDouble(self,index,value));
 }
 
-smallArrayt* setAtIntSmallArrayG      (smallArrayt *self, intmax_t index, int64_t value) {
+smallArrayt* setAtIntSmallArrayG      (smallArrayt *self, int64_t index, int64_t value) {
 
   return(self->f->setAtInt(self,index,value));
 }
 
-smallArrayt* setAtSSmallArrayG        (smallArrayt *self, intmax_t index, const char *string) {
+smallArrayt* setAtSSmallArrayG        (smallArrayt *self, int64_t index, const char *string) {
 
   return(self->f->setAtS(self,index,string));
 }
 
-smallArrayt* setAtCharSmallArrayG(smallArrayt *self, intmax_t index, char c) {
+smallArrayt* setAtCharSmallArrayG(smallArrayt *self, int64_t index, char c) {
 
   return(self->f->setAtChar(self,index,c));
 }
 
-smallArrayt* setAtDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict) {
+smallArrayt* setAtDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict) {
 
   return(self->f->setAtDict(self,index,dict));
 }
 
-smallArrayt* setAtArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array) {
+smallArrayt* setAtArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array) {
 
   return(self->f->setAtArray(self,index,array));
 }
 
-smallArrayt* setAtArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array) {
+smallArrayt* setAtArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array) {
 
   return(self->f->setAtArrayc(self,index,array));
 }
 
-smallArrayt* setAtCArraycSmallArrayG  (smallArrayt *self, intmax_t index, const char **array) {
+smallArrayt* setAtCArraycSmallArrayG  (smallArrayt *self, int64_t index, const char **array) {
 
   return(self->f->setAtArrayc(self,index,(char**)array));
 }
 
-smallArrayt* setAtVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value) {
+smallArrayt* setAtVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value) {
 
   if (value) {
     smallContainert *c = allocSmallContainer(value);
@@ -12684,149 +12684,149 @@ smallArrayt* setAtVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *
   return(self->f->setAtUndefined(self,index));
 }
 
-smallArrayt* setAtSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value) {
+smallArrayt* setAtSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value) {
 
   return(self->f->setAtSmallBool(self,index,value));
 }
 
-smallArrayt* setAtSmallBytesSmallArrayG     (smallArrayt *self, intmax_t index, smallBytest *value) {
+smallArrayt* setAtSmallBytesSmallArrayG     (smallArrayt *self, int64_t index, smallBytest *value) {
 
   return(self->f->setAtSmallBytes(self,index,value));
 }
 
-smallArrayt* setAtSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value) {
+smallArrayt* setAtSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value) {
 
   return(self->f->setAtSmallDouble(self,index,value));
 }
 
-smallArrayt* setAtSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value) {
+smallArrayt* setAtSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value) {
 
   return(self->f->setAtSmallInt(self,index,value));
 }
 
-smallArrayt* setAtSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *value) {
+smallArrayt* setAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value) {
 
   return(self->f->setAtSmallJson(self,index,value));
 }
 
-smallArrayt* setAtSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string) {
+smallArrayt* setAtSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string) {
 
   return(self->f->setAtSmallString(self,index,string));
 }
 
-smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container) {
+smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) {
 
   return(self->f->setAtSmallContainer(self,index,container));
 }
 
 
-smallArrayt* setAtNFreeSmallArrayG    (smallArrayt *self, intmax_t index, baset *value) {
+smallArrayt* setAtNFreeSmallArrayG    (smallArrayt *self, int64_t index, baset *value) {
 
   return(self->f->setAtNFree(self,index,value));
 }
 
-smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value) {
+smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value) {
 
   return(self->f->setAtNFreeUndefined(self,index,value));
 }
 
-smallArrayt* setAtNFreeSSmallArrayG        (smallArrayt *self, intmax_t index, char *string) {
+smallArrayt* setAtNFreeSSmallArrayG        (smallArrayt *self, int64_t index, char *string) {
 
   return(self->f->setAtNFreeS(self,index,string));
 }
 
-smallArrayt* setAtNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict) {
+smallArrayt* setAtNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict) {
 
   return(self->f->setAtNFreeDict(self,index,dict));
 }
 
-smallArrayt* setAtNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array) {
+smallArrayt* setAtNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array) {
 
   return(self->f->setAtNFreeArray(self,index,array));
 }
 
-smallArrayt* setAtNFreeArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array) {
+smallArrayt* setAtNFreeArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array) {
 
   return(self->f->setAtNFreeArrayc(self,index,array));
 }
 
-smallArrayt* setAtNFreeSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value) {
+smallArrayt* setAtNFreeSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value) {
 
   return(self->f->setAtNFreeSmallBool(self,index,value));
 }
 
-smallArrayt* setAtNFreeSmallBytesSmallArrayG     (smallArrayt *self, intmax_t index, smallBytest *value) {
+smallArrayt* setAtNFreeSmallBytesSmallArrayG     (smallArrayt *self, int64_t index, smallBytest *value) {
 
   return(self->f->setAtNFreeSmallBytes(self,index,value));
 }
 
-smallArrayt* setAtNFreeSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value) {
+smallArrayt* setAtNFreeSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value) {
 
   return(self->f->setAtNFreeSmallDouble(self,index,value));
 }
 
-smallArrayt* setAtNFreeSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value) {
+smallArrayt* setAtNFreeSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value) {
 
   return(self->f->setAtNFreeSmallInt(self,index,value));
 }
 
-smallArrayt* setAtNFreeSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *value) {
+smallArrayt* setAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *value) {
 
   return(self->f->setAtNFreeSmallJson(self,index,value));
 }
 
-smallArrayt* setAtNFreeSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string) {
+smallArrayt* setAtNFreeSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string) {
 
   return(self->f->setAtNFreeSmallString(self,index,string));
 }
 
-smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container) {
+smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) {
 
   return(self->f->setAtNFreeSmallContainer(self,index,container));
 }
 
 
-smallArrayt* setPAtDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict) {
+smallArrayt* setPAtDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict) {
 
   return(self->f->setPAtDict(self,index,dict));
 }
 
-smallArrayt* setPAtArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array) {
+smallArrayt* setPAtArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array) {
 
   return(self->f->setPAtArray(self,index,array));
 }
 
-smallArrayt* setPAtSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *json) {
+smallArrayt* setPAtSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json) {
 
   return(self->f->setPAtSmallJson(self,index,json));
 }
 
-smallArrayt* setPAtSmallStringSmallArrayG     (smallArrayt *self, intmax_t index, smallStringt *string) {
+smallArrayt* setPAtSmallStringSmallArrayG     (smallArrayt *self, int64_t index, smallStringt *string) {
 
   return(self->f->setPAtSmallString(self,index,string));
 }
 
-smallArrayt* setPAtNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict) {
+smallArrayt* setPAtNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict) {
 
   return(self->f->setPAtNFreeDict(self,index,dict));
 }
 
-smallArrayt* setPAtNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array) {
+smallArrayt* setPAtNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array) {
 
   return(self->f->setPAtNFreeArray(self,index,array));
 }
 
-smallArrayt* setPAtNFreeSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *json) {
+smallArrayt* setPAtNFreeSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *json) {
 
   return(self->f->setPAtNFreeSmallJson(self,index,json));
 }
 
-smallArrayt* setPAtNFreeSmallStringSmallArrayG     (smallArrayt *self, intmax_t index, smallStringt *string) {
+smallArrayt* setPAtNFreeSmallStringSmallArrayG     (smallArrayt *self, int64_t index, smallStringt *string) {
 
   return(self->f->setPAtNFreeSmallString(self,index,string));
 }
 
-double getNumSmallArrayG(smallArrayt *self, intmax_t index) {
+double getNumSmallArrayG(smallArrayt *self, int64_t index) {
 
   return(self->f->getNum(self, index));
 }
@@ -12904,192 +12904,192 @@ smallArrayt* addSmallArrayG  (smallArrayt *self, smallArrayt *array) {
   return(self->f->add(self, array));
 }
 
-smallArrayt*          sliceSmallArrayG(smallArrayt *self, intmax_t start, intmax_t end) {
+smallArrayt*          sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end) {
 
   return(self->f->slice(self, start, end));
 }
 
-smallArrayt* cropSmallArrayG                      (smallArrayt *self, intmax_t start, intmax_t end) {
+smallArrayt* cropSmallArrayG                      (smallArrayt *self, int64_t start, int64_t end) {
 
   return(self->f->crop(self, start, end));
 }
 
-baset* cropElemSmallArrayG                        (smallArrayt *self, intmax_t index) {
+baset* cropElemSmallArrayG                        (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElem(self, index));
 }
 
-undefinedt* cropElemUndefinedSmallArrayG          (smallArrayt *self, intmax_t index) {
+undefinedt* cropElemUndefinedSmallArrayG          (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemUndefined(self, index));
 }
 
-bool cropElemBoolSmallArrayG                      (smallArrayt *self, intmax_t index) {
+bool cropElemBoolSmallArrayG                      (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemBool(self, index));
 }
 
-double cropElemDoubleSmallArrayG                  (smallArrayt *self, intmax_t index) {
+double cropElemDoubleSmallArrayG                  (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemDouble(self, index));
 }
 
-int64_t cropElemIntSmallArrayG                    (smallArrayt *self, intmax_t index) {
+int64_t cropElemIntSmallArrayG                    (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemInt(self, index));
 }
 
-int32_t cropElemInt32SmallArrayG                  (smallArrayt *self, intmax_t index) {
+int32_t cropElemInt32SmallArrayG                  (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemInt32(self, index));
 }
 
-uint64_t cropElemUintSmallArrayG                  (smallArrayt *self, intmax_t index) {
+uint64_t cropElemUintSmallArrayG                  (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemUint(self, index));
 }
 
-uint32_t cropElemUint32SmallArrayG                (smallArrayt *self, intmax_t index) {
+uint32_t cropElemUint32SmallArrayG                (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemUint32(self, index));
 }
 
-char* cropElemSSmallArrayG                        (smallArrayt *self, intmax_t index) {
+char* cropElemSSmallArrayG                        (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemS(self, index));
 }
 
-smallDictt* cropElemDictSmallArrayG               (smallArrayt *self, intmax_t index) {
+smallDictt* cropElemDictSmallArrayG               (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemDict(self, index));
 }
 
-smallArrayt* cropElemArraySmallArrayG             (smallArrayt *self, intmax_t index) {
+smallArrayt* cropElemArraySmallArrayG             (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemArray(self, index));
 }
 
-smallBoolt* cropElemSmallBoolSmallArrayG          (smallArrayt *self, intmax_t index) {
+smallBoolt* cropElemSmallBoolSmallArrayG          (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemSmallBool(self, index));
 }
 
-smallBytest* cropElemSmallBytesSmallArrayG        (smallArrayt *self, intmax_t index) {
+smallBytest* cropElemSmallBytesSmallArrayG        (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemSmallBytes(self, index));
 }
 
-smallDoublet* cropElemSmallDoubleSmallArrayG      (smallArrayt *self, intmax_t index) {
+smallDoublet* cropElemSmallDoubleSmallArrayG      (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemSmallDouble(self, index));
 }
 
-smallIntt* cropElemSmallIntSmallArrayG            (smallArrayt *self, intmax_t index) {
+smallIntt* cropElemSmallIntSmallArrayG            (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemSmallInt(self, index));
 }
 
-smallJsont* cropElemSmallJsonSmallArrayG          (smallArrayt *self, intmax_t index) {
+smallJsont* cropElemSmallJsonSmallArrayG          (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemSmallJson(self, index));
 }
 
-smallStringt* cropElemSmallStringSmallArrayG      (smallArrayt *self, intmax_t index) {
+smallStringt* cropElemSmallStringSmallArrayG      (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemSmallString(self, index));
 }
 
-void* cropElemVoidSmallArrayG                     (smallArrayt *self, intmax_t index) {
+void* cropElemVoidSmallArrayG                     (smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemVoid(self, index));
 }
 
-smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, intmax_t index) {
+smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index) {
 
   return(self->f->cropElemSmallContainer(self, index));
 }
 
-smallArrayt* copySmallArrayG (smallArrayt *self, intmax_t start, intmax_t end) {
+smallArrayt* copySmallArrayG (smallArrayt *self, int64_t start, int64_t end) {
 
   return(self->f->copy(self, start, end));
 }
 
-smallArrayt*          insertSmallArrayG(smallArrayt *self, intmax_t index, smallArrayt *toInsert) {
+smallArrayt*          insertSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert) {
 
   return(self->f->insert(self, index, toInsert));
 }
 
-smallArrayt* insertSmallJsonSmallArrayG      (smallArrayt *self, intmax_t index, smallJsont *toInsert) {
+smallArrayt* insertSmallJsonSmallArrayG      (smallArrayt *self, int64_t index, smallJsont *toInsert) {
 
   return(self->f->insertSmallJson(self, index, toInsert));
 }
 
-smallArrayt*          insertNSmashSmallArrayG(smallArrayt *self, intmax_t index, smallArrayt *toInsert) {
+smallArrayt*          insertNSmashSmallArrayG(smallArrayt *self, int64_t index, smallArrayt *toInsert) {
 
   return(self->f->insertNSmash(self, index, toInsert));
 }
 
-smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *toInsert) {
+smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert) {
 
   return(self->f->insertNSmashSmallJson(self, index, toInsert));
 }
 
-smallArrayt* injectSmallArrayG         (smallArrayt *self, intmax_t index, baset *value) {
+smallArrayt* injectSmallArrayG         (smallArrayt *self, int64_t index, baset *value) {
 
   return(self->f->inject(self, index, value));
 }
 
-smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value UNUSED) {
+smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value UNUSED) {
 
   return(self->f->injectUndefined(self,index));
 }
 
-smallArrayt* injectBoolSmallArrayG     (smallArrayt *self, intmax_t index, bool value) {
+smallArrayt* injectBoolSmallArrayG     (smallArrayt *self, int64_t index, bool value) {
 
   return(self->f->injectBool(self,index,value));
 }
 
-smallArrayt* injectDoubleSmallArrayG   (smallArrayt *self, intmax_t index, double value) {
+smallArrayt* injectDoubleSmallArrayG   (smallArrayt *self, int64_t index, double value) {
 
   return(self->f->injectDouble(self,index,value));
 }
 
-smallArrayt* injectIntSmallArrayG      (smallArrayt *self, intmax_t index, int64_t value) {
+smallArrayt* injectIntSmallArrayG      (smallArrayt *self, int64_t index, int64_t value) {
 
   return(self->f->injectInt(self,index,value));
 }
 
-smallArrayt* injectSSmallArrayG        (smallArrayt *self, intmax_t index, const char *string) {
+smallArrayt* injectSSmallArrayG        (smallArrayt *self, int64_t index, const char *string) {
 
   return(self->f->injectS(self,index,string));
 }
 
-smallArrayt* injectCharSmallArrayG(smallArrayt *self, intmax_t index, char c) {
+smallArrayt* injectCharSmallArrayG(smallArrayt *self, int64_t index, char c) {
 
   return(self->f->injectChar(self,index,c));
 }
 
-smallArrayt* injectDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict) {
+smallArrayt* injectDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict) {
 
   return(self->f->injectDict(self,index,dict));
 }
 
-smallArrayt* injectArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array) {
+smallArrayt* injectArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array) {
 
   return(self->f->injectArray(self,index,array));
 }
 
-smallArrayt* injectArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array) {
+smallArrayt* injectArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array) {
 
   return(self->f->injectArrayc(self,index,array));
 }
 
-smallArrayt* injectCArraycSmallArrayG   (smallArrayt *self, intmax_t index, const char **array) {
+smallArrayt* injectCArraycSmallArrayG   (smallArrayt *self, int64_t index, const char **array) {
 
   return(self->f->injectArrayc(self,index,(char**)array));
 }
 
-smallArrayt* injectVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value) {
+smallArrayt* injectVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value) {
 
   if (value) {
     smallContainert *c = allocSmallContainer(value);
@@ -13101,123 +13101,123 @@ smallArrayt* injectVoidSmallArrayG     (smallArrayt *self, intmax_t index, void 
   return(self->f->injectUndefined(self,index));
 }
 
-smallArrayt* injectSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value) {
+smallArrayt* injectSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value) {
 
   return(self->f->injectSmallBool(self,index,value));
 }
 
-smallArrayt* injectSmallBytesSmallArrayG     (smallArrayt *self, intmax_t index, smallBytest *value) {
+smallArrayt* injectSmallBytesSmallArrayG     (smallArrayt *self, int64_t index, smallBytest *value) {
 
   return(self->f->injectSmallBytes(self,index,value));
 }
 
-smallArrayt* injectSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value) {
+smallArrayt* injectSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value) {
 
   return(self->f->injectSmallDouble(self,index,value));
 }
 
-smallArrayt* injectSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value) {
+smallArrayt* injectSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value) {
 
   return(self->f->injectSmallInt(self,index,value));
 }
 
-smallArrayt* injectSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *string) {
+smallArrayt* injectSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *string) {
 
   return(self->f->injectSmallJson(self,index,string));
 }
 
-smallArrayt* injectSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string) {
+smallArrayt* injectSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string) {
 
   return(self->f->injectSmallString(self,index,string));
 }
 
-smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container) {
+smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) {
 
   return(self->f->injectSmallContainer(self,index,container));
 }
 
 
-smallArrayt* injectNFreeSmallArrayG    (smallArrayt *self, intmax_t index, baset *value) {
+smallArrayt* injectNFreeSmallArrayG    (smallArrayt *self, int64_t index, baset *value) {
 
   return(self->f->injectNFree(self,index,value));
 }
 
-smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, intmax_t index, undefinedt *value) {
+smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value) {
 
   return(self->f->injectNFreeUndefined(self,index,value));
 }
 
-smallArrayt* injectNFreeSSmallArrayG        (smallArrayt *self, intmax_t index, char *string) {
+smallArrayt* injectNFreeSSmallArrayG        (smallArrayt *self, int64_t index, char *string) {
 
   return(self->f->injectNFreeS(self,index,string));
 }
 
-smallArrayt* injectNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict) {
+smallArrayt* injectNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict) {
 
   return(self->f->injectNFreeDict(self,index,dict));
 }
 
-smallArrayt* injectNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array) {
+smallArrayt* injectNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array) {
 
   return(self->f->injectNFreeArray(self,index,array));
 }
 
-smallArrayt* injectNFreeArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array) {
+smallArrayt* injectNFreeArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array) {
 
   return(self->f->injectNFreeArrayc(self,index,array));
 }
 
-smallArrayt* injectNFreeSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value) {
+smallArrayt* injectNFreeSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value) {
 
   return(self->f->injectNFreeSmallBool(self,index,value));
 }
 
-smallArrayt* injectNFreeSmallBytesSmallArrayG     (smallArrayt *self, intmax_t index, smallBytest *value) {
+smallArrayt* injectNFreeSmallBytesSmallArrayG     (smallArrayt *self, int64_t index, smallBytest *value) {
 
   return(self->f->injectNFreeSmallBytes(self,index,value));
 }
 
-smallArrayt* injectNFreeSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value) {
+smallArrayt* injectNFreeSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value) {
 
   return(self->f->injectNFreeSmallDouble(self,index,value));
 }
 
-smallArrayt* injectNFreeSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value) {
+smallArrayt* injectNFreeSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value) {
 
   return(self->f->injectNFreeSmallInt(self,index,value));
 }
 
-smallArrayt* injectNFreeSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *string) {
+smallArrayt* injectNFreeSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *string) {
 
   return(self->f->injectNFreeSmallJson(self,index,string));
 }
 
-smallArrayt* injectNFreeSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string) {
+smallArrayt* injectNFreeSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string) {
 
   return(self->f->injectNFreeSmallString(self,index,string));
 }
 
-smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container) {
+smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container) {
 
   return(self->f->injectNFreeSmallContainer(self,index,container));
 }
 
-smallArrayt* delSmallArrayG           (smallArrayt *self, intmax_t start, intmax_t end) {
+smallArrayt* delSmallArrayG           (smallArrayt *self, int64_t start, int64_t end) {
 
   return(self->f->del(self, start, end));
 }
 
-smallArrayt* delElemSmallArrayG       (smallArrayt *self, intmax_t index) {
+smallArrayt* delElemSmallArrayG       (smallArrayt *self, int64_t index) {
 
   return(self->f->delElem(self, index));
 }
 
-smallArrayt* removeSmallArrayG        (smallArrayt *self, intmax_t start, intmax_t end) {
+smallArrayt* removeSmallArrayG        (smallArrayt *self, int64_t start, int64_t end) {
 
   return(self->f->remove(self, start, end));
 }
 
-smallArrayt* removeElemSmallArrayG    (smallArrayt *self, intmax_t index) {
+smallArrayt* removeElemSmallArrayG    (smallArrayt *self, int64_t index) {
 
   return(self->f->removeElem(self, index));
 }
@@ -13907,7 +13907,7 @@ bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath)
   return(self->f->appendTextSmallString(self,filePath));
 }
 
-smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, intmax_t index) {
+smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, int64_t index) {
 
   return(self->f->typeSmallString(self,index));
 }
diff --git a/src/json/libsheepyCSmallArray.h b/src/json/libsheepyCSmallArray.h
@@ -444,7 +444,7 @@ typedef smallArrayt*          (*addSmallArrayFt)       (smallArrayt *self, small
  *   0  success
  *   -1 error
  */
-typedef smallArrayt*          (*sliceSmallArrayFt)     (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt*          (*sliceSmallArrayFt)     (smallArrayt *self, int64_t start, int64_t end);
 
 /**
  * Crop elements from start to end
@@ -466,7 +466,7 @@ typedef smallArrayt*          (*sliceSmallArrayFt)     (smallArrayt *self, intma
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallArrayt*     (*cropSmallArrayFt)                   (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt*     (*cropSmallArrayFt)                   (smallArrayt *self, int64_t start, int64_t end);
 
 
 /**
@@ -482,25 +482,25 @@ typedef smallArrayt*     (*cropSmallArrayFt)                   (smallArrayt *sel
  *   unchanged when list is empty
  *   NULL error
  */
-typedef baset*           (*cropElemSmallArrayFt)               (smallArrayt *self, intmax_t index);
-typedef undefinedt*      (*cropElemUndefinedSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef bool             (*cropElemBoolSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef double           (*cropElemDoubleSmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef int64_t          (*cropElemIntSmallArrayFt)            (smallArrayt *self, intmax_t index);
-typedef int32_t          (*cropElemInt32SmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef uint64_t         (*cropElemUintSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef uint32_t         (*cropElemUint32SmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef char*            (*cropElemSSmallArrayFt)              (smallArrayt *self, intmax_t index);
-typedef smallDictt*      (*cropElemDictSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef smallArrayt*     (*cropElemArraySmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallBoolt*      (*cropElemSmallBoolSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef smallBytest*     (*cropElemSmallBytesSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallDoublet*    (*cropElemSmallDoubleSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef smallIntt*       (*cropElemSmallIntSmallArrayFt)       (smallArrayt *self, intmax_t index);
-typedef smallJsont*      (*cropElemSmallJsonSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef smallStringt*    (*cropElemSmallStringSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef void*            (*cropElemVoidSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef smallContainert* (*cropElemSmallContainerSmallArrayFt) (smallArrayt *self, intmax_t index);
+typedef baset*           (*cropElemSmallArrayFt)               (smallArrayt *self, int64_t index);
+typedef undefinedt*      (*cropElemUndefinedSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef bool             (*cropElemBoolSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef double           (*cropElemDoubleSmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef int64_t          (*cropElemIntSmallArrayFt)            (smallArrayt *self, int64_t index);
+typedef int32_t          (*cropElemInt32SmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef uint64_t         (*cropElemUintSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef uint32_t         (*cropElemUint32SmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef char*            (*cropElemSSmallArrayFt)              (smallArrayt *self, int64_t index);
+typedef smallDictt*      (*cropElemDictSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef smallArrayt*     (*cropElemArraySmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallBoolt*      (*cropElemSmallBoolSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef smallBytest*     (*cropElemSmallBytesSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallDoublet*    (*cropElemSmallDoubleSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef smallIntt*       (*cropElemSmallIntSmallArrayFt)       (smallArrayt *self, int64_t index);
+typedef smallJsont*      (*cropElemSmallJsonSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef smallStringt*    (*cropElemSmallStringSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef void*            (*cropElemVoidSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef smallContainert* (*cropElemSmallContainerSmallArrayFt) (smallArrayt *self, int64_t index);
 
 /**
  * keep elements from start and end in list, free the other elements
@@ -517,7 +517,7 @@ typedef smallContainert* (*cropElemSmallContainerSmallArrayFt) (smallArrayt *sel
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallArrayt* (*copySmallArrayFt)          (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt* (*copySmallArrayFt)          (smallArrayt *self, int64_t start, int64_t end);
 
 /**
  * insert array in self at index
@@ -535,10 +535,10 @@ typedef smallArrayt* (*copySmallArrayFt)          (smallArrayt *self, intmax_t s
  *   unchanged array when array is NULL or invalid index
  *   NULL error
  */
-typedef smallArrayt*          (*insertSmallArrayFt)               (smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-typedef smallArrayt*          (*insertSmallJsonSmallArrayFt)      (smallArrayt *self, intmax_t index, smallJsont *toInsert);
-typedef smallArrayt*          (*insertNSmashSmallArrayFt)         (smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-typedef smallArrayt*          (*insertNSmashSmallJsonSmallArrayFt)(smallArrayt *self, intmax_t index, smallJsont *toInsert);
+typedef smallArrayt*          (*insertSmallArrayFt)               (smallArrayt *self, int64_t index, smallArrayt *toInsert);
+typedef smallArrayt*          (*insertSmallJsonSmallArrayFt)      (smallArrayt *self, int64_t index, smallJsont *toInsert);
+typedef smallArrayt*          (*insertNSmashSmallArrayFt)         (smallArrayt *self, int64_t index, smallArrayt *toInsert);
+typedef smallArrayt*          (*insertNSmashSmallJsonSmallArrayFt)(smallArrayt *self, int64_t index, smallJsont *toInsert);
 
 /**
  * inject an element in self at index
@@ -555,37 +555,37 @@ typedef smallArrayt*          (*insertNSmashSmallJsonSmallArrayFt)(smallArrayt *
  *   unchanged array when array is NULL or invalid index
  *   NULL error
  */
-typedef smallArrayt* (*injectSmallArrayFt)     (smallArrayt *self, intmax_t index, baset *toInject);
-typedef smallArrayt* (*injectUndefinedSmallArrayFt)(smallArrayt *self, intmax_t index);
-typedef smallArrayt* (*injectBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, bool toInject);
-typedef smallArrayt* (*injectDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, double toInject);
-typedef smallArrayt* (*injectIntSmallArrayFt)      (smallArrayt *self, intmax_t index, int64_t toInject);
-typedef smallArrayt* (*injectSSmallArrayFt)        (smallArrayt *self, intmax_t index, const char *toInject);
-typedef smallArrayt* (*injectCharSmallArrayFt)     (smallArrayt *self, intmax_t index, char c);
-typedef smallArrayt* (*injectDictSmallArrayFt)     (smallArrayt *self, intmax_t index, smallDictt *toInject);
-typedef smallArrayt* (*injectArraySmallArrayFt)    (smallArrayt *self, intmax_t index, smallArrayt *toInject);
-typedef smallArrayt* (*injectArraycSmallArrayFt)   (smallArrayt *self, intmax_t index, char **toInject);
-typedef smallArrayt* (*injectSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, smallBoolt *toInject);
-typedef smallArrayt* (*injectSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index, smallBytest *toInject);
-typedef smallArrayt* (*injectSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, smallDoublet *toInject);
-typedef smallArrayt* (*injectSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index, smallIntt *toInject);
-typedef smallArrayt* (*injectSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index, smallJsont *toInject);
-typedef smallArrayt* (*injectSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index, smallStringt *toInject);
-typedef smallArrayt* (*injectSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index, smallContainert *toInject);
-
-typedef smallArrayt* (*injectNFreeSmallArrayFt)         (smallArrayt *self, intmax_t index, baset *toInject);
-typedef smallArrayt* (*injectNFreeUndefinedSmallArrayFt)(smallArrayt *self, intmax_t index, undefinedt *undefined);
-typedef smallArrayt* (*injectNFreeSSmallArrayFt)        (smallArrayt *self, intmax_t index, char *toInject);
-typedef smallArrayt* (*injectNFreeDictSmallArrayFt)     (smallArrayt *self, intmax_t index, smallDictt *toInject);
-typedef smallArrayt* (*injectNFreeArraySmallArrayFt)    (smallArrayt *self, intmax_t index, smallArrayt *toInject);
-typedef smallArrayt* (*injectNFreeArraycSmallArrayFt)   (smallArrayt *self, intmax_t index, char **toInject);
-typedef smallArrayt* (*injectNFreeSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, smallBoolt *toInject);
-typedef smallArrayt* (*injectNFreeSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index, smallBytest *toInject);
-typedef smallArrayt* (*injectNFreeSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, smallDoublet *toInject);
-typedef smallArrayt* (*injectNFreeSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index, smallIntt *toInject);
-typedef smallArrayt* (*injectNFreeSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index, smallJsont *toInject);
-typedef smallArrayt* (*injectNFreeSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index, smallStringt *toInject);
-typedef smallArrayt* (*injectNFreeSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index, smallContainert *toInject);
+typedef smallArrayt* (*injectSmallArrayFt)     (smallArrayt *self, int64_t index, baset *toInject);
+typedef smallArrayt* (*injectUndefinedSmallArrayFt)(smallArrayt *self, int64_t index);
+typedef smallArrayt* (*injectBoolSmallArrayFt)     (smallArrayt *self, int64_t index, bool toInject);
+typedef smallArrayt* (*injectDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, double toInject);
+typedef smallArrayt* (*injectIntSmallArrayFt)      (smallArrayt *self, int64_t index, int64_t toInject);
+typedef smallArrayt* (*injectSSmallArrayFt)        (smallArrayt *self, int64_t index, const char *toInject);
+typedef smallArrayt* (*injectCharSmallArrayFt)     (smallArrayt *self, int64_t index, char c);
+typedef smallArrayt* (*injectDictSmallArrayFt)     (smallArrayt *self, int64_t index, smallDictt *toInject);
+typedef smallArrayt* (*injectArraySmallArrayFt)    (smallArrayt *self, int64_t index, smallArrayt *toInject);
+typedef smallArrayt* (*injectArraycSmallArrayFt)   (smallArrayt *self, int64_t index, char **toInject);
+typedef smallArrayt* (*injectSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index, smallBoolt *toInject);
+typedef smallArrayt* (*injectSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index, smallBytest *toInject);
+typedef smallArrayt* (*injectSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, smallDoublet *toInject);
+typedef smallArrayt* (*injectSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index, smallIntt *toInject);
+typedef smallArrayt* (*injectSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index, smallJsont *toInject);
+typedef smallArrayt* (*injectSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index, smallStringt *toInject);
+typedef smallArrayt* (*injectSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *toInject);
+
+typedef smallArrayt* (*injectNFreeSmallArrayFt)         (smallArrayt *self, int64_t index, baset *toInject);
+typedef smallArrayt* (*injectNFreeUndefinedSmallArrayFt)(smallArrayt *self, int64_t index, undefinedt *undefined);
+typedef smallArrayt* (*injectNFreeSSmallArrayFt)        (smallArrayt *self, int64_t index, char *toInject);
+typedef smallArrayt* (*injectNFreeDictSmallArrayFt)     (smallArrayt *self, int64_t index, smallDictt *toInject);
+typedef smallArrayt* (*injectNFreeArraySmallArrayFt)    (smallArrayt *self, int64_t index, smallArrayt *toInject);
+typedef smallArrayt* (*injectNFreeArraycSmallArrayFt)   (smallArrayt *self, int64_t index, char **toInject);
+typedef smallArrayt* (*injectNFreeSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index, smallBoolt *toInject);
+typedef smallArrayt* (*injectNFreeSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index, smallBytest *toInject);
+typedef smallArrayt* (*injectNFreeSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, smallDoublet *toInject);
+typedef smallArrayt* (*injectNFreeSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index, smallIntt *toInject);
+typedef smallArrayt* (*injectNFreeSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index, smallJsont *toInject);
+typedef smallArrayt* (*injectNFreeSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index, smallStringt *toInject);
+typedef smallArrayt* (*injectNFreeSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *toInject);
 
 /**
  * remove (free) elements from start and end in self
@@ -602,7 +602,7 @@ typedef smallArrayt* (*injectNFreeSmallContainerSmallArrayFt)(smallArrayt *self,
  *   0  success
  *   -1 error
  */
-typedef smallArrayt*          (*delSmallArrayFt)       (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt*          (*delSmallArrayFt)       (smallArrayt *self, int64_t start, int64_t end);
 
 /**
  * delete element
@@ -620,7 +620,7 @@ typedef smallArrayt*          (*delSmallArrayFt)       (smallArrayt *self, intma
  * To dispose a and be able to free all objects, the element at index 0 must be freed with delElem
  * The sObject at index 1 and in s are identical, so the element 1 is freed when s is freed
  */
-typedef smallArrayt*          (*delElemSmallArrayFt)   (smallArrayt *self, intmax_t index);
+typedef smallArrayt*          (*delElemSmallArrayFt)   (smallArrayt *self, int64_t index);
 
 /**
  * remove without freeing elements from start and end in self
@@ -637,7 +637,7 @@ typedef smallArrayt*          (*delElemSmallArrayFt)   (smallArrayt *self, intma
  *   0  success
  *   -1 error
  */
-typedef smallArrayt*          (*removeSmallArrayFt)       (smallArrayt *self, intmax_t start, intmax_t end);
+typedef smallArrayt*          (*removeSmallArrayFt)       (smallArrayt *self, int64_t start, int64_t end);
 
 /**
  * remove without freeing element
@@ -656,7 +656,7 @@ typedef smallArrayt*          (*removeSmallArrayFt)       (smallArrayt *self, in
  * // to do so, it uses removeElemG since S will free the sString object
  * removeElemG(a, 0);
  */
-typedef smallArrayt*          (*removeElemSmallArrayFt)   (smallArrayt *self, intmax_t index);
+typedef smallArrayt*          (*removeElemSmallArrayFt)   (smallArrayt *self, int64_t index);
 
 /**
  * sort self in alphabetic order
@@ -751,31 +751,31 @@ typedef smallArrayt*          (*trimSmallArrayFt)      (smallArrayt *self);
  *   pointer to object
  *   NULL when array is NULL or index is not set correctly
  */
-typedef baset*           (*getAtSmallArrayFt)              (smallArrayt *self, intmax_t index);
-typedef undefinedt*      (*getAtUndefinedSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef bool             (*getAtBoolSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef bool*            (*getAtBoolPSmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef double           (*getAtDoubleSmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef double*          (*getAtDoublePSmallArrayFt)       (smallArrayt *self, intmax_t index);
-typedef int64_t          (*getAtIntSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef int64_t*         (*getAtIntPSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef int32_t          (*getAtInt32SmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef int32_t*         (*getAtInt32PSmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef uint64_t         (*getAtUintSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef uint64_t*        (*getAtUintPSmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef uint32_t         (*getAtUint32SmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef uint32_t*        (*getAtUint32PSmallArrayFt)       (smallArrayt *self, intmax_t index);
-typedef char*            (*getAtSSmallArrayFt)             (smallArrayt *self, intmax_t index);
-typedef smallDictt*      (*getAtDictSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallArrayt*     (*getAtArraySmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef smallBoolt*      (*getAtSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallBytest*     (*getAtSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef smallDoublet*    (*getAtSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index);
-typedef smallIntt*       (*getAtSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef smallJsont*      (*getAtSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallStringt*    (*getAtSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index);
-typedef void*            (*getAtVoidSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallContainert* (*getAtSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index);
+typedef baset*           (*getAtSmallArrayFt)              (smallArrayt *self, int64_t index);
+typedef undefinedt*      (*getAtUndefinedSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef bool             (*getAtBoolSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef bool*            (*getAtBoolPSmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef double           (*getAtDoubleSmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef double*          (*getAtDoublePSmallArrayFt)       (smallArrayt *self, int64_t index);
+typedef int64_t          (*getAtIntSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef int64_t*         (*getAtIntPSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef int32_t          (*getAtInt32SmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef int32_t*         (*getAtInt32PSmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef uint64_t         (*getAtUintSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef uint64_t*        (*getAtUintPSmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef uint32_t         (*getAtUint32SmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef uint32_t*        (*getAtUint32PSmallArrayFt)       (smallArrayt *self, int64_t index);
+typedef char*            (*getAtSSmallArrayFt)             (smallArrayt *self, int64_t index);
+typedef smallDictt*      (*getAtDictSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallArrayt*     (*getAtArraySmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef smallBoolt*      (*getAtSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallBytest*     (*getAtSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef smallDoublet*    (*getAtSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index);
+typedef smallIntt*       (*getAtSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef smallJsont*      (*getAtSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallStringt*    (*getAtSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index);
+typedef void*            (*getAtVoidSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallContainert* (*getAtSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index);
 
 /**
  * get duplicated object
@@ -787,25 +787,25 @@ typedef smallContainert* (*getAtSmallContainerSmallArrayFt)(smallArrayt *self, i
  *   duplicated object
  *   NULL when array is NULL or index is not set correctly
  */
-typedef baset*           (*getAtNDupSmallArrayFt)              (smallArrayt *self, intmax_t index);
-typedef undefinedt*      (*getAtNDupUndefinedSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef bool             (*getAtNDupBoolSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef double           (*getAtNDupDoubleSmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef int64_t          (*getAtNDupIntSmallArrayFt)           (smallArrayt *self, intmax_t index);
-typedef int32_t          (*getAtNDupInt32SmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef uint64_t         (*getAtNDupUintSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef uint32_t         (*getAtNDupUint32SmallArrayFt)        (smallArrayt *self, intmax_t index);
-typedef char*            (*getAtNDupSSmallArrayFt)             (smallArrayt *self, intmax_t index);
-typedef smallDictt*      (*getAtNDupDictSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallArrayt*     (*getAtNDupArraySmallArrayFt)         (smallArrayt *self, intmax_t index);
-typedef smallBoolt*      (*getAtNDupSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallBytest*     (*getAtNDupSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef smallDoublet*    (*getAtNDupSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index);
-typedef smallIntt*       (*getAtNDupSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef smallJsont*       (*getAtNDupSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef smallStringt*    (*getAtNDupSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index);
-typedef void*            (*getAtNDupVoidSmallArrayFt)          (smallArrayt *self, intmax_t index);
-typedef smallContainert* (*getAtNDupSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index);
+typedef baset*           (*getAtNDupSmallArrayFt)              (smallArrayt *self, int64_t index);
+typedef undefinedt*      (*getAtNDupUndefinedSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef bool             (*getAtNDupBoolSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef double           (*getAtNDupDoubleSmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef int64_t          (*getAtNDupIntSmallArrayFt)           (smallArrayt *self, int64_t index);
+typedef int32_t          (*getAtNDupInt32SmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef uint64_t         (*getAtNDupUintSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef uint32_t         (*getAtNDupUint32SmallArrayFt)        (smallArrayt *self, int64_t index);
+typedef char*            (*getAtNDupSSmallArrayFt)             (smallArrayt *self, int64_t index);
+typedef smallDictt*      (*getAtNDupDictSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallArrayt*     (*getAtNDupArraySmallArrayFt)         (smallArrayt *self, int64_t index);
+typedef smallBoolt*      (*getAtNDupSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallBytest*     (*getAtNDupSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef smallDoublet*    (*getAtNDupSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index);
+typedef smallIntt*       (*getAtNDupSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef smallJsont*       (*getAtNDupSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef smallStringt*    (*getAtNDupSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index);
+typedef void*            (*getAtNDupVoidSmallArrayFt)          (smallArrayt *self, int64_t index);
+typedef smallContainert* (*getAtNDupSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index);
 
 /**
  * store object at given index (free already existing elements when baset *value is NULL)
@@ -836,23 +836,23 @@ typedef smallContainert* (*getAtNDupSmallContainerSmallArrayFt)(smallArrayt *sel
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallArrayt*         (*setAtSmallArrayFt)     (smallArrayt *self, intmax_t index, baset *value);
-typedef smallArrayt*         (*setAtUndefinedSmallArrayFt)(smallArrayt *self, intmax_t index);
-typedef smallArrayt*         (*setAtBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, bool value);
-typedef smallArrayt*         (*setAtDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, double value);
-typedef smallArrayt*         (*setAtIntSmallArrayFt)      (smallArrayt *self, intmax_t index, int64_t value);
-typedef smallArrayt*         (*setAtSSmallArrayFt)        (smallArrayt *self, intmax_t index, const char *string);
-typedef smallArrayt*         (*setAtCharSmallArrayFt)     (smallArrayt *self, intmax_t index, char c);
-typedef smallArrayt*         (*setAtDictSmallArrayFt)     (smallArrayt *self, intmax_t index, smallDictt *dict);
-typedef smallArrayt*         (*setAtArraySmallArrayFt)    (smallArrayt *self, intmax_t index, smallArrayt *array);
-typedef smallArrayt*         (*setAtArraycSmallArrayFt)   (smallArrayt *self, intmax_t index, char **array);
-typedef smallArrayt*         (*setAtSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, smallBoolt *value);
-typedef smallArrayt*         (*setAtSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index, smallBytest *value);
-typedef smallArrayt*         (*setAtSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, smallDoublet *value);
-typedef smallArrayt*         (*setAtSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index, smallIntt *value);
-typedef smallArrayt*         (*setAtSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index, smallJsont *value);
-typedef smallArrayt*         (*setAtSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index, smallStringt *string);
-typedef smallArrayt*         (*setAtSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index, smallContainert *container);
+typedef smallArrayt*         (*setAtSmallArrayFt)     (smallArrayt *self, int64_t index, baset *value);
+typedef smallArrayt*         (*setAtUndefinedSmallArrayFt)(smallArrayt *self, int64_t index);
+typedef smallArrayt*         (*setAtBoolSmallArrayFt)     (smallArrayt *self, int64_t index, bool value);
+typedef smallArrayt*         (*setAtDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, double value);
+typedef smallArrayt*         (*setAtIntSmallArrayFt)      (smallArrayt *self, int64_t index, int64_t value);
+typedef smallArrayt*         (*setAtSSmallArrayFt)        (smallArrayt *self, int64_t index, const char *string);
+typedef smallArrayt*         (*setAtCharSmallArrayFt)     (smallArrayt *self, int64_t index, char c);
+typedef smallArrayt*         (*setAtDictSmallArrayFt)     (smallArrayt *self, int64_t index, smallDictt *dict);
+typedef smallArrayt*         (*setAtArraySmallArrayFt)    (smallArrayt *self, int64_t index, smallArrayt *array);
+typedef smallArrayt*         (*setAtArraycSmallArrayFt)   (smallArrayt *self, int64_t index, char **array);
+typedef smallArrayt*         (*setAtSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index, smallBoolt *value);
+typedef smallArrayt*         (*setAtSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index, smallBytest *value);
+typedef smallArrayt*         (*setAtSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, smallDoublet *value);
+typedef smallArrayt*         (*setAtSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index, smallIntt *value);
+typedef smallArrayt*         (*setAtSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index, smallJsont *value);
+typedef smallArrayt*         (*setAtSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index, smallStringt *string);
+typedef smallArrayt*         (*setAtSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *container);
 
 /**
  * store object at given index (free already existing elements)
@@ -870,19 +870,19 @@ typedef smallArrayt*         (*setAtSmallContainerSmallArrayFt)(smallArrayt *sel
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallArrayt*         (*setAtNFreeSmallArrayFt)         (smallArrayt *self, intmax_t index, baset *value);
-typedef smallArrayt*         (*setAtNFreeUndefinedSmallArrayFt)(smallArrayt *self, intmax_t index, undefinedt *undefined);
-typedef smallArrayt*         (*setAtNFreeSSmallArrayFt)        (smallArrayt *self, intmax_t index, char *string);
-typedef smallArrayt*         (*setAtNFreeDictSmallArrayFt)     (smallArrayt *self, intmax_t index, smallDictt *dict);
-typedef smallArrayt*         (*setAtNFreeArraySmallArrayFt)    (smallArrayt *self, intmax_t index, smallArrayt *array);
-typedef smallArrayt*         (*setAtNFreeArraycSmallArrayFt)   (smallArrayt *self, intmax_t index, char **array);
-typedef smallArrayt*         (*setAtNFreeSmallBoolSmallArrayFt)     (smallArrayt *self, intmax_t index, smallBoolt *value);
-typedef smallArrayt*         (*setAtNFreeSmallBytesSmallArrayFt)    (smallArrayt *self, intmax_t index, smallBytest *value);
-typedef smallArrayt*         (*setAtNFreeSmallDoubleSmallArrayFt)   (smallArrayt *self, intmax_t index, smallDoublet *value);
-typedef smallArrayt*         (*setAtNFreeSmallIntSmallArrayFt)      (smallArrayt *self, intmax_t index, smallIntt *value);
-typedef smallArrayt*         (*setAtNFreeSmallJsonSmallArrayFt)     (smallArrayt *self, intmax_t index, smallJsont *value);
-typedef smallArrayt*         (*setAtNFreeSmallStringSmallArrayFt)   (smallArrayt *self, intmax_t index, smallStringt *string);
-typedef smallArrayt*         (*setAtNFreeSmallContainerSmallArrayFt)(smallArrayt *self, intmax_t index, smallContainert *container);
+typedef smallArrayt*         (*setAtNFreeSmallArrayFt)         (smallArrayt *self, int64_t index, baset *value);
+typedef smallArrayt*         (*setAtNFreeUndefinedSmallArrayFt)(smallArrayt *self, int64_t index, undefinedt *undefined);
+typedef smallArrayt*         (*setAtNFreeSSmallArrayFt)        (smallArrayt *self, int64_t index, char *string);
+typedef smallArrayt*         (*setAtNFreeDictSmallArrayFt)     (smallArrayt *self, int64_t index, smallDictt *dict);
+typedef smallArrayt*         (*setAtNFreeArraySmallArrayFt)    (smallArrayt *self, int64_t index, smallArrayt *array);
+typedef smallArrayt*         (*setAtNFreeArraycSmallArrayFt)   (smallArrayt *self, int64_t index, char **array);
+typedef smallArrayt*         (*setAtNFreeSmallBoolSmallArrayFt)     (smallArrayt *self, int64_t index, smallBoolt *value);
+typedef smallArrayt*         (*setAtNFreeSmallBytesSmallArrayFt)    (smallArrayt *self, int64_t index, smallBytest *value);
+typedef smallArrayt*         (*setAtNFreeSmallDoubleSmallArrayFt)   (smallArrayt *self, int64_t index, smallDoublet *value);
+typedef smallArrayt*         (*setAtNFreeSmallIntSmallArrayFt)      (smallArrayt *self, int64_t index, smallIntt *value);
+typedef smallArrayt*         (*setAtNFreeSmallJsonSmallArrayFt)     (smallArrayt *self, int64_t index, smallJsont *value);
+typedef smallArrayt*         (*setAtNFreeSmallStringSmallArrayFt)   (smallArrayt *self, int64_t index, smallStringt *string);
+typedef smallArrayt*         (*setAtNFreeSmallContainerSmallArrayFt)(smallArrayt *self, int64_t index, smallContainert *container);
 
 /**
  * store pointer at given index (existing element is not freed)
@@ -898,14 +898,14 @@ typedef smallArrayt*         (*setAtNFreeSmallContainerSmallArrayFt)(smallArrayt
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallArrayt*         (*setPAtArraySmallArrayFt)           (smallArrayt *self, intmax_t index, smallArrayt *array);
-typedef smallArrayt*         (*setPAtDictSmallArrayFt)            (smallArrayt *self, intmax_t index, smallDictt *dict);
-typedef smallArrayt*         (*setPAtSmallJsonSmallArrayFt)       (smallArrayt *self, intmax_t index, smallJsont *json);
-typedef smallArrayt*         (*setPAtSmallStringSmallArrayFt)     (smallArrayt *self, intmax_t index, smallStringt *string);
-typedef smallArrayt*         (*setPAtNFreeArraySmallArrayFt)      (smallArrayt *self, intmax_t index, smallArrayt *array);
-typedef smallArrayt*         (*setPAtNFreeDictSmallArrayFt)       (smallArrayt *self, intmax_t index, smallDictt *dict);
-typedef smallArrayt*         (*setPAtNFreeSmallJsonSmallArrayFt)  (smallArrayt *self, intmax_t index, smallJsont *json);
-typedef smallArrayt*         (*setPAtNFreeSmallStringSmallArrayFt)(smallArrayt *self, intmax_t index, smallStringt *string);
+typedef smallArrayt*         (*setPAtArraySmallArrayFt)           (smallArrayt *self, int64_t index, smallArrayt *array);
+typedef smallArrayt*         (*setPAtDictSmallArrayFt)            (smallArrayt *self, int64_t index, smallDictt *dict);
+typedef smallArrayt*         (*setPAtSmallJsonSmallArrayFt)       (smallArrayt *self, int64_t index, smallJsont *json);
+typedef smallArrayt*         (*setPAtSmallStringSmallArrayFt)     (smallArrayt *self, int64_t index, smallStringt *string);
+typedef smallArrayt*         (*setPAtNFreeArraySmallArrayFt)      (smallArrayt *self, int64_t index, smallArrayt *array);
+typedef smallArrayt*         (*setPAtNFreeDictSmallArrayFt)       (smallArrayt *self, int64_t index, smallDictt *dict);
+typedef smallArrayt*         (*setPAtNFreeSmallJsonSmallArrayFt)  (smallArrayt *self, int64_t index, smallJsont *json);
+typedef smallArrayt*         (*setPAtNFreeSmallStringSmallArrayFt)(smallArrayt *self, int64_t index, smallStringt *string);
 
 /**
  * get number
@@ -919,7 +919,7 @@ typedef smallArrayt*         (*setPAtNFreeSmallStringSmallArrayFt)(smallArrayt *
  * \return
  *   double type number or 0
  */
-typedef double               (*getNumSmallArrayFt)                 (smallArrayt *self, intmax_t index);
+typedef double               (*getNumSmallArrayFt)                 (smallArrayt *self, int64_t index);
 
 /**
  * check if self has object
@@ -1180,12 +1180,12 @@ typedef void (*enumerateSmallArrayFt)              (smallArrayt *self, void *clo
  */
 typedef baset*   (*iterStartSmallArrayFt)          (smallArrayt *self);
 typedef baset*   (*iterStartLastSmallArrayFt)      (smallArrayt *self);
-typedef baset*   (*iterStartFromSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef baset*   (*iterStartFromStepSmallArrayFt)  (smallArrayt *self, intmax_t index, intmax_t step);
+typedef baset*   (*iterStartFromSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef baset*   (*iterStartFromStepSmallArrayFt)  (smallArrayt *self, int64_t index, int64_t step);
 typedef baset*   (*iterNextSmallArrayFt)           (smallArrayt *self);
 typedef baset*   (*iterElementSmallArrayFt)        (smallArrayt *self);
 typedef ssize_t  (*iterIndexSmallArrayFt)          (smallArrayt *self);
-typedef intmax_t (*iterStepSmallArrayFt)           (smallArrayt *self);
+typedef int64_t (*iterStepSmallArrayFt)           (smallArrayt *self);
 
 /**
  * join list, the elements are seperated with delim in the resulting string
@@ -1325,8 +1325,8 @@ typedef bool          (*appendTextSmallStringSmallArrayFt)(smallArrayt *self, sm
  * \return
  *    object type string
  */
-typedef const char*   (*typeStringSmallArrayFt) (smallArrayt *self, intmax_t index);
-typedef smallStringt* (*typeSmallStringSmallArrayFt)(smallArrayt *self, intmax_t index);
+typedef const char*   (*typeStringSmallArrayFt) (smallArrayt *self, int64_t index);
+typedef smallStringt* (*typeSmallStringSmallArrayFt)(smallArrayt *self, int64_t index);
 
 /**
  * get object type at index
@@ -1336,7 +1336,7 @@ typedef smallStringt* (*typeSmallStringSmallArrayFt)(smallArrayt *self, intmax_t
  * \return
  *    object type
  */
-typedef char         (*typeSmallArrayFt)       (smallArrayt *self, intmax_t index);
+typedef char         (*typeSmallArrayFt)       (smallArrayt *self, int64_t index);
 
 /**
  * get first level of object type string in array
@@ -1358,17 +1358,17 @@ typedef smallBytest* (*typesSmallArrayFt)      (smallArrayt *self);
 /**
  * is element at index of type type
  */
-typedef bool (*isETypeSmallArrayFt)      (smallArrayt *self, intmax_t index, const char *type);
-typedef bool (*isEUndefinedSmallArrayFt) (smallArrayt *self, intmax_t index);
-typedef bool (*isEBoolSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef bool (*isEContainerSmallArrayFt) (smallArrayt *self, intmax_t index);
-typedef bool (*isEDictSmallArrayFt)      (smallArrayt *self, intmax_t index);
-typedef bool (*isEDoubleSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef bool (*isEIntSmallArrayFt)       (smallArrayt *self, intmax_t index);
-typedef bool (*isEStringSmallArrayFt)    (smallArrayt *self, intmax_t index);
-typedef bool (*isEFaststringSmallArrayFt)(smallArrayt *self, intmax_t index);
-typedef bool (*isEArraySmallArrayFt)     (smallArrayt *self, intmax_t index);
-typedef bool (*isEBytesSmallArrayFt)     (smallArrayt *self, intmax_t index);
+typedef bool (*isETypeSmallArrayFt)      (smallArrayt *self, int64_t index, const char *type);
+typedef bool (*isEUndefinedSmallArrayFt) (smallArrayt *self, int64_t index);
+typedef bool (*isEBoolSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef bool (*isEContainerSmallArrayFt) (smallArrayt *self, int64_t index);
+typedef bool (*isEDictSmallArrayFt)      (smallArrayt *self, int64_t index);
+typedef bool (*isEDoubleSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef bool (*isEIntSmallArrayFt)       (smallArrayt *self, int64_t index);
+typedef bool (*isEStringSmallArrayFt)    (smallArrayt *self, int64_t index);
+typedef bool (*isEFaststringSmallArrayFt)(smallArrayt *self, int64_t index);
+typedef bool (*isEArraySmallArrayFt)     (smallArrayt *self, int64_t index);
+typedef bool (*isEBytesSmallArrayFt)     (smallArrayt *self, int64_t index);
 
 /**
  * are all elements of type type
@@ -1866,7 +1866,7 @@ struct smallArray {
   // internal
   sArrayt              *a;
   ssize_t              iterIndex;
-  intmax_t             iterStep;
+  int64_t             iterStep;
   baset*               iterElement;
   // iterElementDataType indicates what the type baset object in iterElement
   // if iterElement is not small* class object then finish must not be called
@@ -2077,96 +2077,96 @@ void*            dequeueVoidSmallArrayG          (smallArrayt *self, void* retTy
 smallContainert* dequeueSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED);
 
 
-baset*           getAtSmallArrayG              (smallArrayt *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, intmax_t index);
-bool*            getAtBoolPSmallArrayG         (smallArrayt *self, bool* retType UNUSED, intmax_t index);
-double           getAtDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, intmax_t index);
-double*          getAtDoublePSmallArrayG       (smallArrayt *self, double* retType UNUSED, intmax_t index);
-int64_t          getAtIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, intmax_t index);
-int64_t*         getAtIntPSmallArrayG          (smallArrayt *self, int64_t* retType UNUSED, intmax_t index);
-int32_t          getAtInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, intmax_t index);
-int32_t*         getAtInt32PSmallArrayG        (smallArrayt *self, int32_t* retType UNUSED, intmax_t index);
-uint64_t         getAtUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, intmax_t index);
-uint64_t*        getAtUintPSmallArrayG         (smallArrayt *self, uint64_t* retType UNUSED, intmax_t index);
-uint32_t         getAtUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, intmax_t index);
-uint32_t*        getAtUint32PSmallArrayG       (smallArrayt *self, uint32_t* retType UNUSED, intmax_t index);
-char*            getAtSSmallArrayG             (smallArrayt *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtSmallBytesSmallArrayG    (smallArrayt *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*      getAtSmallJsonSmallArrayG     (smallArrayt *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, intmax_t index);
-
-baset*           getAtNDupSmallArrayG              (smallArrayt *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtNDupUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtNDupBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, intmax_t index);
-double           getAtNDupDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, intmax_t index);
-int64_t          getAtNDupIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, intmax_t index);
-int32_t          getAtNDupInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, intmax_t index);
-uint64_t         getAtNDupUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, intmax_t index);
-uint32_t         getAtNDupUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, intmax_t index);
-char*            getAtNDupSSmallArrayG             (smallArrayt *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtNDupDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtNDupArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtNDupSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtNDupSmallBytesSmallArrayG    (smallArrayt *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtNDupSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtNDupSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*      getAtNDupSmallJsonSmallArrayG      (smallArrayt *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtNDupSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtNDupVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, intmax_t index);
-
-smallArrayt* setAtSmallArrayG         (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtBoolSmallArrayG     (smallArrayt *self, intmax_t index, bool value);
-smallArrayt* setAtDoubleSmallArrayG   (smallArrayt *self, intmax_t index, double value);
-smallArrayt* setAtIntSmallArrayG      (smallArrayt *self, intmax_t index, int64_t value);
-smallArrayt* setAtSSmallArrayG        (smallArrayt *self, intmax_t index, const char *string);
-smallArrayt* setAtCharSmallArrayG     (smallArrayt *self, intmax_t index, char c);
-smallArrayt* setAtDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setAtArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setAtArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* setAtCArraycSmallArrayG  (smallArrayt *self, intmax_t index, const char **array);
-smallArrayt* setAtVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* setAtSmallBytesSmallArrayG    (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* setAtSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* setAtSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* setAtSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *value);
-smallArrayt* setAtSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-smallArrayt* setAtNFreeSmallArrayG    (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtNFreeSSmallArrayG        (smallArrayt *self, intmax_t index, char *string);
-smallArrayt* setAtNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setAtNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setAtNFreeArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* setAtNFreeVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* setAtNFreeSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* setAtNFreeSmallBytesSmallArrayG    (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* setAtNFreeSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* setAtNFreeSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* setAtNFreeSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *value);
-smallArrayt* setAtNFreeSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-
-smallArrayt* setPAtDictSmallArrayG              (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setPAtArraySmallArrayG             (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setPAtSmallJsonSmallArrayG         (smallArrayt *self, intmax_t index, smallJsont *json);
-smallArrayt* setPAtSmallStringSmallArrayG       (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* setPAtNFreeDictSmallArrayG         (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* setPAtNFreeArraySmallArrayG        (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* setPAtNFreeSmallJsonSmallArrayG    (smallArrayt *self, intmax_t index, smallJsont *json);
-smallArrayt* setPAtNFreeSmallStringSmallArrayG  (smallArrayt *self, intmax_t index, smallStringt *string);
-
-double       getNumSmallArrayG                  (smallArrayt *self, intmax_t index);
+baset*           getAtSmallArrayG              (smallArrayt *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, int64_t index);
+bool*            getAtBoolPSmallArrayG         (smallArrayt *self, bool* retType UNUSED, int64_t index);
+double           getAtDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, int64_t index);
+double*          getAtDoublePSmallArrayG       (smallArrayt *self, double* retType UNUSED, int64_t index);
+int64_t          getAtIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, int64_t index);
+int64_t*         getAtIntPSmallArrayG          (smallArrayt *self, int64_t* retType UNUSED, int64_t index);
+int32_t          getAtInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, int64_t index);
+int32_t*         getAtInt32PSmallArrayG        (smallArrayt *self, int32_t* retType UNUSED, int64_t index);
+uint64_t         getAtUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, int64_t index);
+uint64_t*        getAtUintPSmallArrayG         (smallArrayt *self, uint64_t* retType UNUSED, int64_t index);
+uint32_t         getAtUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, int64_t index);
+uint32_t*        getAtUint32PSmallArrayG       (smallArrayt *self, uint32_t* retType UNUSED, int64_t index);
+char*            getAtSSmallArrayG             (smallArrayt *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtSmallBytesSmallArrayG    (smallArrayt *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*      getAtSmallJsonSmallArrayG     (smallArrayt *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index);
+
+baset*           getAtNDupSmallArrayG              (smallArrayt *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtNDupUndefinedSmallArrayG     (smallArrayt *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtNDupBoolSmallArrayG          (smallArrayt *self, bool retType UNUSED, int64_t index);
+double           getAtNDupDoubleSmallArrayG        (smallArrayt *self, double retType UNUSED, int64_t index);
+int64_t          getAtNDupIntSmallArrayG           (smallArrayt *self, int64_t retType UNUSED, int64_t index);
+int32_t          getAtNDupInt32SmallArrayG         (smallArrayt *self, int32_t retType UNUSED, int64_t index);
+uint64_t         getAtNDupUintSmallArrayG          (smallArrayt *self, uint64_t retType UNUSED, int64_t index);
+uint32_t         getAtNDupUint32SmallArrayG        (smallArrayt *self, uint32_t retType UNUSED, int64_t index);
+char*            getAtNDupSSmallArrayG             (smallArrayt *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtNDupDictSmallArrayG          (smallArrayt *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtNDupArraySmallArrayG         (smallArrayt *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtNDupSmallBoolSmallArrayG     (smallArrayt *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtNDupSmallBytesSmallArrayG    (smallArrayt *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtNDupSmallDoubleSmallArrayG   (smallArrayt *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtNDupSmallIntSmallArrayG      (smallArrayt *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*      getAtNDupSmallJsonSmallArrayG      (smallArrayt *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtNDupSmallStringSmallArrayG   (smallArrayt *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtNDupVoidSmallArrayG          (smallArrayt *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtNDupSmallContainerSmallArrayG(smallArrayt *self, smallContainert* retType UNUSED, int64_t index);
+
+smallArrayt* setAtSmallArrayG         (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* setAtUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtBoolSmallArrayG     (smallArrayt *self, int64_t index, bool value);
+smallArrayt* setAtDoubleSmallArrayG   (smallArrayt *self, int64_t index, double value);
+smallArrayt* setAtIntSmallArrayG      (smallArrayt *self, int64_t index, int64_t value);
+smallArrayt* setAtSSmallArrayG        (smallArrayt *self, int64_t index, const char *string);
+smallArrayt* setAtCharSmallArrayG     (smallArrayt *self, int64_t index, char c);
+smallArrayt* setAtDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setAtArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setAtArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* setAtCArraycSmallArrayG  (smallArrayt *self, int64_t index, const char **array);
+smallArrayt* setAtVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* setAtSmallBytesSmallArrayG    (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* setAtSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* setAtSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* setAtSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *value);
+smallArrayt* setAtSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* setAtSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+smallArrayt* setAtNFreeSmallArrayG    (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* setAtNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtNFreeSSmallArrayG        (smallArrayt *self, int64_t index, char *string);
+smallArrayt* setAtNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setAtNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setAtNFreeArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* setAtNFreeVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* setAtNFreeSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* setAtNFreeSmallBytesSmallArrayG    (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* setAtNFreeSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* setAtNFreeSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* setAtNFreeSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *value);
+smallArrayt* setAtNFreeSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* setAtNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+
+smallArrayt* setPAtDictSmallArrayG              (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setPAtArraySmallArrayG             (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setPAtSmallJsonSmallArrayG         (smallArrayt *self, int64_t index, smallJsont *json);
+smallArrayt* setPAtSmallStringSmallArrayG       (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* setPAtNFreeDictSmallArrayG         (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* setPAtNFreeArraySmallArrayG        (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* setPAtNFreeSmallJsonSmallArrayG    (smallArrayt *self, int64_t index, smallJsont *json);
+smallArrayt* setPAtNFreeSmallStringSmallArrayG  (smallArrayt *self, int64_t index, smallStringt *string);
+
+double       getNumSmallArrayG                  (smallArrayt *self, int64_t index);
 
 smallArrayt* reverseSmallArrayG              (smallArrayt *self);
 smallArrayt* appendSmallArrayG               (smallArrayt *self, smallArrayt *array);
@@ -2182,71 +2182,71 @@ smallArrayt* shiftNSmashSmallArrayG          (smallArrayt *self, smallArrayt *ar
 smallArrayt* shiftNSmashSmallJsonSmallArrayG (smallArrayt *self, smallJsont *json);
 
 smallArrayt* addSmallArrayG  (smallArrayt *self, smallArrayt *array);
-smallArrayt* sliceSmallArrayG(smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* cropSmallArrayG                      (smallArrayt *self, intmax_t start, intmax_t end);
-baset* cropElemSmallArrayG                        (smallArrayt *self, intmax_t index);
-undefinedt* cropElemUndefinedSmallArrayG          (smallArrayt *self, intmax_t index);
-bool cropElemBoolSmallArrayG                      (smallArrayt *self, intmax_t index);
-double cropElemDoubleSmallArrayG                  (smallArrayt *self, intmax_t index);
-int64_t cropElemIntSmallArrayG                    (smallArrayt *self, intmax_t index);
-int32_t cropElemInt32SmallArrayG                  (smallArrayt *self, intmax_t index);
-uint64_t cropElemUintSmallArrayG                  (smallArrayt *self, intmax_t index);
-uint32_t cropElemUint32SmallArrayG                (smallArrayt *self, intmax_t index);
-char* cropElemSSmallArrayG                        (smallArrayt *self, intmax_t index);
-smallDictt* cropElemDictSmallArrayG               (smallArrayt *self, intmax_t index);
-smallArrayt* cropElemArraySmallArrayG             (smallArrayt *self, intmax_t index);
-smallBoolt* cropElemSmallBoolSmallArrayG          (smallArrayt *self, intmax_t index);
-smallBytest* cropElemSmallBytesSmallArrayG        (smallArrayt *self, intmax_t index);
-smallDoublet* cropElemSmallDoubleSmallArrayG      (smallArrayt *self, intmax_t index);
-smallIntt* cropElemSmallIntSmallArrayG            (smallArrayt *self, intmax_t index);
-smallJsont* cropElemSmallJsonSmallArrayG          (smallArrayt *self, intmax_t index);
-smallStringt* cropElemSmallStringSmallArrayG      (smallArrayt *self, intmax_t index);
-void* cropElemVoidSmallArrayG                     (smallArrayt *self, intmax_t index);
-smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, intmax_t index);
-smallArrayt* copySmallArrayG (smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* insertSmallArrayG               (smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-smallArrayt* insertSmallJsonSmallArrayG      (smallArrayt *self, intmax_t index, smallJsont *toInsert);
-smallArrayt* insertNSmashSmallArrayG         (smallArrayt *self, intmax_t index, smallArrayt *toInsert);
-smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, intmax_t index, smallJsont *toInsert);
-
-smallArrayt* injectSmallArrayG         (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, intmax_t index, void *value);
-smallArrayt* injectBoolSmallArrayG     (smallArrayt *self, intmax_t index, bool value);
-smallArrayt* injectDoubleSmallArrayG   (smallArrayt *self, intmax_t index, double value);
-smallArrayt* injectIntSmallArrayG      (smallArrayt *self, intmax_t index, int64_t value);
-smallArrayt* injectSSmallArrayG        (smallArrayt *self, intmax_t index, const char *string);
-smallArrayt* injectCharSmallArrayG(smallArrayt *self, intmax_t index, char c);
-smallArrayt* injectDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* injectArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* injectArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* injectCArraycSmallArrayG   (smallArrayt *self, intmax_t index, const char **array);
-smallArrayt* injectVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* injectSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* injectSmallBytesSmallArrayG    (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* injectSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* injectSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* injectSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *string);
-smallArrayt* injectSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-smallArrayt* injectNFreeSmallArrayG    (smallArrayt *self, intmax_t index, baset *value);
-smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, intmax_t index, undefinedt *value);
-smallArrayt* injectNFreeSSmallArrayG        (smallArrayt *self, intmax_t index, char *string);
-smallArrayt* injectNFreeDictSmallArrayG     (smallArrayt *self, intmax_t index, smallDictt *dict);
-smallArrayt* injectNFreeArraySmallArrayG    (smallArrayt *self, intmax_t index, smallArrayt *array);
-smallArrayt* injectNFreeArraycSmallArrayG   (smallArrayt *self, intmax_t index, char **array);
-smallArrayt* injectNFreeVoidSmallArrayG     (smallArrayt *self, intmax_t index, void *value);
-smallArrayt* injectNFreeSmallBoolSmallArrayG     (smallArrayt *self, intmax_t index, smallBoolt *value);
-smallArrayt* injectNFreeSmallBytesSmallArrayG    (smallArrayt *self, intmax_t index, smallBytest *value);
-smallArrayt* injectNFreeSmallDoubleSmallArrayG   (smallArrayt *self, intmax_t index, smallDoublet *value);
-smallArrayt* injectNFreeSmallIntSmallArrayG      (smallArrayt *self, intmax_t index, smallIntt *value);
-smallArrayt* injectNFreeSmallJsonSmallArrayG     (smallArrayt *self, intmax_t index, smallJsont *string);
-smallArrayt* injectNFreeSmallStringSmallArrayG   (smallArrayt *self, intmax_t index, smallStringt *string);
-smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, intmax_t index, smallContainert *container);
-
-smallArrayt* delSmallArrayG           (smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* delElemSmallArrayG       (smallArrayt *self, intmax_t index);
-smallArrayt* removeSmallArrayG        (smallArrayt *self, intmax_t start, intmax_t end);
-smallArrayt* removeElemSmallArrayG    (smallArrayt *self, intmax_t index);
+smallArrayt* sliceSmallArrayG(smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* cropSmallArrayG                      (smallArrayt *self, int64_t start, int64_t end);
+baset* cropElemSmallArrayG                        (smallArrayt *self, int64_t index);
+undefinedt* cropElemUndefinedSmallArrayG          (smallArrayt *self, int64_t index);
+bool cropElemBoolSmallArrayG                      (smallArrayt *self, int64_t index);
+double cropElemDoubleSmallArrayG                  (smallArrayt *self, int64_t index);
+int64_t cropElemIntSmallArrayG                    (smallArrayt *self, int64_t index);
+int32_t cropElemInt32SmallArrayG                  (smallArrayt *self, int64_t index);
+uint64_t cropElemUintSmallArrayG                  (smallArrayt *self, int64_t index);
+uint32_t cropElemUint32SmallArrayG                (smallArrayt *self, int64_t index);
+char* cropElemSSmallArrayG                        (smallArrayt *self, int64_t index);
+smallDictt* cropElemDictSmallArrayG               (smallArrayt *self, int64_t index);
+smallArrayt* cropElemArraySmallArrayG             (smallArrayt *self, int64_t index);
+smallBoolt* cropElemSmallBoolSmallArrayG          (smallArrayt *self, int64_t index);
+smallBytest* cropElemSmallBytesSmallArrayG        (smallArrayt *self, int64_t index);
+smallDoublet* cropElemSmallDoubleSmallArrayG      (smallArrayt *self, int64_t index);
+smallIntt* cropElemSmallIntSmallArrayG            (smallArrayt *self, int64_t index);
+smallJsont* cropElemSmallJsonSmallArrayG          (smallArrayt *self, int64_t index);
+smallStringt* cropElemSmallStringSmallArrayG      (smallArrayt *self, int64_t index);
+void* cropElemVoidSmallArrayG                     (smallArrayt *self, int64_t index);
+smallContainert* cropElemSmallContainerSmallArrayG(smallArrayt *self, int64_t index);
+smallArrayt* copySmallArrayG (smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* insertSmallArrayG               (smallArrayt *self, int64_t index, smallArrayt *toInsert);
+smallArrayt* insertSmallJsonSmallArrayG      (smallArrayt *self, int64_t index, smallJsont *toInsert);
+smallArrayt* insertNSmashSmallArrayG         (smallArrayt *self, int64_t index, smallArrayt *toInsert);
+smallArrayt* insertNSmashSmallJsonSmallArrayG(smallArrayt *self, int64_t index, smallJsont *toInsert);
+
+smallArrayt* injectSmallArrayG         (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* injectUndefinedSmallArrayG(smallArrayt *self, int64_t index, void *value);
+smallArrayt* injectBoolSmallArrayG     (smallArrayt *self, int64_t index, bool value);
+smallArrayt* injectDoubleSmallArrayG   (smallArrayt *self, int64_t index, double value);
+smallArrayt* injectIntSmallArrayG      (smallArrayt *self, int64_t index, int64_t value);
+smallArrayt* injectSSmallArrayG        (smallArrayt *self, int64_t index, const char *string);
+smallArrayt* injectCharSmallArrayG(smallArrayt *self, int64_t index, char c);
+smallArrayt* injectDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* injectArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* injectArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* injectCArraycSmallArrayG   (smallArrayt *self, int64_t index, const char **array);
+smallArrayt* injectVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* injectSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* injectSmallBytesSmallArrayG    (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* injectSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* injectSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* injectSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *string);
+smallArrayt* injectSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* injectSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+smallArrayt* injectNFreeSmallArrayG    (smallArrayt *self, int64_t index, baset *value);
+smallArrayt* injectNFreeUndefinedSmallArrayG(smallArrayt *self, int64_t index, undefinedt *value);
+smallArrayt* injectNFreeSSmallArrayG        (smallArrayt *self, int64_t index, char *string);
+smallArrayt* injectNFreeDictSmallArrayG     (smallArrayt *self, int64_t index, smallDictt *dict);
+smallArrayt* injectNFreeArraySmallArrayG    (smallArrayt *self, int64_t index, smallArrayt *array);
+smallArrayt* injectNFreeArraycSmallArrayG   (smallArrayt *self, int64_t index, char **array);
+smallArrayt* injectNFreeVoidSmallArrayG     (smallArrayt *self, int64_t index, void *value);
+smallArrayt* injectNFreeSmallBoolSmallArrayG     (smallArrayt *self, int64_t index, smallBoolt *value);
+smallArrayt* injectNFreeSmallBytesSmallArrayG    (smallArrayt *self, int64_t index, smallBytest *value);
+smallArrayt* injectNFreeSmallDoubleSmallArrayG   (smallArrayt *self, int64_t index, smallDoublet *value);
+smallArrayt* injectNFreeSmallIntSmallArrayG      (smallArrayt *self, int64_t index, smallIntt *value);
+smallArrayt* injectNFreeSmallJsonSmallArrayG     (smallArrayt *self, int64_t index, smallJsont *string);
+smallArrayt* injectNFreeSmallStringSmallArrayG   (smallArrayt *self, int64_t index, smallStringt *string);
+smallArrayt* injectNFreeSmallContainerSmallArrayG(smallArrayt *self, int64_t index, smallContainert *container);
+
+smallArrayt* delSmallArrayG           (smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* delElemSmallArrayG       (smallArrayt *self, int64_t index);
+smallArrayt* removeSmallArrayG        (smallArrayt *self, int64_t start, int64_t end);
+smallArrayt* removeElemSmallArrayG    (smallArrayt *self, int64_t index);
 smallArrayt* sortSmallArrayG          (smallArrayt *self);
 smallArrayt* sortFSmallArrayG         (smallArrayt *self, shCmpt compareFunction);
 smallArrayt* icSortSmallArrayG        (smallArrayt *self);
@@ -2384,7 +2384,7 @@ bool writeTextSmallStringSmallArrayG (smallArrayt *self, smallStringt *filePath)
 bool writeStreamSmallArrayG          (smallArrayt *self, FILE *fp);
 bool appendTextSmallArrayG(smallArrayt *self, const char *filePath);
 bool appendTextSmallStringSmallArrayG(smallArrayt *self, smallStringt *filePath);
-smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, intmax_t index);
+smallStringt* typeSmallStringSmallArrayG(smallArrayt *self, int64_t index);
 smallArrayt* typeSmallStringsSmallArrayG(smallArrayt *self);
 
 /**
diff --git a/src/json/libsheepyCSmallBool.c b/src/json/libsheepyCSmallBool.c
@@ -92,8 +92,8 @@ internal int writeStreamSmallBool(smallBoolt *self, FILE *fp);
 internal int appendFileSmallBool(smallBoolt *self, const char *filePath);
 internal int appendFileSmallStringSmallBool(smallBoolt *self, smallStringt *filePath);
 smallBoolt* duplicateSmallBoolG (smallBoolt *self);
-bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, intmax_t index UNUSED);
-bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, intmax_t index UNUSED);
+bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, int64_t index UNUSED);
+bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, int64_t index UNUSED);
 smallBoolt* setSmallBoolG(smallBoolt* self, bool p2);
 smallBoolt* setDoubleSmallBoolG(smallBoolt* self, double p2);
 smallBoolt* setInt64SmallBoolG(smallBoolt* self, int64_t p2);
@@ -950,12 +950,12 @@ smallBoolt* duplicateSmallBoolG (smallBoolt *self) {
 
 void             freeSmallBoolG             (smallBoolt *self) {self->f->free(self);}
 
-bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, intmax_t index UNUSED) {
+bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, int64_t index UNUSED) {
 
   return(self->f->get(self));
 }
 
-bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, intmax_t index UNUSED) {
+bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, int64_t index UNUSED) {
 
   return(self->f->getP(self));
 }
diff --git a/src/json/libsheepyCSmallBool.h b/src/json/libsheepyCSmallBool.h
@@ -285,8 +285,8 @@ smallBoolt* duplicateSmallBoolG (smallBoolt *self);
 
 void    freeSmallBoolG      (smallBoolt *self);
 
-bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, intmax_t index UNUSED);
-bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, intmax_t index UNUSED);
+bool             getBoolSmallBoolG          (smallBoolt *self, bool retType UNUSED, int64_t index UNUSED);
+bool*            getBoolPSmallBoolG         (smallBoolt *self, bool* retType UNUSED, int64_t index UNUSED);
 
 smallBoolt* setSmallBoolG(smallBoolt* self, bool p2);
 smallBoolt* setDoubleSmallBoolG(smallBoolt* self, double p2);
diff --git a/src/json/libsheepyCSmallBytes.c b/src/json/libsheepyCSmallBytes.c
@@ -56,7 +56,7 @@ internal void* getSmallBytes(smallBytest *self);
 internal smallBytest* setSmallBytes(smallBytest *self, void *data, uint32_t size);
 internal smallBytest* pushSmallBytes(smallBytest *self, char data);
 internal smallBytest* pushBufferSmallBytes(smallBytest *self, void *data, uint32_t size);
-internal char getAtSmallBytes(smallBytest *self, intmax_t index);
+internal char getAtSmallBytes(smallBytest *self, int64_t index);
 internal size_t lenSmallBytes(smallBytest *self);
 internal bool isEmptySmallBytes(smallBytest *self);
 internal smallBytest* readFileSmallBytes(smallBytest *self, const char *filePath);
@@ -83,7 +83,7 @@ internal bool equalSmallBytesChar(smallBytest *self, const char *value);
 internal bool equalSmallBytesSmallString(smallBytest *self, smallStringt *value);
 internal bool equalSmallBytesBase(smallBytest *self, baset *value);
 smallBytest* duplicateSmallBytesG (smallBytest *self);
-char getAtSmallBytesG(smallBytest *self, char retType UNUSED, intmax_t index);
+char getAtSmallBytesG(smallBytest *self, char retType UNUSED, int64_t index);
 smallBytest* pushSmallBytesG (smallBytest *self, char data);
 size_t lenSmallBytesG(smallBytest *self);
 bool isEmptySmallBytesG(smallBytest *self);
@@ -328,7 +328,7 @@ internal smallBytest* pushBufferSmallBytes(smallBytest *self, void *data, uint32
   return(self);
 }
 
-internal char getAtSmallBytes(smallBytest *self, intmax_t index) {
+internal char getAtSmallBytes(smallBytest *self, int64_t index) {
 
   if (!self->B) {
     return(0);
@@ -337,11 +337,11 @@ internal char getAtSmallBytes(smallBytest *self, intmax_t index) {
   if (index >= self->B->count) {
     return(0);
   }
-  if (index < -(intmax_t)self->B->count) {
+  if (index < -(int64_t)self->B->count) {
     return(0);
   }
   if (index < 0) {
-    index = (intmax_t)self->B->count + index;
+    index = (int64_t)self->B->count + index;
   }
 
   return((&(self->B->data))[index]);
@@ -844,7 +844,7 @@ smallBytest* duplicateSmallBytesG (smallBytest *self) {
 
 void freeSmallBytesG (smallBytest *self) {self->f->free(self);}
 
-char getAtSmallBytesG(smallBytest *self, char retType UNUSED, intmax_t index) {
+char getAtSmallBytesG(smallBytest *self, char retType UNUSED, int64_t index) {
 
   return(self->f->getAt(self,index));
 }
diff --git a/src/json/libsheepyCSmallBytes.h b/src/json/libsheepyCSmallBytes.h
@@ -89,7 +89,7 @@ typedef smallBytest*    (*pushBufferSmallBytesFt) (smallBytest *self, void *data
  * \return
  *    char at index
  */
-typedef char            (*getAtSmallBytesFt) (smallBytest *self, intmax_t index);
+typedef char            (*getAtSmallBytesFt) (smallBytest *self, int64_t index);
 
 /**
  * return buffer size in bytes
@@ -300,7 +300,7 @@ smallBytest* duplicateSmallBytesG (smallBytest *self);
 
 void            freeSmallBytesG      (smallBytest *self);
 
-char getAtSmallBytesG(smallBytest *self, char retType UNUSED, intmax_t index);
+char getAtSmallBytesG(smallBytest *self, char retType UNUSED, int64_t index);
 smallBytest* pushSmallBytesG (smallBytest *self, char data);
 size_t lenSmallBytesG(smallBytest *self);
 bool isEmptySmallBytesG(smallBytest *self);
diff --git a/src/json/libsheepyCSmallContainer.c b/src/json/libsheepyCSmallContainer.c
@@ -27,6 +27,7 @@
 #define internal static
 
 #include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 #include <stdio.h>
 
@@ -60,7 +61,7 @@ internal void smashSmallContainer(smallContainert **self);
 internal void* getSmallContainer(smallContainert *self);
 internal smallContainert* setSmallContainer(smallContainert *self, void *data);
 smallContainert* duplicateSmallContainerG              (smallContainert *self);
-void* getSmallContainerG(smallContainert *self, void* retType UNUSED, intmax_t index UNUSED);
+void* getSmallContainerG(smallContainert *self, void* retType UNUSED, int64_t index UNUSED);
 smallContainert* setSmallContainerG(smallContainert *self, void *data);
 
 void initiateSmallContainer(smallContainert *self) {
@@ -348,7 +349,7 @@ smallContainert* duplicateSmallContainerG              (smallContainert *self) {
 
 void  freeSmallContainerG(smallContainert *self) {self->f->free(self);}
 
-void* getSmallContainerG(smallContainert *self, void* retType UNUSED, intmax_t index UNUSED) {
+void* getSmallContainerG(smallContainert *self, void* retType UNUSED, int64_t index UNUSED) {
 
   return(self->f->get(self));
 }
diff --git a/src/json/libsheepyCSmallContainer.h b/src/json/libsheepyCSmallContainer.h
@@ -255,7 +255,7 @@ smallContainert* duplicateSmallContainerG              (smallContainert *self);
 
 void  freeSmallContainerG(smallContainert *self);
 
-void* getSmallContainerG(smallContainert *self, void* retType UNUSED, intmax_t index UNUSED);
+void* getSmallContainerG(smallContainert *self, void* retType UNUSED, int64_t index UNUSED);
 
 smallContainert* setSmallContainerG(smallContainert *self, void *data);
 
diff --git a/src/json/libsheepyCSmallDouble.c b/src/json/libsheepyCSmallDouble.c
@@ -92,7 +92,7 @@ internal int writeStreamSmallDouble(smallDoublet *self, FILE *fp);
 internal int appendFileSmallDouble(smallDoublet *self, const char *filePath);
 internal int appendFileSmallStringSmallDouble(smallDoublet *self, smallStringt *filePath);
 smallDoublet*      duplicateSmallDoubleG          (smallDoublet *self);
-double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, intmax_t index UNUSED);
+double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, int64_t index UNUSED);
 smallDoublet* setBoolSmallDoubleG(smallDoublet* self, bool p2);
 smallDoublet* setSmallDoubleG(smallDoublet* self, double p2);
 smallDoublet* setInt64SmallDoubleG(smallDoublet* self, int64_t p2);
@@ -105,7 +105,7 @@ smallDoublet* setSmallDoubleSmallDoubleG(smallDoublet* self, smallDoublet* p2);
 smallDoublet* setSmallIntSmallDoubleG(smallDoublet* self, smallIntt* p2);
 smallDoublet* setSmallJsonSmallDoubleG(smallDoublet* self, smallJsont* p2);
 smallDoublet* setSmallStringSmallDoubleG(smallDoublet* self, smallStringt* p2);
-double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, intmax_t index UNUSED);
+double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, int64_t index UNUSED);
 bool equalSmallDoubleChaG(smallDoublet* self, char p2);
 bool equalSmallDoubleCharG(smallDoublet* self, const char * p2);
 bool equalSmallDoubleBaseG(smallDoublet* self, baset* p2);
@@ -944,7 +944,7 @@ smallDoublet*      duplicateSmallDoubleG          (smallDoublet *self) {
 
 void               freeSmallDoubleG               (smallDoublet *self) {self->f->free(self);}
 
-double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, intmax_t index UNUSED) {
+double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, int64_t index UNUSED) {
 
   return(self->f->get(self));
 }
@@ -1010,7 +1010,7 @@ smallDoublet* setSmallStringSmallDoubleG(smallDoublet* self, smallStringt* p2) {
 }
 
 
-double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, intmax_t index UNUSED) {
+double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, int64_t index UNUSED) {
 
   return(self->f->getP(self));
 }
diff --git a/src/json/libsheepyCSmallDouble.h b/src/json/libsheepyCSmallDouble.h
@@ -283,7 +283,7 @@ smallDoublet*      duplicateSmallDoubleG          (smallDoublet *self);
 
 void               freeSmallDoubleG               (smallDoublet *self);
 
-double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, intmax_t index UNUSED);
+double             getDoubleSmallDoubleG          (smallDoublet *self, double retType UNUSED, int64_t index UNUSED);
 
 smallDoublet*               setBoolSmallDoubleG            (smallDoublet* self, bool p2);
 smallDoublet*               setSmallDoubleG                (smallDoublet* self, double p2);
@@ -298,7 +298,7 @@ smallDoublet*               setSmallIntSmallDoubleG        (smallDoublet* self, 
 smallDoublet*               setSmallJsonSmallDoubleG       (smallDoublet* self, smallJsont* p2);
 smallDoublet*               setSmallStringSmallDoubleG     (smallDoublet* self, smallStringt* p2);
 
-double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, intmax_t index UNUSED);
+double*            getDoublePSmallDoubleG         (smallDoublet *self, double* retType UNUSED, int64_t index UNUSED);
 
 bool               equalSmallDoubleChaG           (smallDoublet* self, char p2);
 bool               equalSmallDoubleCharG          (smallDoublet* self, const char * p2);
diff --git a/src/json/libsheepyCSmallInt.c b/src/json/libsheepyCSmallInt.c
@@ -93,14 +93,14 @@ internal int writeStreamSmallInt(smallIntt *self, FILE *fp);
 internal int appendFileSmallInt(smallIntt *self, const char *filePath);
 internal int appendFileSmallStringSmallInt(smallIntt *self, smallStringt *filePath);
 smallIntt*          duplicateSmallIntG       (smallIntt *self);
-int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, intmax_t index UNUSED);
-int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, intmax_t index UNUSED);
-int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, intmax_t index UNUSED);
-int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, intmax_t index UNUSED);
-uint64_t            getUintSmallIntG          (smallIntt *self, uint64_t retType UNUSED, intmax_t index UNUSED);
-uint64_t*           getUintPSmallIntG         (smallIntt *self, uint64_t* retType UNUSED, intmax_t index UNUSED);
-uint32_t            getUint32SmallIntG        (smallIntt *self, uint32_t retType UNUSED, intmax_t index UNUSED);
-uint32_t*           getUint32PSmallIntG       (smallIntt *self, uint32_t* retType UNUSED, intmax_t index UNUSED);
+int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, int64_t index UNUSED);
+int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, int64_t index UNUSED);
+int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, int64_t index UNUSED);
+int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, int64_t index UNUSED);
+uint64_t            getUintSmallIntG          (smallIntt *self, uint64_t retType UNUSED, int64_t index UNUSED);
+uint64_t*           getUintPSmallIntG         (smallIntt *self, uint64_t* retType UNUSED, int64_t index UNUSED);
+uint32_t            getUint32SmallIntG        (smallIntt *self, uint32_t retType UNUSED, int64_t index UNUSED);
+uint32_t*           getUint32PSmallIntG       (smallIntt *self, uint32_t* retType UNUSED, int64_t index UNUSED);
 smallIntt* setBoolSmallIntG(smallIntt* self, bool p2);
 smallIntt* setDoubleSmallIntG(smallIntt* self, double p2);
 smallIntt* setInt32SmallIntG(smallIntt* self, int32_t p2);
@@ -947,42 +947,42 @@ smallIntt*          duplicateSmallIntG       (smallIntt *self) {
 
 void                freeSmallIntG            (smallIntt *self) {self->f->free(self);}
 
-int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, intmax_t index UNUSED) {
+int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, int64_t index UNUSED) {
 
   return(self->f->get(self));
 }
 
-int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, intmax_t index UNUSED) {
+int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, int64_t index UNUSED) {
 
   return(self->f->getP(self));
 }
 
-int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, intmax_t index UNUSED) {
+int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, int64_t index UNUSED) {
 
   return((int32_t)self->f->get(self));
 }
 
-int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, intmax_t index UNUSED) {
+int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, int64_t index UNUSED) {
 
   return((int32_t*)self->f->getP(self));
 }
 
-uint64_t            getUintSmallIntG          (smallIntt *self, uint64_t retType UNUSED, intmax_t index UNUSED) {
+uint64_t            getUintSmallIntG          (smallIntt *self, uint64_t retType UNUSED, int64_t index UNUSED) {
 
   return((uint64_t)self->f->get(self));
 }
 
-uint64_t*           getUintPSmallIntG         (smallIntt *self, uint64_t* retType UNUSED, intmax_t index UNUSED) {
+uint64_t*           getUintPSmallIntG         (smallIntt *self, uint64_t* retType UNUSED, int64_t index UNUSED) {
 
   return((uint64_t*)self->f->getP(self));
 }
 
-uint32_t            getUint32SmallIntG        (smallIntt *self, uint32_t retType UNUSED, intmax_t index UNUSED) {
+uint32_t            getUint32SmallIntG        (smallIntt *self, uint32_t retType UNUSED, int64_t index UNUSED) {
 
   return((uint32_t)self->f->get(self));
 }
 
-uint32_t*           getUint32PSmallIntG       (smallIntt *self, uint32_t* retType UNUSED, intmax_t index UNUSED) {
+uint32_t*           getUint32PSmallIntG       (smallIntt *self, uint32_t* retType UNUSED, int64_t index UNUSED) {
 
   return((uint32_t*)self->f->getP(self));
 }
diff --git a/src/json/libsheepyCSmallInt.h b/src/json/libsheepyCSmallInt.h
@@ -285,14 +285,14 @@ smallIntt*          duplicateSmallIntG       (smallIntt *self);
 
 void                freeSmallIntG            (smallIntt *self);
 
-int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, intmax_t index UNUSED);
-int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, intmax_t index UNUSED);
-int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, intmax_t index UNUSED);
-int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, intmax_t index UNUSED);
-uint64_t            getUintSmallIntG         (smallIntt *self, uint64_t retType UNUSED, intmax_t index UNUSED);
-uint64_t*           getUintPSmallIntG        (smallIntt *self, uint64_t* retType UNUSED, intmax_t index UNUSED);
-uint32_t            getUint32SmallIntG       (smallIntt *self, uint32_t retType UNUSED, intmax_t index UNUSED);
-uint32_t*           getUint32PSmallIntG      (smallIntt *self, uint32_t* retType UNUSED, intmax_t index UNUSED);
+int64_t             getIntSmallIntG          (smallIntt *self, int64_t retType UNUSED, int64_t index UNUSED);
+int64_t*            getIntPSmallIntG         (smallIntt *self, int64_t* retType UNUSED, int64_t index UNUSED);
+int32_t             getInt32SmallIntG        (smallIntt *self, int32_t retType UNUSED, int64_t index UNUSED);
+int32_t*            getInt32PSmallIntG       (smallIntt *self, int32_t* retType UNUSED, int64_t index UNUSED);
+uint64_t            getUintSmallIntG         (smallIntt *self, uint64_t retType UNUSED, int64_t index UNUSED);
+uint64_t*           getUintPSmallIntG        (smallIntt *self, uint64_t* retType UNUSED, int64_t index UNUSED);
+uint32_t            getUint32SmallIntG       (smallIntt *self, uint32_t retType UNUSED, int64_t index UNUSED);
+uint32_t*           getUint32PSmallIntG      (smallIntt *self, uint32_t* retType UNUSED, int64_t index UNUSED);
 
 smallIntt*                setBoolSmallIntG         (smallIntt* self, bool p2);
 smallIntt*                setDoubleSmallIntG       (smallIntt* self, double p2);
diff --git a/src/json/libsheepyCSmallJson.c b/src/json/libsheepyCSmallJson.c
@@ -33,7 +33,6 @@
 
 #include <ctype.h>
 #include <stdio.h>
-#include <inttypes.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <string.h>
@@ -176,44 +175,44 @@ internal smallJsont* setNFreePDictSmallJson(smallJsont *self, const char *key, s
 internal smallJsont* setNFreePArraySmallJson(smallJsont *self, const char *key, smallArrayt *array);
 internal smallJsont* setNFreePSmallJsonSmallJson(smallJsont *self, const char *key, smallJsont *value);
 internal smallJsont* setNFreePSmallStringSmallJson(smallJsont *self, const char *key, smallStringt *string);
-internal smallJsont* setAtSmallJson(smallJsont *self, intmax_t index, baset *value);
-internal smallJsont* setAtUndefinedSmallJson(smallJsont *self, intmax_t index);
-internal smallJsont* setAtBoolSmallJson(smallJsont *self, intmax_t index, bool value);
-internal smallJsont* setAtDoubleSmallJson(smallJsont *self, intmax_t index, double value);
-internal smallJsont* setAtIntSmallJson(smallJsont *self, intmax_t index, int64_t value);
-internal smallJsont* setAtSSmallJson(smallJsont *self, intmax_t index, const char *string);
-internal smallJsont* setAtCharSmallJson(smallJsont *self, intmax_t index, char c);
-internal smallJsont* setAtDictSmallJson(smallJsont *self, intmax_t index, smallDictt *dict);
-internal smallJsont* setAtArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *array);
-internal smallJsont* setAtArraycSmallJson(smallJsont *self, intmax_t index, char **array);
-internal smallJsont* setAtSmallBoolSmallJson(smallJsont *self, intmax_t index, smallBoolt *value);
-internal smallJsont* setAtSmallBytesSmallJson(smallJsont *self, intmax_t index, smallBytest *value);
-internal smallJsont* setAtSmallDoubleSmallJson(smallJsont *self, intmax_t index, smallDoublet *value);
-internal smallJsont* setAtSmallIntSmallJson(smallJsont *self, intmax_t index, smallIntt *value);
-internal smallJsont* setAtSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *value);
-internal smallJsont* setAtSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *string);
-internal smallJsont* setAtSmallContainerSmallJson(smallJsont *self, intmax_t index, smallContainert *container);
-internal smallJsont* setAtNFreeSmallJson(smallJsont *self, intmax_t index, baset *value);
-internal smallJsont* setAtNFreeUndefinedSmallJson(smallJsont *self, intmax_t index, undefinedt *undefined);
-internal smallJsont* setAtNFreeSSmallJson(smallJsont *self, intmax_t index, char *string);
-internal smallJsont* setAtNFreeDictSmallJson(smallJsont *self, intmax_t index, smallDictt *dict);
-internal smallJsont* setAtNFreeArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *array);
-internal smallJsont* setAtNFreeArraycSmallJson(smallJsont *self, intmax_t index, char **array);
-internal smallJsont* setAtNFreeSmallBoolSmallJson(smallJsont *self, intmax_t index, smallBoolt *value);
-internal smallJsont* setAtNFreeSmallBytesSmallJson(smallJsont *self, intmax_t index, smallBytest *value);
-internal smallJsont* setAtNFreeSmallDoubleSmallJson(smallJsont *self, intmax_t index, smallDoublet *value);
-internal smallJsont* setAtNFreeSmallIntSmallJson(smallJsont *self, intmax_t index, smallIntt *value);
-internal smallJsont* setAtNFreeSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *value);
-internal smallJsont* setAtNFreeSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *string);
-internal smallJsont* setAtNFreeSmallContainerSmallJson(smallJsont *self, intmax_t index, smallContainert *container);
-internal smallJsont* setPAtDictSmallJson(smallJsont *self, intmax_t index, smallDictt *dict);
-internal smallJsont* setPAtArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *array);
-internal smallJsont* setPAtSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *value);
-internal smallJsont* setPAtSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *string);
-internal smallJsont* setPAtNFreeDictSmallJson(smallJsont *self, intmax_t index, smallDictt *dict);
-internal smallJsont* setPAtNFreeArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *array);
-internal smallJsont* setPAtNFreeSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *value);
-internal smallJsont* setPAtNFreeSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *string);
+internal smallJsont* setAtSmallJson(smallJsont *self, int64_t index, baset *value);
+internal smallJsont* setAtUndefinedSmallJson(smallJsont *self, int64_t index);
+internal smallJsont* setAtBoolSmallJson(smallJsont *self, int64_t index, bool value);
+internal smallJsont* setAtDoubleSmallJson(smallJsont *self, int64_t index, double value);
+internal smallJsont* setAtIntSmallJson(smallJsont *self, int64_t index, int64_t value);
+internal smallJsont* setAtSSmallJson(smallJsont *self, int64_t index, const char *string);
+internal smallJsont* setAtCharSmallJson(smallJsont *self, int64_t index, char c);
+internal smallJsont* setAtDictSmallJson(smallJsont *self, int64_t index, smallDictt *dict);
+internal smallJsont* setAtArraySmallJson(smallJsont *self, int64_t index, smallArrayt *array);
+internal smallJsont* setAtArraycSmallJson(smallJsont *self, int64_t index, char **array);
+internal smallJsont* setAtSmallBoolSmallJson(smallJsont *self, int64_t index, smallBoolt *value);
+internal smallJsont* setAtSmallBytesSmallJson(smallJsont *self, int64_t index, smallBytest *value);
+internal smallJsont* setAtSmallDoubleSmallJson(smallJsont *self, int64_t index, smallDoublet *value);
+internal smallJsont* setAtSmallIntSmallJson(smallJsont *self, int64_t index, smallIntt *value);
+internal smallJsont* setAtSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *value);
+internal smallJsont* setAtSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *string);
+internal smallJsont* setAtSmallContainerSmallJson(smallJsont *self, int64_t index, smallContainert *container);
+internal smallJsont* setAtNFreeSmallJson(smallJsont *self, int64_t index, baset *value);
+internal smallJsont* setAtNFreeUndefinedSmallJson(smallJsont *self, int64_t index, undefinedt *undefined);
+internal smallJsont* setAtNFreeSSmallJson(smallJsont *self, int64_t index, char *string);
+internal smallJsont* setAtNFreeDictSmallJson(smallJsont *self, int64_t index, smallDictt *dict);
+internal smallJsont* setAtNFreeArraySmallJson(smallJsont *self, int64_t index, smallArrayt *array);
+internal smallJsont* setAtNFreeArraycSmallJson(smallJsont *self, int64_t index, char **array);
+internal smallJsont* setAtNFreeSmallBoolSmallJson(smallJsont *self, int64_t index, smallBoolt *value);
+internal smallJsont* setAtNFreeSmallBytesSmallJson(smallJsont *self, int64_t index, smallBytest *value);
+internal smallJsont* setAtNFreeSmallDoubleSmallJson(smallJsont *self, int64_t index, smallDoublet *value);
+internal smallJsont* setAtNFreeSmallIntSmallJson(smallJsont *self, int64_t index, smallIntt *value);
+internal smallJsont* setAtNFreeSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *value);
+internal smallJsont* setAtNFreeSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *string);
+internal smallJsont* setAtNFreeSmallContainerSmallJson(smallJsont *self, int64_t index, smallContainert *container);
+internal smallJsont* setPAtDictSmallJson(smallJsont *self, int64_t index, smallDictt *dict);
+internal smallJsont* setPAtArraySmallJson(smallJsont *self, int64_t index, smallArrayt *array);
+internal smallJsont* setPAtSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *value);
+internal smallJsont* setPAtSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *string);
+internal smallJsont* setPAtNFreeDictSmallJson(smallJsont *self, int64_t index, smallDictt *dict);
+internal smallJsont* setPAtNFreeArraySmallJson(smallJsont *self, int64_t index, smallArrayt *array);
+internal smallJsont* setPAtNFreeSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *value);
+internal smallJsont* setPAtNFreeSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *string);
 internal smallJsont* pushSmallJson(smallJsont *self, baset *value);
 internal smallJsont* pushUndefinedSmallJson(smallJsont *self);
 internal smallJsont* pushBoolSmallJson(smallJsont *self, bool value);
@@ -334,30 +333,30 @@ internal smallJsont* shiftSmallJsonSmallJson(smallJsont *self, smallJsont *array
 internal smallJsont* shiftNSmashSmallJsonSmallJson(smallJsont *self, smallJsont *array);
 internal smallJsont* addSmallJson(smallJsont *self, smallArrayt *array);
 internal smallJsont* addJsonSmallJson(smallJsont *self, smallJsont *array);
-internal smallJsont* sliceSmallJson(smallJsont *self, intmax_t start, intmax_t end);
-internal smallJsont* cropSmallJson(smallJsont *self, intmax_t start, intmax_t end);
-internal char* cropSSmallJson(smallJsont *self, intmax_t start, intmax_t end);
-internal smallStringt* cropSmallStringSmallJson(smallJsont *self, intmax_t start, intmax_t end);
-internal baset* cropElemAtSmallJson(smallJsont *self, intmax_t index);
-internal undefinedt* cropElemAtUndefinedSmallJson(smallJsont *self, intmax_t index);
-internal bool cropElemAtBoolSmallJson(smallJsont *self, intmax_t index);
-internal double cropElemAtDoubleSmallJson(smallJsont *self, intmax_t index);
-internal int64_t cropElemAtIntSmallJson(smallJsont *self, intmax_t index);
-internal int32_t cropElemAtInt32SmallJson(smallJsont *self, intmax_t index);
-internal uint64_t cropElemAtUintSmallJson(smallJsont *self, intmax_t index);
-internal uint32_t cropElemAtUint32SmallJson(smallJsont *self, intmax_t index);
-internal char* cropElemAtSSmallJson(smallJsont *self, intmax_t index);
-internal char cropElemAtCharSmallJson(smallJsont *self, intmax_t index);
-internal smallDictt* cropElemAtDictSmallJson(smallJsont *self, intmax_t index);
-internal smallArrayt* cropElemAtArraySmallJson(smallJsont *self, intmax_t index);
-internal smallBoolt* cropElemAtSmallBoolSmallJson(smallJsont *self, intmax_t index);
-internal smallBytest* cropElemAtSmallBytesSmallJson(smallJsont *self, intmax_t index);
-internal smallDoublet* cropElemAtSmallDoubleSmallJson(smallJsont *self, intmax_t index);
-internal smallIntt* cropElemAtSmallIntSmallJson(smallJsont *self, intmax_t index);
-internal smallJsont* cropElemAtSmallJsonSmallJson(smallJsont *self, intmax_t index);
-internal smallStringt* cropElemAtSmallStringSmallJson(smallJsont *self, intmax_t index);
-internal void* cropElemAtVoidSmallJson(smallJsont *self, intmax_t index);
-internal smallContainert* cropElemAtSmallContainerSmallJson(smallJsont *self, intmax_t index);
+internal smallJsont* sliceSmallJson(smallJsont *self, int64_t start, int64_t end);
+internal smallJsont* cropSmallJson(smallJsont *self, int64_t start, int64_t end);
+internal char* cropSSmallJson(smallJsont *self, int64_t start, int64_t end);
+internal smallStringt* cropSmallStringSmallJson(smallJsont *self, int64_t start, int64_t end);
+internal baset* cropElemAtSmallJson(smallJsont *self, int64_t index);
+internal undefinedt* cropElemAtUndefinedSmallJson(smallJsont *self, int64_t index);
+internal bool cropElemAtBoolSmallJson(smallJsont *self, int64_t index);
+internal double cropElemAtDoubleSmallJson(smallJsont *self, int64_t index);
+internal int64_t cropElemAtIntSmallJson(smallJsont *self, int64_t index);
+internal int32_t cropElemAtInt32SmallJson(smallJsont *self, int64_t index);
+internal uint64_t cropElemAtUintSmallJson(smallJsont *self, int64_t index);
+internal uint32_t cropElemAtUint32SmallJson(smallJsont *self, int64_t index);
+internal char* cropElemAtSSmallJson(smallJsont *self, int64_t index);
+internal char cropElemAtCharSmallJson(smallJsont *self, int64_t index);
+internal smallDictt* cropElemAtDictSmallJson(smallJsont *self, int64_t index);
+internal smallArrayt* cropElemAtArraySmallJson(smallJsont *self, int64_t index);
+internal smallBoolt* cropElemAtSmallBoolSmallJson(smallJsont *self, int64_t index);
+internal smallBytest* cropElemAtSmallBytesSmallJson(smallJsont *self, int64_t index);
+internal smallDoublet* cropElemAtSmallDoubleSmallJson(smallJsont *self, int64_t index);
+internal smallIntt* cropElemAtSmallIntSmallJson(smallJsont *self, int64_t index);
+internal smallJsont* cropElemAtSmallJsonSmallJson(smallJsont *self, int64_t index);
+internal smallStringt* cropElemAtSmallStringSmallJson(smallJsont *self, int64_t index);
+internal void* cropElemAtVoidSmallJson(smallJsont *self, int64_t index);
+internal smallContainert* cropElemAtSmallContainerSmallJson(smallJsont *self, int64_t index);
 internal baset* cropElemKeySmallJson(smallJsont *self, char* key);
 internal undefinedt* cropElemKeyUndefinedSmallJson(smallJsont *self, char* key);
 internal bool cropElemKeyBoolSmallJson(smallJsont *self, char* key);
@@ -377,45 +376,45 @@ internal smallJsont* cropElemKeySmallJsonSmallJson(smallJsont *self, char* key);
 internal smallStringt* cropElemKeySmallStringSmallJson(smallJsont *self, char* key);
 internal void* cropElemKeyVoidSmallJson(smallJsont *self, char* key);
 internal smallContainert* cropElemKeySmallContainerSmallJson(smallJsont *self, char* key);
-internal smallJsont* copySmallJson(smallJsont *self, intmax_t start, intmax_t end);
-internal smallJsont* insertSmallJson(smallJsont *self, intmax_t index, smallArrayt *toInsert);
-internal smallJsont* insertNSmashSmallJson(smallJsont *self, intmax_t index, smallArrayt *toInsert);
-internal smallJsont* insertSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *toInsert);
-internal smallJsont* insertNSmashSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *toInsert);
-internal smallJsont* insertStringSmallJson(smallJsont *self, intmax_t index, smallStringt *toInsert);
-internal smallJsont* insertSSmallJson(smallJsont *self, intmax_t index, const char *toInsert);
-internal smallJsont* insertNFreeStringSmallJson(smallJsont *self, intmax_t index, smallStringt *toInsert);
-internal smallJsont* insertSNFreeSmallJson(smallJsont *self, intmax_t index, char *toInsert);
-internal smallJsont* injectSmallJson(smallJsont *self, intmax_t index, baset *toInject);
-internal smallJsont* injectUndefinedSmallJson(smallJsont *self, intmax_t index);
-internal smallJsont* injectBoolSmallJson(smallJsont *self, intmax_t index, bool toInject);
-internal smallJsont* injectDoubleSmallJson(smallJsont *self, intmax_t index, double toInject);
-internal smallJsont* injectIntSmallJson(smallJsont *self, intmax_t index, int64_t toInject);
-internal smallJsont* injectSSmallJson(smallJsont *self, intmax_t index, const char *toInject);
-internal smallJsont* injectCharSmallJson(smallJsont *self, intmax_t index, char c);
-internal smallJsont* injectDictSmallJson(smallJsont *self, intmax_t index, smallDictt *toInject);
-internal smallJsont* injectArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *toInject);
-internal smallJsont* injectArraycSmallJson(smallJsont *self, intmax_t index, char **toInject);
-internal smallJsont* injectSmallBoolSmallJson(smallJsont *self, intmax_t index, smallBoolt *toInject);
-internal smallJsont* injectSmallBytesSmallJson(smallJsont *self, intmax_t index, smallBytest *toInject);
-internal smallJsont* injectSmallDoubleSmallJson(smallJsont *self, intmax_t index, smallDoublet *toInject);
-internal smallJsont* injectSmallIntSmallJson(smallJsont *self, intmax_t index, smallIntt *toInject);
-internal smallJsont* injectSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *toInject);
-internal smallJsont* injectSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *toInject);
-internal smallJsont* injectSmallContainerSmallJson(smallJsont *self, intmax_t index, smallContainert *toInject);
-internal smallJsont* injectNFreeSmallJson(smallJsont *self, intmax_t index, baset *toInject);
-internal smallJsont* injectNFreeUndefinedSmallJson(smallJsont *self, intmax_t index, undefinedt *undefined);
-internal smallJsont* injectNFreeSSmallJson(smallJsont *self, intmax_t index, char *toInject);
-internal smallJsont* injectNFreeDictSmallJson(smallJsont *self, intmax_t index, smallDictt *toInject);
-internal smallJsont* injectNFreeArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *toInject);
-internal smallJsont* injectNFreeArraycSmallJson(smallJsont *self, intmax_t index, char **toInject);
-internal smallJsont* injectNFreeSmallBoolSmallJson(smallJsont *self, intmax_t index, smallBoolt *toInject);
-internal smallJsont* injectNFreeSmallBytesSmallJson(smallJsont *self, intmax_t index, smallBytest *toInject);
-internal smallJsont* injectNFreeSmallDoubleSmallJson(smallJsont *self, intmax_t index, smallDoublet *toInject);
-internal smallJsont* injectNFreeSmallIntSmallJson(smallJsont *self, intmax_t index, smallIntt *toInject);
-internal smallJsont* injectNFreeSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *toInject);
-internal smallJsont* injectNFreeSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *toInject);
-internal smallJsont* injectNFreeSmallContainerSmallJson(smallJsont *self, intmax_t index, smallContainert *toInject);
+internal smallJsont* copySmallJson(smallJsont *self, int64_t start, int64_t end);
+internal smallJsont* insertSmallJson(smallJsont *self, int64_t index, smallArrayt *toInsert);
+internal smallJsont* insertNSmashSmallJson(smallJsont *self, int64_t index, smallArrayt *toInsert);
+internal smallJsont* insertSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *toInsert);
+internal smallJsont* insertNSmashSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *toInsert);
+internal smallJsont* insertStringSmallJson(smallJsont *self, int64_t index, smallStringt *toInsert);
+internal smallJsont* insertSSmallJson(smallJsont *self, int64_t index, const char *toInsert);
+internal smallJsont* insertNFreeStringSmallJson(smallJsont *self, int64_t index, smallStringt *toInsert);
+internal smallJsont* insertSNFreeSmallJson(smallJsont *self, int64_t index, char *toInsert);
+internal smallJsont* injectSmallJson(smallJsont *self, int64_t index, baset *toInject);
+internal smallJsont* injectUndefinedSmallJson(smallJsont *self, int64_t index);
+internal smallJsont* injectBoolSmallJson(smallJsont *self, int64_t index, bool toInject);
+internal smallJsont* injectDoubleSmallJson(smallJsont *self, int64_t index, double toInject);
+internal smallJsont* injectIntSmallJson(smallJsont *self, int64_t index, int64_t toInject);
+internal smallJsont* injectSSmallJson(smallJsont *self, int64_t index, const char *toInject);
+internal smallJsont* injectCharSmallJson(smallJsont *self, int64_t index, char c);
+internal smallJsont* injectDictSmallJson(smallJsont *self, int64_t index, smallDictt *toInject);
+internal smallJsont* injectArraySmallJson(smallJsont *self, int64_t index, smallArrayt *toInject);
+internal smallJsont* injectArraycSmallJson(smallJsont *self, int64_t index, char **toInject);
+internal smallJsont* injectSmallBoolSmallJson(smallJsont *self, int64_t index, smallBoolt *toInject);
+internal smallJsont* injectSmallBytesSmallJson(smallJsont *self, int64_t index, smallBytest *toInject);
+internal smallJsont* injectSmallDoubleSmallJson(smallJsont *self, int64_t index, smallDoublet *toInject);
+internal smallJsont* injectSmallIntSmallJson(smallJsont *self, int64_t index, smallIntt *toInject);
+internal smallJsont* injectSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *toInject);
+internal smallJsont* injectSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *toInject);
+internal smallJsont* injectSmallContainerSmallJson(smallJsont *self, int64_t index, smallContainert *toInject);
+internal smallJsont* injectNFreeSmallJson(smallJsont *self, int64_t index, baset *toInject);
+internal smallJsont* injectNFreeUndefinedSmallJson(smallJsont *self, int64_t index, undefinedt *undefined);
+internal smallJsont* injectNFreeSSmallJson(smallJsont *self, int64_t index, char *toInject);
+internal smallJsont* injectNFreeDictSmallJson(smallJsont *self, int64_t index, smallDictt *toInject);
+internal smallJsont* injectNFreeArraySmallJson(smallJsont *self, int64_t index, smallArrayt *toInject);
+internal smallJsont* injectNFreeArraycSmallJson(smallJsont *self, int64_t index, char **toInject);
+internal smallJsont* injectNFreeSmallBoolSmallJson(smallJsont *self, int64_t index, smallBoolt *toInject);
+internal smallJsont* injectNFreeSmallBytesSmallJson(smallJsont *self, int64_t index, smallBytest *toInject);
+internal smallJsont* injectNFreeSmallDoubleSmallJson(smallJsont *self, int64_t index, smallDoublet *toInject);
+internal smallJsont* injectNFreeSmallIntSmallJson(smallJsont *self, int64_t index, smallIntt *toInject);
+internal smallJsont* injectNFreeSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *toInject);
+internal smallJsont* injectNFreeSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *toInject);
+internal smallJsont* injectNFreeSmallContainerSmallJson(smallJsont *self, int64_t index, smallContainert *toInject);
 internal smallJsont* uniqSmallJson(smallJsont *self);
 internal int sortSCmp(const void * a, const void * b);
 internal smallJsont* sortSmallJson(smallJsont *self);
@@ -598,10 +597,10 @@ internal bool icEqualSmallJsonSmallJson(smallJsont *self, smallJsont *string);
 internal bool icEqualSmallJsonSmallString(smallJsont *self, smallStringt *string);
 internal bool icEqualSSmallJson(smallJsont *self, const char *string);
 internal bool icEqualCharSmallJson(smallJsont *self, char c);
-internal bool equalISSmallJson(smallJsont *self, const char *string, intmax_t index);
-internal bool equalICharSmallJson(smallJsont *self, char c, intmax_t index);
-internal bool equalIJsonSmallJson(smallJsont *self, smallJsont *string, intmax_t index);
-internal bool equalISmallStringSmallJson(smallJsont *self, smallStringt *string, intmax_t index);
+internal bool equalISSmallJson(smallJsont *self, const char *string, int64_t index);
+internal bool equalICharSmallJson(smallJsont *self, char c, int64_t index);
+internal bool equalIJsonSmallJson(smallJsont *self, smallJsont *string, int64_t index);
+internal bool equalISmallStringSmallJson(smallJsont *self, smallStringt *string, int64_t index);
 internal bool startsWithSSmallJson(smallJsont *self, const char *string);
 internal bool startsWithCharSmallJson(smallJsont *self, char c);
 internal bool startsWithSmallStringSmallJson(smallJsont *self, smallStringt *string);
@@ -628,9 +627,9 @@ internal ssize_t icCountSmallStringSmallJson(smallJsont *self, smallStringt *str
 internal ssize_t icCountJsonSmallJson(smallJsont *self, smallJsont *string);
 internal bool isNumberSmallJson(smallJsont *self);
 internal bool isIntSmallJson(smallJsont *self);
-internal intmax_t parseIntSmallJson(smallJsont *self);
+internal int64_t parseIntSmallJson(smallJsont *self);
 internal double parseDoubleSmallJson(smallJsont *self);
-internal smallJsont* intToSmallJson(smallJsont *self, intmax_t n);
+internal smallJsont* intToSmallJson(smallJsont *self, int64_t n);
 internal smallJsont* doubleToSmallJson(smallJsont *self, double n);
 internal size_t lenSmallJson(smallJsont *self);
 internal smallJsont* upperSmallJson(smallJsont *self);
@@ -725,14 +724,14 @@ smallJsont* zipCArrayJsonSmallJson(smallJsont *self, const char** array1, smallJ
 internal baset* iterStartSmallJson(smallJsont *self);
 internal const char* iterStartKeySmallJson(smallJsont *self);
 internal baset* iterStartLastSmallJson(smallJsont *self);
-internal baset* iterStartFromSmallJson(smallJsont *self, intmax_t index);
-internal baset* iterStartFromStepSmallJson(smallJsont *self, intmax_t index, intmax_t step);
+internal baset* iterStartFromSmallJson(smallJsont *self, int64_t index);
+internal baset* iterStartFromStepSmallJson(smallJsont *self, int64_t index, int64_t step);
 internal baset* iterNextSmallJson(smallJsont *self);
 internal const char* iterNextKeySmallJson(smallJsont *self);
 internal baset* iterElementSmallJson(smallJsont *self);
 internal const char* iterKeySmallJson(smallJsont *self);
 internal ssize_t iterIndexSmallJson(smallJsont *self);
-internal intmax_t iterStepSmallJson(smallJsont *self);
+internal int64_t iterStepSmallJson(smallJsont *self);
 internal baset* getSmallJson(smallJsont *self, const char *key);
 internal undefinedt* getUndefinedSmallJson(smallJsont *self, const char *key);
 internal bool getBoolSmallJson(smallJsont *self, const char *key);
@@ -777,58 +776,58 @@ internal smallJsont* getNDupSmallJsonSmallJson(smallJsont *self, const char *key
 internal smallStringt* getNDupSmallStringSmallJson(smallJsont *self, const char *key);
 internal void* getNDupVoidSmallJson(smallJsont *self, const char *key);
 internal smallContainert* getNDupSmallContainerSmallJson(smallJsont *self, const char *key);
-baset* getAtSmallJson(smallJsont *self, intmax_t index);
-internal undefinedt* getAtUndefinedSmallJson(smallJsont *self, intmax_t index);
-internal bool getAtBoolSmallJson(smallJsont *self, intmax_t index);
-internal bool* getAtBoolPSmallJson(smallJsont *self, intmax_t index);
-internal double getAtDoubleSmallJson(smallJsont *self, intmax_t index);
-internal double* getAtDoublePSmallJson(smallJsont *self, intmax_t index);
-internal int64_t getAtIntSmallJson(smallJsont *self, intmax_t index);
-internal int64_t* getAtIntPSmallJson(smallJsont *self, intmax_t index);
-internal int32_t getAtInt32SmallJson(smallJsont *self, intmax_t index);
-internal int32_t* getAtInt32PSmallJson(smallJsont *self, intmax_t index);
-internal uint64_t getAtUintSmallJson(smallJsont *self, intmax_t index);
-internal uint64_t* getAtUintPSmallJson(smallJsont *self, intmax_t index);
-internal uint32_t getAtUint32SmallJson(smallJsont *self, intmax_t index);
-internal uint32_t* getAtUint32PSmallJson(smallJsont *self, intmax_t index);
-internal char* getAtSSmallJson(smallJsont *self, intmax_t index);
-internal smallDictt* getAtDictSmallJson(smallJsont *self, intmax_t index);
-internal smallArrayt* getAtArraySmallJson(smallJsont *self, intmax_t index);
-internal smallBoolt* getAtSmallBoolSmallJson(smallJsont *self, intmax_t index);
-internal smallBytest* getAtSmallBytesSmallJson(smallJsont *self, intmax_t index);
-internal smallDoublet* getAtSmallDoubleSmallJson(smallJsont *self, intmax_t index);
-internal smallIntt* getAtSmallIntSmallJson(smallJsont *self, intmax_t index);
-internal smallJsont* getAtSmallJsonSmallJson(smallJsont *self, intmax_t index);
-internal smallStringt* getAtSmallStringSmallJson(smallJsont *self, intmax_t index);
-internal void* getAtVoidSmallJson(smallJsont *self, intmax_t index);
-internal smallContainert* getAtSmallContainerSmallJson(smallJsont *self, intmax_t index);
-baset* getAtNDupSmallJson(smallJsont *self, intmax_t index);
-internal undefinedt* getAtNDupUndefinedSmallJson(smallJsont *self, intmax_t index);
-internal bool getAtNDupBoolSmallJson(smallJsont *self, intmax_t index);
-internal double getAtNDupDoubleSmallJson(smallJsont *self, intmax_t index);
-internal int64_t getAtNDupIntSmallJson(smallJsont *self, intmax_t index);
-internal int32_t getAtNDupInt32SmallJson(smallJsont *self, intmax_t index);
-internal uint64_t getAtNDupUintSmallJson(smallJsont *self, intmax_t index);
-internal uint32_t getAtNDupUint32SmallJson(smallJsont *self, intmax_t index);
-internal char* getAtNDupSSmallJson(smallJsont *self, intmax_t index);
-internal smallDictt* getAtNDupDictSmallJson(smallJsont *self, intmax_t index);
-internal smallArrayt* getAtNDupArraySmallJson(smallJsont *self, intmax_t index);
-internal smallBoolt* getAtNDupSmallBoolSmallJson(smallJsont *self, intmax_t index);
-internal smallBytest* getAtNDupSmallBytesSmallJson(smallJsont *self, intmax_t index);
-internal smallDoublet* getAtNDupSmallDoubleSmallJson(smallJsont *self, intmax_t index);
-internal smallIntt* getAtNDupSmallIntSmallJson(smallJsont *self, intmax_t index);
-internal smallJsont* getAtNDupSmallJsonSmallJson(smallJsont *self, intmax_t index);
-internal smallStringt* getAtNDupSmallStringSmallJson(smallJsont *self, intmax_t index);
-internal void* getAtNDupVoidSmallJson(smallJsont *self, intmax_t index);
-internal smallContainert* getAtNDupSmallContainerSmallJson(smallJsont *self, intmax_t index);
+baset* getAtSmallJson(smallJsont *self, int64_t index);
+internal undefinedt* getAtUndefinedSmallJson(smallJsont *self, int64_t index);
+internal bool getAtBoolSmallJson(smallJsont *self, int64_t index);
+internal bool* getAtBoolPSmallJson(smallJsont *self, int64_t index);
+internal double getAtDoubleSmallJson(smallJsont *self, int64_t index);
+internal double* getAtDoublePSmallJson(smallJsont *self, int64_t index);
+internal int64_t getAtIntSmallJson(smallJsont *self, int64_t index);
+internal int64_t* getAtIntPSmallJson(smallJsont *self, int64_t index);
+internal int32_t getAtInt32SmallJson(smallJsont *self, int64_t index);
+internal int32_t* getAtInt32PSmallJson(smallJsont *self, int64_t index);
+internal uint64_t getAtUintSmallJson(smallJsont *self, int64_t index);
+internal uint64_t* getAtUintPSmallJson(smallJsont *self, int64_t index);
+internal uint32_t getAtUint32SmallJson(smallJsont *self, int64_t index);
+internal uint32_t* getAtUint32PSmallJson(smallJsont *self, int64_t index);
+internal char* getAtSSmallJson(smallJsont *self, int64_t index);
+internal smallDictt* getAtDictSmallJson(smallJsont *self, int64_t index);
+internal smallArrayt* getAtArraySmallJson(smallJsont *self, int64_t index);
+internal smallBoolt* getAtSmallBoolSmallJson(smallJsont *self, int64_t index);
+internal smallBytest* getAtSmallBytesSmallJson(smallJsont *self, int64_t index);
+internal smallDoublet* getAtSmallDoubleSmallJson(smallJsont *self, int64_t index);
+internal smallIntt* getAtSmallIntSmallJson(smallJsont *self, int64_t index);
+internal smallJsont* getAtSmallJsonSmallJson(smallJsont *self, int64_t index);
+internal smallStringt* getAtSmallStringSmallJson(smallJsont *self, int64_t index);
+internal void* getAtVoidSmallJson(smallJsont *self, int64_t index);
+internal smallContainert* getAtSmallContainerSmallJson(smallJsont *self, int64_t index);
+baset* getAtNDupSmallJson(smallJsont *self, int64_t index);
+internal undefinedt* getAtNDupUndefinedSmallJson(smallJsont *self, int64_t index);
+internal bool getAtNDupBoolSmallJson(smallJsont *self, int64_t index);
+internal double getAtNDupDoubleSmallJson(smallJsont *self, int64_t index);
+internal int64_t getAtNDupIntSmallJson(smallJsont *self, int64_t index);
+internal int32_t getAtNDupInt32SmallJson(smallJsont *self, int64_t index);
+internal uint64_t getAtNDupUintSmallJson(smallJsont *self, int64_t index);
+internal uint32_t getAtNDupUint32SmallJson(smallJsont *self, int64_t index);
+internal char* getAtNDupSSmallJson(smallJsont *self, int64_t index);
+internal smallDictt* getAtNDupDictSmallJson(smallJsont *self, int64_t index);
+internal smallArrayt* getAtNDupArraySmallJson(smallJsont *self, int64_t index);
+internal smallBoolt* getAtNDupSmallBoolSmallJson(smallJsont *self, int64_t index);
+internal smallBytest* getAtNDupSmallBytesSmallJson(smallJsont *self, int64_t index);
+internal smallDoublet* getAtNDupSmallDoubleSmallJson(smallJsont *self, int64_t index);
+internal smallIntt* getAtNDupSmallIntSmallJson(smallJsont *self, int64_t index);
+internal smallJsont* getAtNDupSmallJsonSmallJson(smallJsont *self, int64_t index);
+internal smallStringt* getAtNDupSmallStringSmallJson(smallJsont *self, int64_t index);
+internal void* getAtNDupVoidSmallJson(smallJsont *self, int64_t index);
+internal smallContainert* getAtNDupSmallContainerSmallJson(smallJsont *self, int64_t index);
 internal double getNumSmallJson(smallJsont *self, const char *key);
-internal double getNumAtSmallJson(smallJsont *self, intmax_t index);
+internal double getNumAtSmallJson(smallJsont *self, int64_t index);
 internal smallJsont* delElemSmallJson(smallJsont *self, const char *key);
-internal smallJsont* delSmallJson(smallJsont *self, intmax_t start, intmax_t end);
-internal smallJsont* delElemIndexSmallJson(smallJsont *self, intmax_t index);
+internal smallJsont* delSmallJson(smallJsont *self, int64_t start, int64_t end);
+internal smallJsont* delElemIndexSmallJson(smallJsont *self, int64_t index);
 internal smallJsont* removeElemSmallJson(smallJsont *self, const char *key);
-internal smallJsont* removeSmallJson(smallJsont *self, intmax_t start, intmax_t end);
-internal smallJsont* removeElemIndexSmallJson(smallJsont *self, intmax_t index);
+internal smallJsont* removeSmallJson(smallJsont *self, int64_t start, int64_t end);
+internal smallJsont* removeElemIndexSmallJson(smallJsont *self, int64_t index);
 internal char** sDictStringifyForeach(sDictElemt *e, char *indentS2, int indent, int level);
 internal char** sDictStringify(sDictt *dict, int indent, int level);
 internal char** sArrayStringify(sArrayt *array, int indent, int level);
@@ -885,26 +884,26 @@ internal bool appendTextSmallStringSmallJson(smallJsont *self, smallStringt *fil
 internal bool appendTextJsonSmallJson(smallJsont *self, smallJsont *filePath);
 internal const char* typeStringSmallJson(smallJsont *self, const char *key);
 internal smallStringt* typeSmallStringSmallJson(smallJsont *self, const char *key);
-internal const char* typeAtStringSmallJson(smallJsont *self, intmax_t index);
-internal smallStringt* typeAtSmallStringSmallJson(smallJsont *self, intmax_t index);
+internal const char* typeAtStringSmallJson(smallJsont *self, int64_t index);
+internal smallStringt* typeAtSmallStringSmallJson(smallJsont *self, int64_t index);
 internal const char* typeStringKCharSmallJson(smallJsont *self, char key);
 internal smallStringt* typeSmallStringKCharSmallJson(smallJsont *self, char key);
 internal char typeSmallJson(smallJsont *self, const char *key);
 internal char typeKCharSmallJson(smallJsont *self, char key);
-internal char typeAtSmallJson(smallJsont *self, intmax_t index);
+internal char typeAtSmallJson(smallJsont *self, int64_t index);
 internal smallJsont* typeStringsSmallJson(smallJsont *self);
 internal smallBytest* typesSmallJson(smallJsont *self);
-internal bool isETypeAtSmallJson(smallJsont *self, intmax_t index, const char *type);
-internal bool isEUndefinedAtSmallJson(smallJsont *self, intmax_t index);
-internal bool isEBoolAtSmallJson(smallJsont *self, intmax_t index);
-internal bool isEContainerAtSmallJson(smallJsont *self, intmax_t index);
-internal bool isEDictAtSmallJson(smallJsont *self, intmax_t index);
-internal bool isEDoubleAtSmallJson(smallJsont *self, intmax_t index);
-internal bool isEIntAtSmallJson(smallJsont *self, intmax_t index);
-internal bool isEStringAtSmallJson(smallJsont *self, intmax_t index);
-internal bool isEFaststringAtSmallJson(smallJsont *self, intmax_t index);
-internal bool isEArrayAtSmallJson(smallJsont *self, intmax_t index);
-internal bool isEBytesAtSmallJson(smallJsont *self, intmax_t index);
+internal bool isETypeAtSmallJson(smallJsont *self, int64_t index, const char *type);
+internal bool isEUndefinedAtSmallJson(smallJsont *self, int64_t index);
+internal bool isEBoolAtSmallJson(smallJsont *self, int64_t index);
+internal bool isEContainerAtSmallJson(smallJsont *self, int64_t index);
+internal bool isEDictAtSmallJson(smallJsont *self, int64_t index);
+internal bool isEDoubleAtSmallJson(smallJsont *self, int64_t index);
+internal bool isEIntAtSmallJson(smallJsont *self, int64_t index);
+internal bool isEStringAtSmallJson(smallJsont *self, int64_t index);
+internal bool isEFaststringAtSmallJson(smallJsont *self, int64_t index);
+internal bool isEArrayAtSmallJson(smallJsont *self, int64_t index);
+internal bool isEBytesAtSmallJson(smallJsont *self, int64_t index);
 internal bool isETypeSmallJson(smallJsont *self, const char *key, const char *type);
 internal bool isEUndefinedSmallJson(smallJsont *self, const char *key);
 internal bool isEBoolSmallJson(smallJsont *self, const char *key);
@@ -1071,46 +1070,46 @@ smallJsont* setNFreePDictSmallJsonG    (smallJsont *self, const char *key, small
 smallJsont* setNFreePArraySmallJsonG   (smallJsont *self, const char *key, smallArrayt *array);
 smallJsont* setNFreePSmallJsonSmallJsonG(smallJsont *self, const char *key, smallJsont *value);
 smallJsont* setNFreePSmallStringSmallJsonG(smallJsont *self, const char *key, smallStringt *string);
-smallJsont* setAtSmallJsonG         (smallJsont *self, intmax_t index, baset *value);
-smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtBoolSmallJsonG     (smallJsont *self, intmax_t index, bool value);
-smallJsont* setAtDoubleSmallJsonG   (smallJsont *self, intmax_t index, double value);
-smallJsont* setAtIntSmallJsonG      (smallJsont *self, intmax_t index, int64_t value);
-smallJsont* setAtSSmallJsonG        (smallJsont *self, intmax_t index, const char *string);
-smallJsont* setAtCharSmallJsonG(smallJsont *self, intmax_t index, char c);
-smallJsont* setAtDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setAtArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setAtArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* setAtCArraycSmallJsonG  (smallJsont *self, intmax_t index, const char **array);
-smallJsont* setAtVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* setAtSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* setAtSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* setAtSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* setAtSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setAtSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* setAtSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
-smallJsont* setAtNFreeSmallJsonG    (smallJsont *self, intmax_t index, baset *value);
-smallJsont* setAtNFreeUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtNFreeSSmallJsonG        (smallJsont *self, intmax_t index, char *string);
-smallJsont* setAtNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setAtNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setAtNFreeArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* setAtNFreeSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* setAtNFreeSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* setAtNFreeSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* setAtNFreeSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* setAtNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setAtNFreeSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* setAtNFreeSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
-smallJsont* setPAtDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setPAtArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setPAtSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setPAtSmallStringSmallJsonG     (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* setPAtNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setPAtNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setPAtNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setPAtNFreeSmallStringSmallJsonG     (smallJsont *self, intmax_t index, smallStringt *string);
+smallJsont* setAtSmallJsonG         (smallJsont *self, int64_t index, baset *value);
+smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* setAtBoolSmallJsonG     (smallJsont *self, int64_t index, bool value);
+smallJsont* setAtDoubleSmallJsonG   (smallJsont *self, int64_t index, double value);
+smallJsont* setAtIntSmallJsonG      (smallJsont *self, int64_t index, int64_t value);
+smallJsont* setAtSSmallJsonG        (smallJsont *self, int64_t index, const char *string);
+smallJsont* setAtCharSmallJsonG(smallJsont *self, int64_t index, char c);
+smallJsont* setAtDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setAtArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setAtArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* setAtCArraycSmallJsonG  (smallJsont *self, int64_t index, const char **array);
+smallJsont* setAtVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* setAtSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* setAtSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* setAtSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* setAtSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* setAtSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setAtSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* setAtSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
+smallJsont* setAtNFreeSmallJsonG    (smallJsont *self, int64_t index, baset *value);
+smallJsont* setAtNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* setAtNFreeSSmallJsonG        (smallJsont *self, int64_t index, char *string);
+smallJsont* setAtNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setAtNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setAtNFreeArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* setAtNFreeSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* setAtNFreeSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* setAtNFreeSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* setAtNFreeSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* setAtNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setAtNFreeSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* setAtNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
+smallJsont* setPAtDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setPAtArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setPAtSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setPAtSmallStringSmallJsonG     (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* setPAtNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setPAtNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setPAtNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setPAtNFreeSmallStringSmallJsonG     (smallJsont *self, int64_t index, smallStringt *string);
 baset*           getSmallJsonG              (smallJsont *self, baset* retType UNUSED, const char *key);
 undefinedt*      getUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, const char *key);
 bool             getBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, const char *key);
@@ -1155,56 +1154,56 @@ smallJsont*       getNDupSmallJsonSmallJsonG    (smallJsont *self, smallJsont* r
 smallStringt*    getNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, const char *key);
 void*            getNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, const char *key);
 smallContainert* getNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, const char *key);
-baset*           getAtSmallJsonG              (smallJsont *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, intmax_t index);
-bool*            getAtBoolPSmallJsonG         (smallJsont *self, bool* retType UNUSED, intmax_t index);
-double           getAtDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, intmax_t index);
-double*          getAtDoublePSmallJsonG       (smallJsont *self, double* retType UNUSED, intmax_t index);
-int64_t          getAtIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, intmax_t index);
-int64_t*         getAtIntPSmallJsonG          (smallJsont *self, int64_t* retType UNUSED, intmax_t index);
-int32_t          getAtInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, intmax_t index);
-int32_t*         getAtInt32PSmallJsonG        (smallJsont *self, int32_t* retType UNUSED, intmax_t index);
-uint64_t         getAtUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, intmax_t index);
-uint64_t*        getAtUintPSmallJsonG         (smallJsont *self, uint64_t* retType UNUSED, intmax_t index);
-uint32_t         getAtUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, intmax_t index);
-uint32_t*        getAtUint32PSmallJsonG       (smallJsont *self, uint32_t* retType UNUSED, intmax_t index);
-char*            getAtSSmallJsonG             (smallJsont *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*       getAtSmallJsonSmallJsonG    (smallJsont *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, intmax_t index);
-baset*           getAtNDupSmallJsonG              (smallJsont *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtNDupUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtNDupBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, intmax_t index);
-double           getAtNDupDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, intmax_t index);
-int64_t          getAtNDupIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, intmax_t index);
-int32_t          getAtNDupInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, intmax_t index);
-uint64_t         getAtNDupUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, intmax_t index);
-uint32_t         getAtNDupUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, intmax_t index);
-char*            getAtNDupSSmallJsonG             (smallJsont *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtNDupDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtNDupArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtNDupSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtNDupSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtNDupSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtNDupSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*       getAtNDupSmallJsonSmallJsonG    (smallJsont *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, intmax_t index);
+baset*           getAtSmallJsonG              (smallJsont *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, int64_t index);
+bool*            getAtBoolPSmallJsonG         (smallJsont *self, bool* retType UNUSED, int64_t index);
+double           getAtDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, int64_t index);
+double*          getAtDoublePSmallJsonG       (smallJsont *self, double* retType UNUSED, int64_t index);
+int64_t          getAtIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, int64_t index);
+int64_t*         getAtIntPSmallJsonG          (smallJsont *self, int64_t* retType UNUSED, int64_t index);
+int32_t          getAtInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, int64_t index);
+int32_t*         getAtInt32PSmallJsonG        (smallJsont *self, int32_t* retType UNUSED, int64_t index);
+uint64_t         getAtUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, int64_t index);
+uint64_t*        getAtUintPSmallJsonG         (smallJsont *self, uint64_t* retType UNUSED, int64_t index);
+uint32_t         getAtUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, int64_t index);
+uint32_t*        getAtUint32PSmallJsonG       (smallJsont *self, uint32_t* retType UNUSED, int64_t index);
+char*            getAtSSmallJsonG             (smallJsont *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*       getAtSmallJsonSmallJsonG    (smallJsont *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index);
+baset*           getAtNDupSmallJsonG              (smallJsont *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtNDupUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtNDupBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, int64_t index);
+double           getAtNDupDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, int64_t index);
+int64_t          getAtNDupIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, int64_t index);
+int32_t          getAtNDupInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, int64_t index);
+uint64_t         getAtNDupUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, int64_t index);
+uint32_t         getAtNDupUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, int64_t index);
+char*            getAtNDupSSmallJsonG             (smallJsont *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtNDupDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtNDupArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtNDupSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtNDupSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtNDupSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtNDupSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*       getAtNDupSmallJsonSmallJsonG    (smallJsont *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index);
 double getNumSmallJsonG(smallJsont *self, const char *key);
-double getNumAtSmallJsonG(smallJsont *self, intmax_t index);
+double getNumAtSmallJsonG(smallJsont *self, int64_t index);
 smallJsont* delKeySmallJsonG(smallJsont *self, const char *key, int unused UNUSED);
-smallJsont* delSmallJsonG(smallJsont *self, intmax_t start, intmax_t end);
+smallJsont* delSmallJsonG(smallJsont *self, int64_t start, int64_t end);
 smallJsont* delElemSmallJsonG(smallJsont *self, const char *key);
-smallJsont* delElemIndexSmallJsonG(smallJsont *self, intmax_t index);
+smallJsont* delElemIndexSmallJsonG(smallJsont *self, int64_t index);
 smallJsont* prependSmallJsonG         (smallJsont *self, baset *value);
 smallJsont* prependUndefinedSmallJsonG(smallJsont *self, void *value UNUSED);
 smallJsont* prependBoolSmallJsonG     (smallJsont *self, bool value);
@@ -1272,30 +1271,30 @@ smallJsont* shiftSmallJsonSmallJsonG(smallJsont *self, smallJsont *array);
 smallJsont* shiftNSmashSmallJsonSmallJsonG(smallJsont *self, smallJsont *array);
 smallJsont* addSmallJsonG  (smallJsont *self, smallArrayt *array);
 smallJsont* addJsonSmallJsonG  (smallJsont *self, smallJsont *array);
-smallJsont* sliceSmallJsonG(smallJsont *self, intmax_t start, intmax_t end);
-smallJsont* cropSmallJsonG                          (smallJsont *self, intmax_t start, intmax_t end);
-char* cropSSmallJsonG                               (smallJsont *self, intmax_t start, intmax_t end);
-smallStringt* cropSmallStringSmallJsonG             (smallJsont *self, intmax_t start, intmax_t end);
-baset* cropElemAtSmallJsonG                         (smallJsont *self, intmax_t index);
-undefinedt* cropElemAtUndefinedSmallJsonG           (smallJsont *self, intmax_t index);
-bool cropElemAtBoolSmallJsonG                       (smallJsont *self, intmax_t index);
-double cropElemAtDoubleSmallJsonG                   (smallJsont *self, intmax_t index);
-int64_t cropElemAtIntSmallJsonG                     (smallJsont *self, intmax_t index);
-int32_t cropElemAtInt32SmallJsonG                   (smallJsont *self, intmax_t index);
-uint64_t cropElemAtUintSmallJsonG                   (smallJsont *self, intmax_t index);
-uint32_t cropElemAtUint32SmallJsonG                 (smallJsont *self, intmax_t index);
-char* cropElemAtSSmallJsonG                         (smallJsont *self, intmax_t index);
-char cropElemAtCharSmallJsonG                       (smallJsont *self, intmax_t index);
-smallDictt* cropElemAtDictSmallJsonG                (smallJsont *self, intmax_t index);
-smallArrayt* cropElemAtArraySmallJsonG              (smallJsont *self, intmax_t index);
-smallBoolt* cropElemAtSmallBoolSmallJsonG           (smallJsont *self, intmax_t index);
-smallBytest* cropElemAtSmallBytesSmallJsonG         (smallJsont *self, intmax_t index);
-smallDoublet* cropElemAtSmallDoubleSmallJsonG       (smallJsont *self, intmax_t index);
-smallIntt* cropElemAtSmallIntSmallJsonG             (smallJsont *self, intmax_t index);
-smallJsont* cropElemAtSmallJsonSmallJsonG           (smallJsont *self, intmax_t index);
-smallStringt* cropElemAtSmallStringSmallJsonG       (smallJsont *self, intmax_t index);
-void* cropElemAtVoidSmallJsonG                      (smallJsont *self, intmax_t index);
-smallContainert* cropElemAtSmallContainerSmallJsonG (smallJsont *self, intmax_t index);
+smallJsont* sliceSmallJsonG(smallJsont *self, int64_t start, int64_t end);
+smallJsont* cropSmallJsonG                          (smallJsont *self, int64_t start, int64_t end);
+char* cropSSmallJsonG                               (smallJsont *self, int64_t start, int64_t end);
+smallStringt* cropSmallStringSmallJsonG             (smallJsont *self, int64_t start, int64_t end);
+baset* cropElemAtSmallJsonG                         (smallJsont *self, int64_t index);
+undefinedt* cropElemAtUndefinedSmallJsonG           (smallJsont *self, int64_t index);
+bool cropElemAtBoolSmallJsonG                       (smallJsont *self, int64_t index);
+double cropElemAtDoubleSmallJsonG                   (smallJsont *self, int64_t index);
+int64_t cropElemAtIntSmallJsonG                     (smallJsont *self, int64_t index);
+int32_t cropElemAtInt32SmallJsonG                   (smallJsont *self, int64_t index);
+uint64_t cropElemAtUintSmallJsonG                   (smallJsont *self, int64_t index);
+uint32_t cropElemAtUint32SmallJsonG                 (smallJsont *self, int64_t index);
+char* cropElemAtSSmallJsonG                         (smallJsont *self, int64_t index);
+char cropElemAtCharSmallJsonG                       (smallJsont *self, int64_t index);
+smallDictt* cropElemAtDictSmallJsonG                (smallJsont *self, int64_t index);
+smallArrayt* cropElemAtArraySmallJsonG              (smallJsont *self, int64_t index);
+smallBoolt* cropElemAtSmallBoolSmallJsonG           (smallJsont *self, int64_t index);
+smallBytest* cropElemAtSmallBytesSmallJsonG         (smallJsont *self, int64_t index);
+smallDoublet* cropElemAtSmallDoubleSmallJsonG       (smallJsont *self, int64_t index);
+smallIntt* cropElemAtSmallIntSmallJsonG             (smallJsont *self, int64_t index);
+smallJsont* cropElemAtSmallJsonSmallJsonG           (smallJsont *self, int64_t index);
+smallStringt* cropElemAtSmallStringSmallJsonG       (smallJsont *self, int64_t index);
+void* cropElemAtVoidSmallJsonG                      (smallJsont *self, int64_t index);
+smallContainert* cropElemAtSmallContainerSmallJsonG (smallJsont *self, int64_t index);
 baset* cropElemKeySmallJsonG                        (smallJsont *self, const char* key);
 undefinedt* cropElemKeyUndefinedSmallJsonG          (smallJsont *self, const char* key);
 bool cropElemKeyBoolSmallJsonG                      (smallJsont *self, const char* key);
@@ -1315,47 +1314,47 @@ smallJsont* cropElemKeySmallJsonSmallJsonG          (smallJsont *self, const cha
 smallStringt* cropElemKeySmallStringSmallJsonG      (smallJsont *self, const char* key);
 void* cropElemKeyVoidSmallJsonG                     (smallJsont *self, const char* key);
 smallContainert* cropElemKeySmallContainerSmallJsonG(smallJsont *self, const char* key);
-smallJsont* copySmallJsonG (smallJsont *self, intmax_t start, intmax_t end);
-smallJsont*          insertSmallJsonG(smallJsont *self, intmax_t index, smallArrayt *toInsert);
-smallJsont*          insertNSmashSmallJsonG(smallJsont *self, intmax_t index, smallArrayt *toInsert);
-smallJsont*          insertSmallJsonSmallJsonG(smallJsont *self, intmax_t index, smallJsont *toInsert);
-smallJsont*          insertNSmashSmallJsonSmallJsonG(smallJsont *self, intmax_t index, smallJsont *toInsert);
-smallJsont*    insertStringSmallJsonG     (smallJsont *self, intmax_t index, smallStringt *toInsert);
-smallJsont*    insertSSmallJsonG    (smallJsont *self, intmax_t index, const char *toInsert);
-smallJsont*    insertNFreeStringSmallJsonG(smallJsont *self, intmax_t index, smallStringt *toInsert);
-smallJsont*    insertNFreeSSmallJsonG(smallJsont *self, intmax_t index, char *toInsert);
-smallJsont* injectSmallJsonG         (smallJsont *self, intmax_t index, baset *value);
-smallJsont* injectUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value UNUSED);
-smallJsont* injectBoolSmallJsonG     (smallJsont *self, intmax_t index, bool value);
-smallJsont* injectDoubleSmallJsonG   (smallJsont *self, intmax_t index, double value);
-smallJsont* injectIntSmallJsonG      (smallJsont *self, intmax_t index, int64_t value);
-smallJsont* injectSSmallJsonG        (smallJsont *self, intmax_t index, const char *string);
-smallJsont* injectCharSmallJsonG(smallJsont *self, intmax_t index, char c);
-smallJsont* injectDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* injectArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* injectArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* injectCArraycSmallJsonG   (smallJsont *self, intmax_t index, const char **array);
-smallJsont* injectVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* injectSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* injectSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* injectSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* injectSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* injectSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* injectSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* injectSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
-smallJsont* injectNFreeSmallJsonG    (smallJsont *self, intmax_t index, baset *value);
-smallJsont* injectNFreeUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* injectNFreeSSmallJsonG        (smallJsont *self, intmax_t index, char *string);
-smallJsont* injectNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* injectNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* injectNFreeArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* injectNFreeSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* injectNFreeSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* injectNFreeSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* injectNFreeSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* injectNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* injectNFreeSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* injectNFreeSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
+smallJsont* copySmallJsonG (smallJsont *self, int64_t start, int64_t end);
+smallJsont*          insertSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert);
+smallJsont*          insertNSmashSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert);
+smallJsont*          insertSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert);
+smallJsont*          insertNSmashSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert);
+smallJsont*    insertStringSmallJsonG     (smallJsont *self, int64_t index, smallStringt *toInsert);
+smallJsont*    insertSSmallJsonG    (smallJsont *self, int64_t index, const char *toInsert);
+smallJsont*    insertNFreeStringSmallJsonG(smallJsont *self, int64_t index, smallStringt *toInsert);
+smallJsont*    insertNFreeSSmallJsonG(smallJsont *self, int64_t index, char *toInsert);
+smallJsont* injectSmallJsonG         (smallJsont *self, int64_t index, baset *value);
+smallJsont* injectUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value UNUSED);
+smallJsont* injectBoolSmallJsonG     (smallJsont *self, int64_t index, bool value);
+smallJsont* injectDoubleSmallJsonG   (smallJsont *self, int64_t index, double value);
+smallJsont* injectIntSmallJsonG      (smallJsont *self, int64_t index, int64_t value);
+smallJsont* injectSSmallJsonG        (smallJsont *self, int64_t index, const char *string);
+smallJsont* injectCharSmallJsonG(smallJsont *self, int64_t index, char c);
+smallJsont* injectDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* injectArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* injectArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* injectCArraycSmallJsonG   (smallJsont *self, int64_t index, const char **array);
+smallJsont* injectVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* injectSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* injectSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* injectSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* injectSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* injectSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* injectSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* injectSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
+smallJsont* injectNFreeSmallJsonG    (smallJsont *self, int64_t index, baset *value);
+smallJsont* injectNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* injectNFreeSSmallJsonG        (smallJsont *self, int64_t index, char *string);
+smallJsont* injectNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* injectNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* injectNFreeArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* injectNFreeSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* injectNFreeSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* injectNFreeSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* injectNFreeSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* injectNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* injectNFreeSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* injectNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
 smallJsont* uniqSmallJsonG(smallJsont *self, char c);
 smallJsont* sortSmallJsonG          (smallJsont *self);
 smallJsont* sortFSmallJsonG(smallJsont *self, shCmpt compareFunction);
@@ -1533,10 +1532,10 @@ bool icEqualSmallJsonSmallJsonG(smallJsont* self, smallJsont* p2);
 bool icEqualSmallJsonSmallStringG(smallJsont* self, smallStringt* p2);
 bool icEqualCharSmallJsonG(smallJsont *self, char c);
 bool icEqualSSmallJsonG       (smallJsont *self, const char *string);
-bool equalISSmallJsonG      (smallJsont *self, const char *string, intmax_t index);
-bool equalICharSmallJsonG(smallJsont *self, char c, intmax_t index);
-bool equalIJsonSmallJsonG(smallJsont *self, smallJsont *string, intmax_t index);
-bool equalISmallStringSmallJsonG(smallJsont *self, smallStringt *string, intmax_t index);
+bool equalISSmallJsonG      (smallJsont *self, const char *string, int64_t index);
+bool equalICharSmallJsonG(smallJsont *self, char c, int64_t index);
+bool equalIJsonSmallJsonG(smallJsont *self, smallJsont *string, int64_t index);
+bool equalISmallStringSmallJsonG(smallJsont *self, smallStringt *string, int64_t index);
 bool startsWithSSmallJsonG  (smallJsont *self, const char *string);
 bool startsWithCharSmallJsonG(smallJsont *self, char c);
 bool startsWithSmallStringSmallJsonG(smallJsont *self, smallStringt *string);
@@ -1563,9 +1562,9 @@ ssize_t icCountSmallStringSmallJsonG(smallJsont *self, smallStringt *string);
 ssize_t icCountJsonSmallJsonG(smallJsont *self, smallJsont *string);
 bool isNumberSmallJsonG(smallJsont *self);
 bool isIntSmallJsonG(smallJsont *self);
-intmax_t parseIntSmallJsonG (smallJsont *self);
+int64_t parseIntSmallJsonG (smallJsont *self);
 double parseDoubleSmallJsonG (smallJsont *self);
-smallJsont* intToSmallJsonG        (smallJsont *self, intmax_t n);
+smallJsont* intToSmallJsonG        (smallJsont *self, int64_t n);
 smallJsont* doubleToSmallJsonG     (smallJsont *self, double n);
 size_t      lenSmallJsonG       (smallJsont *self);
 smallJsont*    upperSmallJsonG      (smallJsont *self);
@@ -4379,16 +4378,16 @@ internal smallJsont* setNFreePSmallStringSmallJson(smallJsont *self, const char 
   // cg_c bug
 }
 
-internal smallJsont* setAtSmallJson(smallJsont *self, intmax_t index, baset *value) {
+internal smallJsont* setAtSmallJson(smallJsont *self, int64_t index, baset *value) {
 
   if (self->topIsA != TOP_IS_ARRAY || !value) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4399,16 +4398,16 @@ internal smallJsont* setAtSmallJson(smallJsont *self, intmax_t index, baset *val
   return(self);
 }
 
-internal smallJsont* setAtUndefinedSmallJson(smallJsont *self, intmax_t index) {
+internal smallJsont* setAtUndefinedSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4423,16 +4422,16 @@ internal smallJsont* setAtUndefinedSmallJson(smallJsont *self, intmax_t index) {
   return(self);
 }
 
-internal smallJsont* setAtBoolSmallJson(smallJsont *self, intmax_t index, bool value) {
+internal smallJsont* setAtBoolSmallJson(smallJsont *self, int64_t index, bool value) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4447,16 +4446,16 @@ internal smallJsont* setAtBoolSmallJson(smallJsont *self, intmax_t index, bool v
   return(self);
 }
 
-internal smallJsont* setAtDoubleSmallJson(smallJsont *self, intmax_t index, double value) {
+internal smallJsont* setAtDoubleSmallJson(smallJsont *self, int64_t index, double value) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4471,16 +4470,16 @@ internal smallJsont* setAtDoubleSmallJson(smallJsont *self, intmax_t index, doub
   return(self);
 }
 
-internal smallJsont* setAtIntSmallJson(smallJsont *self, intmax_t index, int64_t value) {
+internal smallJsont* setAtIntSmallJson(smallJsont *self, int64_t index, int64_t value) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4495,16 +4494,16 @@ internal smallJsont* setAtIntSmallJson(smallJsont *self, intmax_t index, int64_t
   return(self);
 }
 
-internal smallJsont* setAtSSmallJson(smallJsont *self, intmax_t index, const char *string) {
+internal smallJsont* setAtSSmallJson(smallJsont *self, int64_t index, const char *string) {
 
   if (self->topIsA != TOP_IS_ARRAY || !string) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4520,7 +4519,7 @@ internal smallJsont* setAtSSmallJson(smallJsont *self, intmax_t index, const cha
   return(self);
 }
 
-internal smallJsont* setAtCharSmallJson(smallJsont *self, intmax_t index, char c) {
+internal smallJsont* setAtCharSmallJson(smallJsont *self, int64_t index, char c) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4530,7 +4529,7 @@ internal smallJsont* setAtCharSmallJson(smallJsont *self, intmax_t index, char c
   return(setAtSSmallJson(self, index, s));
 }
 
-internal smallJsont* setAtDictSmallJson(smallJsont *self, intmax_t index, smallDictt *dict) {
+internal smallJsont* setAtDictSmallJson(smallJsont *self, int64_t index, smallDictt *dict) {
 
   if (self->topIsA != TOP_IS_ARRAY || !dict) {
     return(NULL);
@@ -4540,10 +4539,10 @@ internal smallJsont* setAtDictSmallJson(smallJsont *self, intmax_t index, smallD
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4559,7 +4558,7 @@ internal smallJsont* setAtDictSmallJson(smallJsont *self, intmax_t index, smallD
 }
 
 
-internal smallJsont* setAtArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *array) {
+internal smallJsont* setAtArraySmallJson(smallJsont *self, int64_t index, smallArrayt *array) {
 
   if (self->topIsA != TOP_IS_ARRAY || !array) {
     return(NULL);
@@ -4569,10 +4568,10 @@ internal smallJsont* setAtArraySmallJson(smallJsont *self, intmax_t index, small
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4588,16 +4587,16 @@ internal smallJsont* setAtArraySmallJson(smallJsont *self, intmax_t index, small
   return(self);
 }
 
-internal smallJsont* setAtArraycSmallJson(smallJsont *self, intmax_t index, char **array) {
+internal smallJsont* setAtArraycSmallJson(smallJsont *self, int64_t index, char **array) {
 
   if (self->topIsA != TOP_IS_ARRAY || !array) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4624,7 +4623,7 @@ internal smallJsont* setAtArraycSmallJson(smallJsont *self, intmax_t index, char
   return(self);
 }
 
-internal smallJsont* setAtSmallBoolSmallJson(smallJsont *self, intmax_t index, smallBoolt *value) {
+internal smallJsont* setAtSmallBoolSmallJson(smallJsont *self, int64_t index, smallBoolt *value) {
 
   if (self->topIsA != TOP_IS_ARRAY || !value) {
     return(NULL);
@@ -4634,10 +4633,10 @@ internal smallJsont* setAtSmallBoolSmallJson(smallJsont *self, intmax_t index, s
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4651,7 +4650,7 @@ internal smallJsont* setAtSmallBoolSmallJson(smallJsont *self, intmax_t index, s
   return(self);
 }
 
-internal smallJsont* setAtSmallBytesSmallJson(smallJsont *self, intmax_t index, smallBytest *value) {
+internal smallJsont* setAtSmallBytesSmallJson(smallJsont *self, int64_t index, smallBytest *value) {
 
   if (self->topIsA != TOP_IS_ARRAY || !value) {
     return(NULL);
@@ -4661,10 +4660,10 @@ internal smallJsont* setAtSmallBytesSmallJson(smallJsont *self, intmax_t index, 
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4678,7 +4677,7 @@ internal smallJsont* setAtSmallBytesSmallJson(smallJsont *self, intmax_t index, 
   return(self);
 }
 
-internal smallJsont* setAtSmallDoubleSmallJson(smallJsont *self, intmax_t index, smallDoublet *value) {
+internal smallJsont* setAtSmallDoubleSmallJson(smallJsont *self, int64_t index, smallDoublet *value) {
 
   if (self->topIsA != TOP_IS_ARRAY || !value) {
     return(NULL);
@@ -4688,10 +4687,10 @@ internal smallJsont* setAtSmallDoubleSmallJson(smallJsont *self, intmax_t index,
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4705,7 +4704,7 @@ internal smallJsont* setAtSmallDoubleSmallJson(smallJsont *self, intmax_t index,
   return(self);
 }
 
-internal smallJsont* setAtSmallIntSmallJson(smallJsont *self, intmax_t index, smallIntt *value) {
+internal smallJsont* setAtSmallIntSmallJson(smallJsont *self, int64_t index, smallIntt *value) {
 
   if (self->topIsA != TOP_IS_ARRAY || !value) {
     return(NULL);
@@ -4715,10 +4714,10 @@ internal smallJsont* setAtSmallIntSmallJson(smallJsont *self, intmax_t index, sm
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4732,7 +4731,7 @@ internal smallJsont* setAtSmallIntSmallJson(smallJsont *self, intmax_t index, sm
   return(self);
 }
 
-internal smallJsont* setAtSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *value) {
+internal smallJsont* setAtSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *value) {
 
   if (self->topIsA != TOP_IS_ARRAY || !value) {
     return(NULL);
@@ -4742,10 +4741,10 @@ internal smallJsont* setAtSmallJsonSmallJson(smallJsont *self, intmax_t index, s
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4763,7 +4762,7 @@ internal smallJsont* setAtSmallJsonSmallJson(smallJsont *self, intmax_t index, s
   return(self);
 }
 
-internal smallJsont* setAtSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *string) {
+internal smallJsont* setAtSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *string) {
 
   if (self->topIsA != TOP_IS_ARRAY || !string) {
     return(NULL);
@@ -4773,10 +4772,10 @@ internal smallJsont* setAtSmallStringSmallJson(smallJsont *self, intmax_t index,
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4790,7 +4789,7 @@ internal smallJsont* setAtSmallStringSmallJson(smallJsont *self, intmax_t index,
   return(self);
 }
 
-internal smallJsont* setAtSmallContainerSmallJson(smallJsont *self, intmax_t index, smallContainert *container) {
+internal smallJsont* setAtSmallContainerSmallJson(smallJsont *self, int64_t index, smallContainert *container) {
 
   if (self->topIsA != TOP_IS_ARRAY || !container) {
     return(NULL);
@@ -4801,10 +4800,10 @@ internal smallJsont* setAtSmallContainerSmallJson(smallJsont *self, intmax_t ind
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4818,16 +4817,16 @@ internal smallJsont* setAtSmallContainerSmallJson(smallJsont *self, intmax_t ind
   return(self);
 }
 
-internal smallJsont* setAtNFreeSmallJson(smallJsont *self, intmax_t index, baset *value) {
+internal smallJsont* setAtNFreeSmallJson(smallJsont *self, int64_t index, baset *value) {
 
   if (self->topIsA != TOP_IS_ARRAY || !value) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -4843,7 +4842,7 @@ internal smallJsont* setAtNFreeSmallJson(smallJsont *self, intmax_t index, baset
   return(self);
 }
 
-internal smallJsont* setAtNFreeUndefinedSmallJson(smallJsont *self, intmax_t index, undefinedt *undefined) {
+internal smallJsont* setAtNFreeUndefinedSmallJson(smallJsont *self, int64_t index, undefinedt *undefined) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4856,7 +4855,7 @@ internal smallJsont* setAtNFreeUndefinedSmallJson(smallJsont *self, intmax_t ind
   return(r);
 }
 
-internal smallJsont* setAtNFreeSSmallJson(smallJsont *self, intmax_t index, char *string) {
+internal smallJsont* setAtNFreeSSmallJson(smallJsont *self, int64_t index, char *string) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4869,7 +4868,7 @@ internal smallJsont* setAtNFreeSSmallJson(smallJsont *self, intmax_t index, char
   return(r);
 }
 
-internal smallJsont* setAtNFreeDictSmallJson(smallJsont *self, intmax_t index, smallDictt *dict) {
+internal smallJsont* setAtNFreeDictSmallJson(smallJsont *self, int64_t index, smallDictt *dict) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4882,7 +4881,7 @@ internal smallJsont* setAtNFreeDictSmallJson(smallJsont *self, intmax_t index, s
   return(r);
 }
 
-internal smallJsont* setAtNFreeArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *array) {
+internal smallJsont* setAtNFreeArraySmallJson(smallJsont *self, int64_t index, smallArrayt *array) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4895,7 +4894,7 @@ internal smallJsont* setAtNFreeArraySmallJson(smallJsont *self, intmax_t index, 
   return(r);
 }
 
-internal smallJsont* setAtNFreeArraycSmallJson(smallJsont *self, intmax_t index, char **array) {
+internal smallJsont* setAtNFreeArraycSmallJson(smallJsont *self, int64_t index, char **array) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4908,7 +4907,7 @@ internal smallJsont* setAtNFreeArraycSmallJson(smallJsont *self, intmax_t index,
   return(r);
 }
 
-internal smallJsont* setAtNFreeSmallBoolSmallJson(smallJsont *self, intmax_t index, smallBoolt *value) {
+internal smallJsont* setAtNFreeSmallBoolSmallJson(smallJsont *self, int64_t index, smallBoolt *value) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4921,7 +4920,7 @@ internal smallJsont* setAtNFreeSmallBoolSmallJson(smallJsont *self, intmax_t ind
   return(r);
 }
 
-internal smallJsont* setAtNFreeSmallBytesSmallJson(smallJsont *self, intmax_t index, smallBytest *value) {
+internal smallJsont* setAtNFreeSmallBytesSmallJson(smallJsont *self, int64_t index, smallBytest *value) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4934,7 +4933,7 @@ internal smallJsont* setAtNFreeSmallBytesSmallJson(smallJsont *self, intmax_t in
   return(r);
 }
 
-internal smallJsont* setAtNFreeSmallDoubleSmallJson(smallJsont *self, intmax_t index, smallDoublet *value) {
+internal smallJsont* setAtNFreeSmallDoubleSmallJson(smallJsont *self, int64_t index, smallDoublet *value) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4947,7 +4946,7 @@ internal smallJsont* setAtNFreeSmallDoubleSmallJson(smallJsont *self, intmax_t i
   return(r);
 }
 
-internal smallJsont* setAtNFreeSmallIntSmallJson(smallJsont *self, intmax_t index, smallIntt *value) {
+internal smallJsont* setAtNFreeSmallIntSmallJson(smallJsont *self, int64_t index, smallIntt *value) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4960,7 +4959,7 @@ internal smallJsont* setAtNFreeSmallIntSmallJson(smallJsont *self, intmax_t inde
   return(r);
 }
 
-internal smallJsont* setAtNFreeSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *value) {
+internal smallJsont* setAtNFreeSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *value) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4973,7 +4972,7 @@ internal smallJsont* setAtNFreeSmallJsonSmallJson(smallJsont *self, intmax_t ind
   return(r);
 }
 
-internal smallJsont* setAtNFreeSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *string) {
+internal smallJsont* setAtNFreeSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *string) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -4986,7 +4985,7 @@ internal smallJsont* setAtNFreeSmallStringSmallJson(smallJsont *self, intmax_t i
   return(r);
 }
 
-internal smallJsont* setAtNFreeSmallContainerSmallJson(smallJsont *self, intmax_t index, smallContainert *container) {
+internal smallJsont* setAtNFreeSmallContainerSmallJson(smallJsont *self, int64_t index, smallContainert *container) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -5000,7 +4999,7 @@ internal smallJsont* setAtNFreeSmallContainerSmallJson(smallJsont *self, intmax_
 }
 
 
-internal smallJsont* setPAtDictSmallJson(smallJsont *self, intmax_t index, smallDictt *dict) {
+internal smallJsont* setPAtDictSmallJson(smallJsont *self, int64_t index, smallDictt *dict) {
 
   if (self->topIsA != TOP_IS_ARRAY || !dict) {
     return(NULL);
@@ -5010,10 +5009,10 @@ internal smallJsont* setPAtDictSmallJson(smallJsont *self, intmax_t index, small
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -5029,7 +5028,7 @@ internal smallJsont* setPAtDictSmallJson(smallJsont *self, intmax_t index, small
   return(self);
 }
 
-internal smallJsont* setPAtArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *array) {
+internal smallJsont* setPAtArraySmallJson(smallJsont *self, int64_t index, smallArrayt *array) {
 
   if (self->topIsA != TOP_IS_ARRAY || !array) {
     return(NULL);
@@ -5039,10 +5038,10 @@ internal smallJsont* setPAtArraySmallJson(smallJsont *self, intmax_t index, smal
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -5058,7 +5057,7 @@ internal smallJsont* setPAtArraySmallJson(smallJsont *self, intmax_t index, smal
   return(self);
 }
 
-internal smallJsont* setPAtSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *value) {
+internal smallJsont* setPAtSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *value) {
 
   if (self->topIsA != TOP_IS_ARRAY || !value) {
     return(NULL);
@@ -5068,10 +5067,10 @@ internal smallJsont* setPAtSmallJsonSmallJson(smallJsont *self, intmax_t index, 
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -5088,7 +5087,7 @@ internal smallJsont* setPAtSmallJsonSmallJson(smallJsont *self, intmax_t index, 
   return(self);
 }
 
-internal smallJsont* setPAtSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *string) {
+internal smallJsont* setPAtSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *string) {
 
   if (self->topIsA != TOP_IS_ARRAY || !string) {
     return(NULL);
@@ -5098,10 +5097,10 @@ internal smallJsont* setPAtSmallStringSmallJson(smallJsont *self, intmax_t index
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -5118,7 +5117,7 @@ internal smallJsont* setPAtSmallStringSmallJson(smallJsont *self, intmax_t index
   return(self);
 }
 
-internal smallJsont* setPAtNFreeDictSmallJson(smallJsont *self, intmax_t index, smallDictt *dict) {
+internal smallJsont* setPAtNFreeDictSmallJson(smallJsont *self, int64_t index, smallDictt *dict) {
 
   if (self->topIsA != TOP_IS_ARRAY || !dict) {
     return(NULL);
@@ -5128,10 +5127,10 @@ internal smallJsont* setPAtNFreeDictSmallJson(smallJsont *self, intmax_t index, 
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -5149,7 +5148,7 @@ internal smallJsont* setPAtNFreeDictSmallJson(smallJsont *self, intmax_t index, 
 }
 
 
-internal smallJsont* setPAtNFreeArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *array) {
+internal smallJsont* setPAtNFreeArraySmallJson(smallJsont *self, int64_t index, smallArrayt *array) {
 
   if (self->topIsA != TOP_IS_ARRAY || !array) {
     return(NULL);
@@ -5159,10 +5158,10 @@ internal smallJsont* setPAtNFreeArraySmallJson(smallJsont *self, intmax_t index,
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -5179,7 +5178,7 @@ internal smallJsont* setPAtNFreeArraySmallJson(smallJsont *self, intmax_t index,
   return(self);
 }
 
-internal smallJsont* setPAtNFreeSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *value) {
+internal smallJsont* setPAtNFreeSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *value) {
 
   if (self->topIsA != TOP_IS_ARRAY || !value) {
     return(NULL);
@@ -5189,10 +5188,10 @@ internal smallJsont* setPAtNFreeSmallJsonSmallJson(smallJsont *self, intmax_t in
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -5210,7 +5209,7 @@ internal smallJsont* setPAtNFreeSmallJsonSmallJson(smallJsont *self, intmax_t in
   return(self);
 }
 
-internal smallJsont* setPAtNFreeSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *string) {
+internal smallJsont* setPAtNFreeSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *string) {
 
   if (self->topIsA != TOP_IS_ARRAY || !string) {
     return(NULL);
@@ -5220,10 +5219,10 @@ internal smallJsont* setPAtNFreeSmallStringSmallJson(smallJsont *self, intmax_t 
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8179,10 +8178,10 @@ internal smallJsont* addJsonSmallJson(smallJsont *self, smallJsont *array) {
   return(r);
 }
 
-internal smallJsont* sliceSmallJson(smallJsont *self, intmax_t start, intmax_t end) {
+internal smallJsont* sliceSmallJson(smallJsont *self, int64_t start, int64_t end) {
   size_t len;
   char *s = NULL;
-  intmax_t n;
+  int64_t n;
 
   if (self->topIsA != TOP_IS_ARRAY && self->topIsA != TOP_IS_STRING) {
     return(NULL);
@@ -8194,17 +8193,17 @@ internal smallJsont* sliceSmallJson(smallJsont *self, intmax_t start, intmax_t e
     return(NULL);
   }
 
-  if (start > (intmax_t)len) {
+  if (start > (int64_t)len) {
     emptySmallJson(self);
     return(NULL);
   }
-  if (end > (intmax_t)len) {
+  if (end > (int64_t)len) {
     end = len;
   }
-  if (start <= -(intmax_t)len) {
+  if (start <= -(int64_t)len) {
     start = -len;
   }
-  if (end <= -(intmax_t)len) {
+  if (end <= -(int64_t)len) {
     emptySmallJson(self);
     return(NULL);
   }
@@ -8257,9 +8256,9 @@ internal smallJsont* sliceSmallJson(smallJsont *self, intmax_t start, intmax_t e
 }
 
 
-internal smallJsont* cropSmallJson(smallJsont *self, intmax_t start, intmax_t end) {
-  intmax_t len;
-  intmax_t n;
+internal smallJsont* cropSmallJson(smallJsont *self, int64_t start, int64_t end) {
+  int64_t len;
+  int64_t n;
   char *l = NULL;
   smallt *o = NULL;
 
@@ -8313,7 +8312,7 @@ internal smallJsont* cropSmallJson(smallJsont *self, intmax_t start, intmax_t en
     switch(self->topIsA) {
       case TOP_IS_ARRAY:
         // start < end < len
-        for (intmax_t i=0;i < n;i++) {
+        for (int64_t i=0;i < n;i++) {
           o = sArrayGetTiny(self->topA, start+i);
           sArrayPushTiny(&(r->topA), o);
         }
@@ -8349,9 +8348,9 @@ internal smallJsont* cropSmallJson(smallJsont *self, intmax_t start, intmax_t en
 }
 
 
-internal char* cropSSmallJson(smallJsont *self, intmax_t start, intmax_t end) {
+internal char* cropSSmallJson(smallJsont *self, int64_t start, int64_t end) {
   char *l = NULL;
-  intmax_t len;
+  int64_t len;
 
   if (self->topIsA != TOP_IS_STRING) {
     return(NULL);
@@ -8387,7 +8386,7 @@ internal char* cropSSmallJson(smallJsont *self, intmax_t start, intmax_t end) {
 
   if (start < end) {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = malloc((n+1) * sizeof(char));
     if (!l) {
@@ -8407,7 +8406,7 @@ internal char* cropSSmallJson(smallJsont *self, intmax_t start, intmax_t end) {
 }
 
 
-internal smallStringt* cropSmallStringSmallJson(smallJsont *self, intmax_t start, intmax_t end) {
+internal smallStringt* cropSmallStringSmallJson(smallJsont *self, int64_t start, int64_t end) {
 
   char *cropped = cropSSmallJson(self, start, end);
 
@@ -8425,17 +8424,17 @@ internal smallStringt* cropSmallStringSmallJson(smallJsont *self, intmax_t start
 }
 
 
-internal baset* cropElemAtSmallJson(smallJsont *self, intmax_t index) {
+internal baset* cropElemAtSmallJson(smallJsont *self, int64_t index) {
   baset *r = NULL;
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8479,17 +8478,17 @@ internal baset* cropElemAtSmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal undefinedt* cropElemAtUndefinedSmallJson(smallJsont *self, intmax_t index) {
+internal undefinedt* cropElemAtUndefinedSmallJson(smallJsont *self, int64_t index) {
   undefinedt *r = NULL;
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8519,16 +8518,16 @@ internal undefinedt* cropElemAtUndefinedSmallJson(smallJsont *self, intmax_t ind
   return(r);
 }
 
-internal bool cropElemAtBoolSmallJson(smallJsont *self, intmax_t index) {
+internal bool cropElemAtBoolSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(false);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(false);
   }
   if (index < 0) {
@@ -8566,16 +8565,16 @@ internal bool cropElemAtBoolSmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal double cropElemAtDoubleSmallJson(smallJsont *self, intmax_t index) {
+internal double cropElemAtDoubleSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(0);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(0);
   }
   if (index < 0) {
@@ -8613,16 +8612,16 @@ internal double cropElemAtDoubleSmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal int64_t cropElemAtIntSmallJson(smallJsont *self, intmax_t index) {
+internal int64_t cropElemAtIntSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(0);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(0);
   }
   if (index < 0) {
@@ -8660,16 +8659,16 @@ internal int64_t cropElemAtIntSmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal int32_t cropElemAtInt32SmallJson(smallJsont *self, intmax_t index) {
+internal int32_t cropElemAtInt32SmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(0);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(0);
   }
   if (index < 0) {
@@ -8707,16 +8706,16 @@ internal int32_t cropElemAtInt32SmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal uint64_t cropElemAtUintSmallJson(smallJsont *self, intmax_t index) {
+internal uint64_t cropElemAtUintSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(0);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(0);
   }
   if (index < 0) {
@@ -8754,16 +8753,16 @@ internal uint64_t cropElemAtUintSmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal uint32_t cropElemAtUint32SmallJson(smallJsont *self, intmax_t index) {
+internal uint32_t cropElemAtUint32SmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(0);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(0);
   }
   if (index < 0) {
@@ -8801,16 +8800,16 @@ internal uint32_t cropElemAtUint32SmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal char* cropElemAtSSmallJson(smallJsont *self, intmax_t index) {
+internal char* cropElemAtSSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8848,8 +8847,8 @@ internal char* cropElemAtSSmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal char cropElemAtCharSmallJson(smallJsont *self, intmax_t index) {
-  intmax_t len;
+internal char cropElemAtCharSmallJson(smallJsont *self, int64_t index) {
+  int64_t len;
 
   if (self->topIsA != TOP_IS_STRING) {
     return(0);
@@ -8886,16 +8885,16 @@ internal char cropElemAtCharSmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal smallDictt* cropElemAtDictSmallJson(smallJsont *self, intmax_t index) {
+internal smallDictt* cropElemAtDictSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8928,16 +8927,16 @@ internal smallDictt* cropElemAtDictSmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal smallArrayt* cropElemAtArraySmallJson(smallJsont *self, intmax_t index) {
+internal smallArrayt* cropElemAtArraySmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -8970,16 +8969,16 @@ internal smallArrayt* cropElemAtArraySmallJson(smallJsont *self, intmax_t index)
 }
 
 
-internal smallBoolt* cropElemAtSmallBoolSmallJson(smallJsont *self, intmax_t index) {
+internal smallBoolt* cropElemAtSmallBoolSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -9012,16 +9011,16 @@ internal smallBoolt* cropElemAtSmallBoolSmallJson(smallJsont *self, intmax_t ind
 }
 
 
-internal smallBytest* cropElemAtSmallBytesSmallJson(smallJsont *self, intmax_t index) {
+internal smallBytest* cropElemAtSmallBytesSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -9054,16 +9053,16 @@ internal smallBytest* cropElemAtSmallBytesSmallJson(smallJsont *self, intmax_t i
 }
 
 
-internal smallDoublet* cropElemAtSmallDoubleSmallJson(smallJsont *self, intmax_t index) {
+internal smallDoublet* cropElemAtSmallDoubleSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -9096,16 +9095,16 @@ internal smallDoublet* cropElemAtSmallDoubleSmallJson(smallJsont *self, intmax_t
 }
 
 
-internal smallIntt* cropElemAtSmallIntSmallJson(smallJsont *self, intmax_t index) {
+internal smallIntt* cropElemAtSmallIntSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -9138,16 +9137,16 @@ internal smallIntt* cropElemAtSmallIntSmallJson(smallJsont *self, intmax_t index
 }
 
 
-internal smallJsont* cropElemAtSmallJsonSmallJson(smallJsont *self, intmax_t index) {
+internal smallJsont* cropElemAtSmallJsonSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -9186,16 +9185,16 @@ internal smallJsont* cropElemAtSmallJsonSmallJson(smallJsont *self, intmax_t ind
 }
 
 
-internal smallStringt* cropElemAtSmallStringSmallJson(smallJsont *self, intmax_t index) {
+internal smallStringt* cropElemAtSmallStringSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -9228,16 +9227,16 @@ internal smallStringt* cropElemAtSmallStringSmallJson(smallJsont *self, intmax_t
 }
 
 
-internal void* cropElemAtVoidSmallJson(smallJsont *self, intmax_t index) {
+internal void* cropElemAtVoidSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -9275,16 +9274,16 @@ internal void* cropElemAtVoidSmallJson(smallJsont *self, intmax_t index) {
 }
 
 
-internal smallContainert* cropElemAtSmallContainerSmallJson(smallJsont *self, intmax_t index) {
+internal smallContainert* cropElemAtSmallContainerSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -10057,7 +10056,7 @@ internal smallContainert* cropElemKeySmallContainerSmallJson(smallJsont *self, c
 
 
 
-internal smallJsont* copySmallJson(smallJsont *self, intmax_t start, intmax_t end) {
+internal smallJsont* copySmallJson(smallJsont *self, int64_t start, int64_t end) {
   size_t len;
   smallt *o = NULL;
   char *s = NULL;
@@ -10072,16 +10071,16 @@ internal smallJsont* copySmallJson(smallJsont *self, intmax_t start, intmax_t en
     return(NULL);
   }
 
-  if (start >= (intmax_t)len) {
+  if (start >= (int64_t)len) {
     return(NULL);
   }
-  if (end > (intmax_t)len) {
+  if (end > (int64_t)len) {
     end = len;
   }
-  if (start <= -(intmax_t)len) {
+  if (start <= -(int64_t)len) {
     start = -len;
   }
-  if (end <= -(intmax_t)len) {
+  if (end <= -(int64_t)len) {
     return(NULL);
   }
   if (start < 0) {
@@ -10108,10 +10107,10 @@ internal smallJsont* copySmallJson(smallJsont *self, intmax_t start, intmax_t en
       }
       else {
         // start < end < len
-        intmax_t n;
+        int64_t n;
         n = end - start;
 
-        for (intmax_t i=0;i < n;i++) {
+        for (int64_t i=0;i < n;i++) {
           o = sArrayGetTiny(self->topA, start+i);
           sArrayPushTiny(&(r->topA), sDuplicate(o));
       }
@@ -10119,7 +10118,7 @@ internal smallJsont* copySmallJson(smallJsont *self, intmax_t start, intmax_t en
       break;
     case TOP_IS_STRING:;
 
-      intmax_t n;
+      int64_t n;
       if (start == end) {
         emptyS(s);
       }
@@ -10142,7 +10141,7 @@ internal smallJsont* copySmallJson(smallJsont *self, intmax_t start, intmax_t en
   return(r);
 }
 
-internal smallJsont* insertSmallJson(smallJsont *self, intmax_t index, smallArrayt *toInsert) {
+internal smallJsont* insertSmallJson(smallJsont *self, int64_t index, smallArrayt *toInsert) {
   size_t len;;
 
   //sanity checks
@@ -10177,13 +10176,13 @@ internal smallJsont* insertSmallJson(smallJsont *self, intmax_t index, smallArra
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -10203,26 +10202,26 @@ internal smallJsont* insertSmallJson(smallJsont *self, intmax_t index, smallArra
   smallt *o;
   if (index == 0) {
     // insert at beginning
-    for (intmax_t i=0;i < (intmax_t)toInsert->f->len(toInsert);i++) {
+    for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) {
       o = sArrayGetTiny(toInsert->a, i);
       sArrayPushTiny(&a, o);
     }
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
     }
   else {
 
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
     }
-    for (intmax_t i=0;i < (intmax_t)toInsert->f->len(toInsert);i++) {
+    for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) {
       o = sArrayGetTiny(toInsert->a, i);
       sArrayPushTiny(&a, o);
     }
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10233,7 +10232,7 @@ internal smallJsont* insertSmallJson(smallJsont *self, intmax_t index, smallArra
   return(self);
 }
 
-internal smallJsont* insertNSmashSmallJson(smallJsont *self, intmax_t index, smallArrayt *toInsert) {
+internal smallJsont* insertNSmashSmallJson(smallJsont *self, int64_t index, smallArrayt *toInsert) {
   smallJsont *r = NULL;
 
   r = insertSmallJson(self, index, toInsert);
@@ -10243,7 +10242,7 @@ internal smallJsont* insertNSmashSmallJson(smallJsont *self, intmax_t index, sma
   return(r);
 }
 
-internal smallJsont* insertSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *toInsert) {
+internal smallJsont* insertSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *toInsert) {
   size_t len;;
 
   //sanity checks
@@ -10270,13 +10269,13 @@ internal smallJsont* insertSmallJsonSmallJson(smallJsont *self, intmax_t index, 
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -10300,26 +10299,26 @@ internal smallJsont* insertSmallJsonSmallJson(smallJsont *self, intmax_t index, 
   smallt *o;
   if (index == 0) {
     // insert at beginning
-    for (intmax_t i=0;i < (intmax_t)toInsert->f->len(toInsert);i++) {
+    for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) {
       o = sArrayGetTiny(toInsert->topA, i);
       sArrayPushTiny(&a, o);
     }
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
     }
   else {
 
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
     }
-    for (intmax_t i=0;i < (intmax_t)toInsert->f->len(toInsert);i++) {
+    for (int64_t i=0;i < (int64_t)toInsert->f->len(toInsert);i++) {
       o = sArrayGetTiny(toInsert->topA, i);
       sArrayPushTiny(&a, o);
     }
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10330,7 +10329,7 @@ internal smallJsont* insertSmallJsonSmallJson(smallJsont *self, intmax_t index, 
   return(self);
 }
 
-internal smallJsont* insertNSmashSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *toInsert) {
+internal smallJsont* insertNSmashSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *toInsert) {
   smallJsont *r = NULL;
 
   r = insertSmallJsonSmallJson(self, index, toInsert);
@@ -10340,7 +10339,7 @@ internal smallJsont* insertNSmashSmallJsonSmallJson(smallJsont *self, intmax_t i
   return(r);
 }
 
-internal smallJsont* insertStringSmallJson(smallJsont *self, intmax_t index, smallStringt *toInsert) {
+internal smallJsont* insertStringSmallJson(smallJsont *self, int64_t index, smallStringt *toInsert) {
   char *r = NULL;
 
   // sanity checks
@@ -10382,13 +10381,13 @@ internal smallJsont* insertStringSmallJson(smallJsont *self, intmax_t index, sma
     neg = true;
   }
 
-  if (index > (intmax_t)lenSmallJson(self)) {
+  if (index > (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (neg) {
@@ -10417,7 +10416,7 @@ internal smallJsont* insertStringSmallJson(smallJsont *self, intmax_t index, sma
   return(self);
 }
 
-internal smallJsont* insertSSmallJson(smallJsont *self, intmax_t index, const char *toInsert) {
+internal smallJsont* insertSSmallJson(smallJsont *self, int64_t index, const char *toInsert) {
   char *r = NULL;
 
   // sanity checks
@@ -10453,13 +10452,13 @@ internal smallJsont* insertSSmallJson(smallJsont *self, intmax_t index, const ch
     neg = true;
   }
 
-  if (index > (intmax_t)lenSmallJson(self)) {
+  if (index > (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (neg) {
@@ -10489,7 +10488,7 @@ internal smallJsont* insertSSmallJson(smallJsont *self, intmax_t index, const ch
   return(self);
 }
 
-internal smallJsont* insertNFreeStringSmallJson(smallJsont *self, intmax_t index, smallStringt *toInsert) {
+internal smallJsont* insertNFreeStringSmallJson(smallJsont *self, int64_t index, smallStringt *toInsert) {
 
   smallJsont *r = insertStringSmallJson(self, index, toInsert);
   if (r) {
@@ -10498,7 +10497,7 @@ internal smallJsont* insertNFreeStringSmallJson(smallJsont *self, intmax_t index
   return(r);
 }
 
-internal smallJsont* insertSNFreeSmallJson(smallJsont *self, intmax_t index, char *toInsert) {
+internal smallJsont* insertSNFreeSmallJson(smallJsont *self, int64_t index, char *toInsert) {
 
   smallJsont *r = insertSSmallJson(self, index, toInsert);
   if (r) {
@@ -10507,7 +10506,7 @@ internal smallJsont* insertSNFreeSmallJson(smallJsont *self, intmax_t index, cha
   return(r);
 }
 
-internal smallJsont* injectSmallJson(smallJsont *self, intmax_t index, baset *toInject) {
+internal smallJsont* injectSmallJson(smallJsont *self, int64_t index, baset *toInject) {
   size_t len;
 
   if (self->topIsA != SMALLJSON_IS_EMPTY && self->topIsA != TOP_IS_ARRAY) {
@@ -10533,13 +10532,13 @@ internal smallJsont* injectSmallJson(smallJsont *self, intmax_t index, baset *to
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -10561,7 +10560,7 @@ internal smallJsont* injectSmallJson(smallJsont *self, intmax_t index, baset *to
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10569,12 +10568,12 @@ internal smallJsont* injectSmallJson(smallJsont *self, intmax_t index, baset *to
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10585,7 +10584,7 @@ internal smallJsont* injectSmallJson(smallJsont *self, intmax_t index, baset *to
   return(self);
 }
 
-internal smallJsont* injectUndefinedSmallJson(smallJsont *self, intmax_t index) {
+internal smallJsont* injectUndefinedSmallJson(smallJsont *self, int64_t index) {
   size_t len;
 
   if (self->topIsA != SMALLJSON_IS_EMPTY && self->topIsA != TOP_IS_ARRAY) {
@@ -10607,13 +10606,13 @@ internal smallJsont* injectUndefinedSmallJson(smallJsont *self, intmax_t index) 
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -10635,7 +10634,7 @@ internal smallJsont* injectUndefinedSmallJson(smallJsont *self, intmax_t index) 
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10643,12 +10642,12 @@ internal smallJsont* injectUndefinedSmallJson(smallJsont *self, intmax_t index) 
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10659,7 +10658,7 @@ internal smallJsont* injectUndefinedSmallJson(smallJsont *self, intmax_t index) 
   return(self);
 }
 
-internal smallJsont* injectBoolSmallJson(smallJsont *self, intmax_t index, bool toInject) {
+internal smallJsont* injectBoolSmallJson(smallJsont *self, int64_t index, bool toInject) {
   size_t len;
 
   if (self->topIsA != SMALLJSON_IS_EMPTY && self->topIsA != TOP_IS_ARRAY) {
@@ -10681,13 +10680,13 @@ internal smallJsont* injectBoolSmallJson(smallJsont *self, intmax_t index, bool 
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -10710,7 +10709,7 @@ internal smallJsont* injectBoolSmallJson(smallJsont *self, intmax_t index, bool 
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10718,12 +10717,12 @@ internal smallJsont* injectBoolSmallJson(smallJsont *self, intmax_t index, bool 
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10734,7 +10733,7 @@ internal smallJsont* injectBoolSmallJson(smallJsont *self, intmax_t index, bool 
   return(self);
 }
 
-internal smallJsont* injectDoubleSmallJson(smallJsont *self, intmax_t index, double toInject) {
+internal smallJsont* injectDoubleSmallJson(smallJsont *self, int64_t index, double toInject) {
   size_t len;
 
   if (self->topIsA != SMALLJSON_IS_EMPTY && self->topIsA != TOP_IS_ARRAY) {
@@ -10756,13 +10755,13 @@ internal smallJsont* injectDoubleSmallJson(smallJsont *self, intmax_t index, dou
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -10785,7 +10784,7 @@ internal smallJsont* injectDoubleSmallJson(smallJsont *self, intmax_t index, dou
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10793,12 +10792,12 @@ internal smallJsont* injectDoubleSmallJson(smallJsont *self, intmax_t index, dou
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10809,7 +10808,7 @@ internal smallJsont* injectDoubleSmallJson(smallJsont *self, intmax_t index, dou
   return(self);
 }
 
-internal smallJsont* injectIntSmallJson(smallJsont *self, intmax_t index, int64_t toInject) {
+internal smallJsont* injectIntSmallJson(smallJsont *self, int64_t index, int64_t toInject) {
   size_t len;
 
   if (self->topIsA != SMALLJSON_IS_EMPTY && self->topIsA != TOP_IS_ARRAY) {
@@ -10831,13 +10830,13 @@ internal smallJsont* injectIntSmallJson(smallJsont *self, intmax_t index, int64_
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -10860,7 +10859,7 @@ internal smallJsont* injectIntSmallJson(smallJsont *self, intmax_t index, int64_
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10868,12 +10867,12 @@ internal smallJsont* injectIntSmallJson(smallJsont *self, intmax_t index, int64_
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10884,7 +10883,7 @@ internal smallJsont* injectIntSmallJson(smallJsont *self, intmax_t index, int64_
   return(self);
 }
 
-internal smallJsont* injectSSmallJson(smallJsont *self, intmax_t index, const char *toInject) {
+internal smallJsont* injectSSmallJson(smallJsont *self, int64_t index, const char *toInject) {
   size_t len;
 
   if (!toInject) {
@@ -10914,13 +10913,13 @@ internal smallJsont* injectSSmallJson(smallJsont *self, intmax_t index, const ch
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -10942,7 +10941,7 @@ internal smallJsont* injectSSmallJson(smallJsont *self, intmax_t index, const ch
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10950,12 +10949,12 @@ internal smallJsont* injectSSmallJson(smallJsont *self, intmax_t index, const ch
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -10966,13 +10965,13 @@ internal smallJsont* injectSSmallJson(smallJsont *self, intmax_t index, const ch
   return(self);
 }
 
-internal smallJsont* injectCharSmallJson(smallJsont *self, intmax_t index, char c) {
+internal smallJsont* injectCharSmallJson(smallJsont *self, int64_t index, char c) {
 
   charToS(s, c);
   return(injectSSmallJson(self, index, s));
 }
 
-internal smallJsont* injectDictSmallJson(smallJsont *self, intmax_t index, smallDictt *toInject) {
+internal smallJsont* injectDictSmallJson(smallJsont *self, int64_t index, smallDictt *toInject) {
   size_t len;
 
   if (!toInject) {
@@ -11002,13 +11001,13 @@ internal smallJsont* injectDictSmallJson(smallJsont *self, intmax_t index, small
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -11030,7 +11029,7 @@ internal smallJsont* injectDictSmallJson(smallJsont *self, intmax_t index, small
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -11038,12 +11037,12 @@ internal smallJsont* injectDictSmallJson(smallJsont *self, intmax_t index, small
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -11054,7 +11053,7 @@ internal smallJsont* injectDictSmallJson(smallJsont *self, intmax_t index, small
   return(self);
 }
 
-internal smallJsont* injectArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *toInject) {
+internal smallJsont* injectArraySmallJson(smallJsont *self, int64_t index, smallArrayt *toInject) {
   size_t len;
 
   if (!toInject) {
@@ -11084,13 +11083,13 @@ internal smallJsont* injectArraySmallJson(smallJsont *self, intmax_t index, smal
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -11112,7 +11111,7 @@ internal smallJsont* injectArraySmallJson(smallJsont *self, intmax_t index, smal
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -11120,12 +11119,12 @@ internal smallJsont* injectArraySmallJson(smallJsont *self, intmax_t index, smal
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -11136,7 +11135,7 @@ internal smallJsont* injectArraySmallJson(smallJsont *self, intmax_t index, smal
   return(self);
 }
 
-internal smallJsont* injectArraycSmallJson(smallJsont *self, intmax_t index, char **toInject) {
+internal smallJsont* injectArraycSmallJson(smallJsont *self, int64_t index, char **toInject) {
   size_t len;
 
   if (!toInject) {
@@ -11162,13 +11161,13 @@ internal smallJsont* injectArraycSmallJson(smallJsont *self, intmax_t index, cha
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -11204,7 +11203,7 @@ internal smallJsont* injectArraycSmallJson(smallJsont *self, intmax_t index, cha
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -11212,12 +11211,12 @@ internal smallJsont* injectArraycSmallJson(smallJsont *self, intmax_t index, cha
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -11228,7 +11227,7 @@ internal smallJsont* injectArraycSmallJson(smallJsont *self, intmax_t index, cha
   return(self);
 }
 
-internal smallJsont* injectSmallBoolSmallJson(smallJsont *self, intmax_t index, smallBoolt *toInject) {
+internal smallJsont* injectSmallBoolSmallJson(smallJsont *self, int64_t index, smallBoolt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11245,7 +11244,7 @@ internal smallJsont* injectSmallBoolSmallJson(smallJsont *self, intmax_t index, 
   return(injectSmallJson(self, index, (baset*)toInject));
 }
 
-internal smallJsont* injectSmallBytesSmallJson(smallJsont *self, intmax_t index, smallBytest *toInject) {
+internal smallJsont* injectSmallBytesSmallJson(smallJsont *self, int64_t index, smallBytest *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11262,7 +11261,7 @@ internal smallJsont* injectSmallBytesSmallJson(smallJsont *self, intmax_t index,
   return(injectSmallJson(self, index, (baset*)toInject));
 }
 
-internal smallJsont* injectSmallDoubleSmallJson(smallJsont *self, intmax_t index, smallDoublet *toInject) {
+internal smallJsont* injectSmallDoubleSmallJson(smallJsont *self, int64_t index, smallDoublet *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11279,7 +11278,7 @@ internal smallJsont* injectSmallDoubleSmallJson(smallJsont *self, intmax_t index
   return(injectSmallJson(self, index, (baset*)toInject));
 }
 
-internal smallJsont* injectSmallIntSmallJson(smallJsont *self, intmax_t index, smallIntt *toInject) {
+internal smallJsont* injectSmallIntSmallJson(smallJsont *self, int64_t index, smallIntt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11296,7 +11295,7 @@ internal smallJsont* injectSmallIntSmallJson(smallJsont *self, intmax_t index, s
   return(injectSmallJson(self, index, (baset*)toInject));
 }
 
-internal smallJsont* injectSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *toInject) {
+internal smallJsont* injectSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11320,7 +11319,7 @@ internal smallJsont* injectSmallJsonSmallJson(smallJsont *self, intmax_t index, 
   return(r);
 }
 
-internal smallJsont* injectSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *toInject) {
+internal smallJsont* injectSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11341,7 +11340,7 @@ internal smallJsont* injectSmallStringSmallJson(smallJsont *self, intmax_t index
   return(injectSmallJson(self, index, (baset*)toInject));
 }
 
-internal smallJsont* injectSmallContainerSmallJson(smallJsont *self, intmax_t index, smallContainert *toInject) {
+internal smallJsont* injectSmallContainerSmallJson(smallJsont *self, int64_t index, smallContainert *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11358,7 +11357,7 @@ internal smallJsont* injectSmallContainerSmallJson(smallJsont *self, intmax_t in
   return(injectSmallJson(self, index, (baset*)toInject));
 }
 
-internal smallJsont* injectNFreeSmallJson(smallJsont *self, intmax_t index, baset *toInject) {
+internal smallJsont* injectNFreeSmallJson(smallJsont *self, int64_t index, baset *toInject) {
   size_t len;
 
   if (!toInject) {
@@ -11384,13 +11383,13 @@ internal smallJsont* injectNFreeSmallJson(smallJsont *self, intmax_t index, base
     neg = true;
   }
 
-  if (index > (intmax_t)len) {
+  if (index > (int64_t)len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (neg) {
@@ -11416,7 +11415,7 @@ internal smallJsont* injectNFreeSmallJson(smallJsont *self, intmax_t index, base
   if (index == 0) {
     // inject at beginning
     sArrayPushTiny(&a, o);
-    for (intmax_t i=0;i < (intmax_t)len;i++) {
+    for (int64_t i=0;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -11424,12 +11423,12 @@ internal smallJsont* injectNFreeSmallJson(smallJsont *self, intmax_t index, base
   else {
 
     smallt *o2;
-    for (intmax_t i=0;i < index;i++) {
+    for (int64_t i=0;i < index;i++) {
       o2 = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o2);
     }
     sArrayPushTiny(&a, o);
-    for (intmax_t i=index;i < (intmax_t)len;i++) {
+    for (int64_t i=index;i < (int64_t)len;i++) {
       o = sArrayGetTiny(self->topA, i);
       sArrayPushTiny(&a, o);
   }
@@ -11440,7 +11439,7 @@ internal smallJsont* injectNFreeSmallJson(smallJsont *self, intmax_t index, base
   return(self);
 }
 
-internal smallJsont* injectNFreeUndefinedSmallJson(smallJsont *self, intmax_t index, undefinedt *undefined) {
+internal smallJsont* injectNFreeUndefinedSmallJson(smallJsont *self, int64_t index, undefinedt *undefined) {
 
   smallJsont *r = injectUndefinedSmallJson(self, index);;
   if (r) {
@@ -11449,7 +11448,7 @@ internal smallJsont* injectNFreeUndefinedSmallJson(smallJsont *self, intmax_t in
   return(r);
 }
 
-internal smallJsont* injectNFreeSSmallJson(smallJsont *self, intmax_t index, char *toInject) {
+internal smallJsont* injectNFreeSSmallJson(smallJsont *self, int64_t index, char *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11462,7 +11461,7 @@ internal smallJsont* injectNFreeSSmallJson(smallJsont *self, intmax_t index, cha
   return(r);
 }
 
-internal smallJsont* injectNFreeDictSmallJson(smallJsont *self, intmax_t index, smallDictt *toInject) {
+internal smallJsont* injectNFreeDictSmallJson(smallJsont *self, int64_t index, smallDictt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11475,7 +11474,7 @@ internal smallJsont* injectNFreeDictSmallJson(smallJsont *self, intmax_t index, 
   return(r);
 }
 
-internal smallJsont* injectNFreeArraySmallJson(smallJsont *self, intmax_t index, smallArrayt *toInject) {
+internal smallJsont* injectNFreeArraySmallJson(smallJsont *self, int64_t index, smallArrayt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11488,7 +11487,7 @@ internal smallJsont* injectNFreeArraySmallJson(smallJsont *self, intmax_t index,
   return(r);
 }
 
-internal smallJsont* injectNFreeArraycSmallJson(smallJsont *self, intmax_t index, char **toInject) {
+internal smallJsont* injectNFreeArraycSmallJson(smallJsont *self, int64_t index, char **toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11501,7 +11500,7 @@ internal smallJsont* injectNFreeArraycSmallJson(smallJsont *self, intmax_t index
   return(r);
 }
 
-internal smallJsont* injectNFreeSmallBoolSmallJson(smallJsont *self, intmax_t index, smallBoolt *toInject) {
+internal smallJsont* injectNFreeSmallBoolSmallJson(smallJsont *self, int64_t index, smallBoolt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11514,7 +11513,7 @@ internal smallJsont* injectNFreeSmallBoolSmallJson(smallJsont *self, intmax_t in
   return(r);
 }
 
-internal smallJsont* injectNFreeSmallBytesSmallJson(smallJsont *self, intmax_t index, smallBytest *toInject) {
+internal smallJsont* injectNFreeSmallBytesSmallJson(smallJsont *self, int64_t index, smallBytest *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11527,7 +11526,7 @@ internal smallJsont* injectNFreeSmallBytesSmallJson(smallJsont *self, intmax_t i
   return(r);
 }
 
-internal smallJsont* injectNFreeSmallDoubleSmallJson(smallJsont *self, intmax_t index, smallDoublet *toInject) {
+internal smallJsont* injectNFreeSmallDoubleSmallJson(smallJsont *self, int64_t index, smallDoublet *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11540,7 +11539,7 @@ internal smallJsont* injectNFreeSmallDoubleSmallJson(smallJsont *self, intmax_t 
   return(r);
 }
 
-internal smallJsont* injectNFreeSmallIntSmallJson(smallJsont *self, intmax_t index, smallIntt *toInject) {
+internal smallJsont* injectNFreeSmallIntSmallJson(smallJsont *self, int64_t index, smallIntt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11553,7 +11552,7 @@ internal smallJsont* injectNFreeSmallIntSmallJson(smallJsont *self, intmax_t ind
   return(r);
 }
 
-internal smallJsont* injectNFreeSmallJsonSmallJson(smallJsont *self, intmax_t index, smallJsont *toInject) {
+internal smallJsont* injectNFreeSmallJsonSmallJson(smallJsont *self, int64_t index, smallJsont *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11566,7 +11565,7 @@ internal smallJsont* injectNFreeSmallJsonSmallJson(smallJsont *self, intmax_t in
   return(r);
 }
 
-internal smallJsont* injectNFreeSmallStringSmallJson(smallJsont *self, intmax_t index, smallStringt *toInject) {
+internal smallJsont* injectNFreeSmallStringSmallJson(smallJsont *self, int64_t index, smallStringt *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -11579,7 +11578,7 @@ internal smallJsont* injectNFreeSmallStringSmallJson(smallJsont *self, intmax_t 
   return(r);
 }
 
-internal smallJsont* injectNFreeSmallContainerSmallJson(smallJsont *self, intmax_t index, smallContainert *toInject) {
+internal smallJsont* injectNFreeSmallContainerSmallJson(smallJsont *self, int64_t index, smallContainert *toInject) {
 
   if (!toInject) {
     return(NULL);
@@ -16934,23 +16933,23 @@ internal bool icEqualCharSmallJson(smallJsont *self, char c) {
   return(false);
 }
 
-internal bool equalISSmallJson(smallJsont *self, const char *string, intmax_t index) {
+internal bool equalISSmallJson(smallJsont *self, const char *string, int64_t index) {
 
   if (self->topIsA != TOP_IS_STRING || !self->topS || !string) {
     return(false);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self) && lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self) && lenSmallJson(self)) {
     return(false);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(false);
   }
   if (index < 0) {
-    index = (intmax_t)lenSmallJson(self) + index;
+    index = (int64_t)lenSmallJson(self) + index;
   }
 
-  if (index > (intmax_t)(lenSmallJson(self) - strlen(string))) {
+  if (index > (int64_t)(lenSmallJson(self) - strlen(string))) {
     return(false);
   }
 
@@ -16965,13 +16964,13 @@ internal bool equalISSmallJson(smallJsont *self, const char *string, intmax_t in
   return(strncmp(sStringGetTiny(self->topS) + index, string, strlen(string)) == 0);;
 }
 
-internal bool equalICharSmallJson(smallJsont *self, char c, intmax_t index) {
+internal bool equalICharSmallJson(smallJsont *self, char c, int64_t index) {
 
   charToS(s, c);
   return(equalISSmallJson(self, s, index));
 }
 
-internal bool equalIJsonSmallJson(smallJsont *self, smallJsont *string, intmax_t index) {
+internal bool equalIJsonSmallJson(smallJsont *self, smallJsont *string, int64_t index) {
 
   if (!string) {
     return(false);
@@ -16988,7 +16987,7 @@ internal bool equalIJsonSmallJson(smallJsont *self, smallJsont *string, intmax_t
   return(equalISSmallJson(self, sjGet(string), index));
 }
 
-internal bool equalISmallStringSmallJson(smallJsont *self, smallStringt *string, intmax_t index) {
+internal bool equalISmallStringSmallJson(smallJsont *self, smallStringt *string, int64_t index) {
 
   if (!string) {
     return(false);
@@ -17416,7 +17415,7 @@ internal bool isIntSmallJson(smallJsont *self) {
 }
 
 
-internal intmax_t parseIntSmallJson(smallJsont *self) {
+internal int64_t parseIntSmallJson(smallJsont *self) {
 
   if (self->topIsA != TOP_IS_STRING || !lenSmallJson(self)) {
     return(0);
@@ -17426,8 +17425,8 @@ internal intmax_t parseIntSmallJson(smallJsont *self) {
   while (!isdigit(*string) && *string != '-' && *string != 0) {
     string++;
   }
-  intmax_t r = strtoimax(string, NULL, 10);
-  if (r == INTMAX_MAX || r == INTMAX_MIN) {
+  int64_t r = strtoll(string, NULL, 10);
+  if (r == INT64_MAX || r == INT64_MIN) {
     pStrError("parseInt error");
   }
   return(r);
@@ -17447,7 +17446,7 @@ internal double parseDoubleSmallJson(smallJsont *self) {
   return(r);
 }
 
-internal smallJsont* intToSmallJson(smallJsont *self, intmax_t n) {
+internal smallJsont* intToSmallJson(smallJsont *self, int64_t n) {
   char s[50];
 
   sprintf(s, "%" PRIiMAX, n);
@@ -20149,7 +20148,7 @@ internal baset* iterStartLastSmallJson(smallJsont *self) {
   return(self->iterElement);
 }
 
-internal baset* iterStartFromSmallJson(smallJsont *self, intmax_t index) {
+internal baset* iterStartFromSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -20162,10 +20161,10 @@ internal baset* iterStartFromSmallJson(smallJsont *self, intmax_t index) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -20199,7 +20198,7 @@ internal baset* iterStartFromSmallJson(smallJsont *self, intmax_t index) {
   return(self->iterElement);
 }
 
-internal baset* iterStartFromStepSmallJson(smallJsont *self, intmax_t index, intmax_t step) {
+internal baset* iterStartFromStepSmallJson(smallJsont *self, int64_t index, int64_t step) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
@@ -20217,10 +20216,10 @@ internal baset* iterStartFromStepSmallJson(smallJsont *self, intmax_t index, int
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -20394,7 +20393,7 @@ internal ssize_t iterIndexSmallJson(smallJsont *self) {
   return(self->iterIndex);
 }
 
-internal intmax_t iterStepSmallJson(smallJsont *self) {
+internal int64_t iterStepSmallJson(smallJsont *self) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(-1);
@@ -21057,16 +21056,16 @@ internal smallContainert* getNDupSmallContainerSmallJson(smallJsont *self, const
   return(NULL);
 }
 
-baset* getAtSmallJson(smallJsont *self, intmax_t index) {
+baset* getAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21082,16 +21081,16 @@ baset* getAtSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal undefinedt* getAtUndefinedSmallJson(smallJsont *self, intmax_t index) {
+internal undefinedt* getAtUndefinedSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21108,7 +21107,7 @@ internal undefinedt* getAtUndefinedSmallJson(smallJsont *self, intmax_t index) {
   return(allocUndefined());
 }
 
-internal bool getAtBoolSmallJson(smallJsont *self, intmax_t index) {
+internal bool getAtBoolSmallJson(smallJsont *self, int64_t index) {
   smallBoolt *e = NULL;
   bool r = false;;
 
@@ -21120,7 +21119,7 @@ internal bool getAtBoolSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal bool* getAtBoolPSmallJson(smallJsont *self, intmax_t index) {
+internal bool* getAtBoolPSmallJson(smallJsont *self, int64_t index) {
   smallBoolt *e = NULL;
   bool* r = NULL;
 
@@ -21132,7 +21131,7 @@ internal bool* getAtBoolPSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal double getAtDoubleSmallJson(smallJsont *self, intmax_t index) {
+internal double getAtDoubleSmallJson(smallJsont *self, int64_t index) {
   smallDoublet *e = NULL;
   double r = 0;;
 
@@ -21144,7 +21143,7 @@ internal double getAtDoubleSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal double* getAtDoublePSmallJson(smallJsont *self, intmax_t index) {
+internal double* getAtDoublePSmallJson(smallJsont *self, int64_t index) {
   smallDoublet *e = NULL;
   double* r = NULL;
 
@@ -21156,7 +21155,7 @@ internal double* getAtDoublePSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal int64_t getAtIntSmallJson(smallJsont *self, intmax_t index) {
+internal int64_t getAtIntSmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   int64_t r = 0;;
 
@@ -21168,7 +21167,7 @@ internal int64_t getAtIntSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal int64_t* getAtIntPSmallJson(smallJsont *self, intmax_t index) {
+internal int64_t* getAtIntPSmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   int64_t* r = NULL;
 
@@ -21180,7 +21179,7 @@ internal int64_t* getAtIntPSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal int32_t getAtInt32SmallJson(smallJsont *self, intmax_t index) {
+internal int32_t getAtInt32SmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   int32_t r = 0;;
 
@@ -21192,7 +21191,7 @@ internal int32_t getAtInt32SmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal int32_t* getAtInt32PSmallJson(smallJsont *self, intmax_t index) {
+internal int32_t* getAtInt32PSmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   int32_t* r = NULL;
 
@@ -21204,7 +21203,7 @@ internal int32_t* getAtInt32PSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal uint64_t getAtUintSmallJson(smallJsont *self, intmax_t index) {
+internal uint64_t getAtUintSmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   uint64_t r = 0;;
 
@@ -21216,7 +21215,7 @@ internal uint64_t getAtUintSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal uint64_t* getAtUintPSmallJson(smallJsont *self, intmax_t index) {
+internal uint64_t* getAtUintPSmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   uint64_t* r = NULL;
 
@@ -21228,7 +21227,7 @@ internal uint64_t* getAtUintPSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal uint32_t getAtUint32SmallJson(smallJsont *self, intmax_t index) {
+internal uint32_t getAtUint32SmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   uint32_t r = 0;;
 
@@ -21240,7 +21239,7 @@ internal uint32_t getAtUint32SmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal uint32_t* getAtUint32PSmallJson(smallJsont *self, intmax_t index) {
+internal uint32_t* getAtUint32PSmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   uint32_t* r = NULL;
 
@@ -21252,7 +21251,7 @@ internal uint32_t* getAtUint32PSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal char* getAtSSmallJson(smallJsont *self, intmax_t index) {
+internal char* getAtSSmallJson(smallJsont *self, int64_t index) {
   smallStringt *e = NULL;
   char* r = NULL;
 
@@ -21264,16 +21263,16 @@ internal char* getAtSSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal smallDictt* getAtDictSmallJson(smallJsont *self, intmax_t index) {
+internal smallDictt* getAtDictSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21290,16 +21289,16 @@ internal smallDictt* getAtDictSmallJson(smallJsont *self, intmax_t index) {
   return((smallDictt*) toBaset(o));
 }
 
-internal smallArrayt* getAtArraySmallJson(smallJsont *self, intmax_t index) {
+internal smallArrayt* getAtArraySmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21316,16 +21315,16 @@ internal smallArrayt* getAtArraySmallJson(smallJsont *self, intmax_t index) {
   return((smallArrayt*) toBaset(o));
 }
 
-internal smallBoolt* getAtSmallBoolSmallJson(smallJsont *self, intmax_t index) {
+internal smallBoolt* getAtSmallBoolSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21342,16 +21341,16 @@ internal smallBoolt* getAtSmallBoolSmallJson(smallJsont *self, intmax_t index) {
   return((smallBoolt*) toBaset(o));
 }
 
-internal smallBytest* getAtSmallBytesSmallJson(smallJsont *self, intmax_t index) {
+internal smallBytest* getAtSmallBytesSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21368,16 +21367,16 @@ internal smallBytest* getAtSmallBytesSmallJson(smallJsont *self, intmax_t index)
   return((smallBytest*) toBaset(o));
 }
 
-internal smallDoublet* getAtSmallDoubleSmallJson(smallJsont *self, intmax_t index) {
+internal smallDoublet* getAtSmallDoubleSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21394,16 +21393,16 @@ internal smallDoublet* getAtSmallDoubleSmallJson(smallJsont *self, intmax_t inde
   return((smallDoublet*) toBaset(o));
 }
 
-internal smallIntt* getAtSmallIntSmallJson(smallJsont *self, intmax_t index) {
+internal smallIntt* getAtSmallIntSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21420,16 +21419,16 @@ internal smallIntt* getAtSmallIntSmallJson(smallJsont *self, intmax_t index) {
   return((smallIntt*) toBaset(o));
 }
 
-internal smallJsont* getAtSmallJsonSmallJson(smallJsont *self, intmax_t index) {
+internal smallJsont* getAtSmallJsonSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21454,16 +21453,16 @@ internal smallJsont* getAtSmallJsonSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal smallStringt* getAtSmallStringSmallJson(smallJsont *self, intmax_t index) {
+internal smallStringt* getAtSmallStringSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21480,7 +21479,7 @@ internal smallStringt* getAtSmallStringSmallJson(smallJsont *self, intmax_t inde
   return((smallStringt*) toBaset(o));
 }
 
-internal void* getAtVoidSmallJson(smallJsont *self, intmax_t index) {
+internal void* getAtVoidSmallJson(smallJsont *self, int64_t index) {
   smallContainert *e = NULL;
   void* r = NULL;
 
@@ -21492,16 +21491,16 @@ internal void* getAtVoidSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal smallContainert* getAtSmallContainerSmallJson(smallJsont *self, intmax_t index) {
+internal smallContainert* getAtSmallContainerSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21521,16 +21520,16 @@ internal smallContainert* getAtSmallContainerSmallJson(smallJsont *self, intmax_
   return((smallContainert*) toBaset(o));
 }
 
-baset* getAtNDupSmallJson(smallJsont *self, intmax_t index) {
+baset* getAtNDupSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21553,16 +21552,16 @@ baset* getAtNDupSmallJson(smallJsont *self, intmax_t index) {
   return(toBaset(sDuplicate(o)));
 }
 
-internal undefinedt* getAtNDupUndefinedSmallJson(smallJsont *self, intmax_t index) {
+internal undefinedt* getAtNDupUndefinedSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21579,7 +21578,7 @@ internal undefinedt* getAtNDupUndefinedSmallJson(smallJsont *self, intmax_t inde
   return(allocUndefined());
 }
 
-internal bool getAtNDupBoolSmallJson(smallJsont *self, intmax_t index) {
+internal bool getAtNDupBoolSmallJson(smallJsont *self, int64_t index) {
   smallBoolt *e = NULL;
   bool r = false;;
 
@@ -21591,7 +21590,7 @@ internal bool getAtNDupBoolSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal double getAtNDupDoubleSmallJson(smallJsont *self, intmax_t index) {
+internal double getAtNDupDoubleSmallJson(smallJsont *self, int64_t index) {
   smallDoublet *e = NULL;
   double r = 0;;
 
@@ -21603,7 +21602,7 @@ internal double getAtNDupDoubleSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal int64_t getAtNDupIntSmallJson(smallJsont *self, intmax_t index) {
+internal int64_t getAtNDupIntSmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   int64_t r = 0;;
 
@@ -21615,7 +21614,7 @@ internal int64_t getAtNDupIntSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal int32_t getAtNDupInt32SmallJson(smallJsont *self, intmax_t index) {
+internal int32_t getAtNDupInt32SmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   int32_t r = 0;;
 
@@ -21627,7 +21626,7 @@ internal int32_t getAtNDupInt32SmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal uint64_t getAtNDupUintSmallJson(smallJsont *self, intmax_t index) {
+internal uint64_t getAtNDupUintSmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   uint64_t r = 0;;
 
@@ -21639,7 +21638,7 @@ internal uint64_t getAtNDupUintSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal uint32_t getAtNDupUint32SmallJson(smallJsont *self, intmax_t index) {
+internal uint32_t getAtNDupUint32SmallJson(smallJsont *self, int64_t index) {
   smallIntt *e = NULL;
   uint32_t r = 0;;
 
@@ -21651,7 +21650,7 @@ internal uint32_t getAtNDupUint32SmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal char* getAtNDupSSmallJson(smallJsont *self, intmax_t index) {
+internal char* getAtNDupSSmallJson(smallJsont *self, int64_t index) {
   smallStringt *e = NULL;
   char* r = NULL;
 
@@ -21663,16 +21662,16 @@ internal char* getAtNDupSSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal smallDictt* getAtNDupDictSmallJson(smallJsont *self, intmax_t index) {
+internal smallDictt* getAtNDupDictSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21689,16 +21688,16 @@ internal smallDictt* getAtNDupDictSmallJson(smallJsont *self, intmax_t index) {
   return((smallDictt*)toBaset(sDuplicate(o)));
 }
 
-internal smallArrayt* getAtNDupArraySmallJson(smallJsont *self, intmax_t index) {
+internal smallArrayt* getAtNDupArraySmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21715,16 +21714,16 @@ internal smallArrayt* getAtNDupArraySmallJson(smallJsont *self, intmax_t index) 
   return((smallArrayt*)toBaset(sDuplicate(o)));
 }
 
-internal smallBoolt* getAtNDupSmallBoolSmallJson(smallJsont *self, intmax_t index) {
+internal smallBoolt* getAtNDupSmallBoolSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21741,16 +21740,16 @@ internal smallBoolt* getAtNDupSmallBoolSmallJson(smallJsont *self, intmax_t inde
   return((smallBoolt*)toBaset(sDuplicate(o)));
 }
 
-internal smallBytest* getAtNDupSmallBytesSmallJson(smallJsont *self, intmax_t index) {
+internal smallBytest* getAtNDupSmallBytesSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21767,16 +21766,16 @@ internal smallBytest* getAtNDupSmallBytesSmallJson(smallJsont *self, intmax_t in
   return((smallBytest*)toBaset(sDuplicate(o)));
 }
 
-internal smallDoublet* getAtNDupSmallDoubleSmallJson(smallJsont *self, intmax_t index) {
+internal smallDoublet* getAtNDupSmallDoubleSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21793,16 +21792,16 @@ internal smallDoublet* getAtNDupSmallDoubleSmallJson(smallJsont *self, intmax_t 
   return((smallDoublet*)toBaset(sDuplicate(o)));
 }
 
-internal smallIntt* getAtNDupSmallIntSmallJson(smallJsont *self, intmax_t index) {
+internal smallIntt* getAtNDupSmallIntSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21819,16 +21818,16 @@ internal smallIntt* getAtNDupSmallIntSmallJson(smallJsont *self, intmax_t index)
   return((smallIntt*)toBaset(sDuplicate(o)));
 }
 
-internal smallJsont* getAtNDupSmallJsonSmallJson(smallJsont *self, intmax_t index) {
+internal smallJsont* getAtNDupSmallJsonSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21854,16 +21853,16 @@ internal smallJsont* getAtNDupSmallJsonSmallJson(smallJsont *self, intmax_t inde
   return(r);
 }
 
-internal smallStringt* getAtNDupSmallStringSmallJson(smallJsont *self, intmax_t index) {
+internal smallStringt* getAtNDupSmallStringSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21880,7 +21879,7 @@ internal smallStringt* getAtNDupSmallStringSmallJson(smallJsont *self, intmax_t 
   return((smallStringt*)toBaset(sDuplicate(o)));
 }
 
-internal void* getAtNDupVoidSmallJson(smallJsont *self, intmax_t index) {
+internal void* getAtNDupVoidSmallJson(smallJsont *self, int64_t index) {
   smallContainert *e = NULL;
   void* r = NULL;
 
@@ -21892,16 +21891,16 @@ internal void* getAtNDupVoidSmallJson(smallJsont *self, intmax_t index) {
   return(r);
 }
 
-internal smallContainert* getAtNDupSmallContainerSmallJson(smallJsont *self, intmax_t index) {
+internal smallContainert* getAtNDupSmallContainerSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(NULL);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(NULL);
   }
   if (index < 0) {
@@ -21951,16 +21950,16 @@ internal double getNumSmallJson(smallJsont *self, const char *key) {
   return(0);
 }
 
-internal double getNumAtSmallJson(smallJsont *self, intmax_t index) {
+internal double getNumAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(0);
   }
 
-  if (index >= (intmax_t)lenSmallJson(self)) {
+  if (index >= (int64_t)lenSmallJson(self)) {
     return(0);
   }
-  if (index < -(intmax_t)lenSmallJson(self)) {
+  if (index < -(int64_t)lenSmallJson(self)) {
     return(0);
   }
   if (index < 0) {
@@ -21995,7 +21994,7 @@ internal smallJsont* delElemSmallJson(smallJsont *self, const char *key) {
   return(self);
 }
 
-internal smallJsont* delSmallJson(smallJsont *self, intmax_t start, intmax_t end) {
+internal smallJsont* delSmallJson(smallJsont *self, int64_t start, int64_t end) {
   size_t len;
 
   switch(self->topIsA) {
@@ -22009,16 +22008,16 @@ internal smallJsont* delSmallJson(smallJsont *self, intmax_t start, intmax_t end
         return(NULL);
       }
 
-      if (start >= (intmax_t)len) {
+      if (start >= (int64_t)len) {
         start = len;
       }
-      if (end > (intmax_t)len) {
+      if (end > (int64_t)len) {
         end = len;
       }
-      if (start <= -(intmax_t)len) {
+      if (start <= -(int64_t)len) {
         start = -len;
       }
-      if (end <= -(intmax_t)len) {
+      if (end <= -(int64_t)len) {
         end = -len;
       }
       if (start < 0) {
@@ -22037,7 +22036,7 @@ internal smallJsont* delSmallJson(smallJsont *self, intmax_t start, intmax_t end
 
       // start < end < len
       // copy range to a new smallString
-      intmax_t n;
+      int64_t n;
       n = end - start;
       // +2 for sType at the beginning
       s = malloc(len - n +2);
@@ -22060,16 +22059,16 @@ internal smallJsont* delSmallJson(smallJsont *self, intmax_t start, intmax_t end
         return(NULL);
       }
 
-      if (start >= (intmax_t)len) {
+      if (start >= (int64_t)len) {
         start = len;
       }
-      if (end > (intmax_t)len) {
+      if (end > (int64_t)len) {
         end = len;
       }
-      if (start <= -(intmax_t)len) {
+      if (start <= -(int64_t)len) {
         start = -len;
       }
-      if (end <= -(intmax_t)len) {
+      if (end <= -(int64_t)len) {
         end = -len;
       }
       if (start < 0) {
@@ -22094,7 +22093,7 @@ internal smallJsont* delSmallJson(smallJsont *self, intmax_t start, intmax_t end
   }
 }
 
-internal smallJsont* delElemIndexSmallJson(smallJsont *self, intmax_t index) {
+internal smallJsont* delElemIndexSmallJson(smallJsont *self, int64_t index) {
   size_t len;
 
   switch(self->topIsA) {
@@ -22103,10 +22102,10 @@ internal smallJsont* delElemIndexSmallJson(smallJsont *self, intmax_t index) {
 
       len = lenSmallJson(self);
 
-      if (index >= (intmax_t)len) {
+      if (index >= (int64_t)len) {
         return(NULL);
       }
-      if (index < -(intmax_t)len) {
+      if (index < -(int64_t)len) {
         return(NULL);
       }
       if (index < 0) {
@@ -22130,10 +22129,10 @@ internal smallJsont* delElemIndexSmallJson(smallJsont *self, intmax_t index) {
     case TOP_IS_ARRAY:
       len = lenSmallJson(self);
 
-      if (index >= (intmax_t)len) {
+      if (index >= (int64_t)len) {
         return(NULL);
       }
-      if (index < -(intmax_t)len) {
+      if (index < -(int64_t)len) {
         return(NULL);
       }
       if (index < 0) {
@@ -22153,7 +22152,7 @@ internal smallJsont* removeElemSmallJson(smallJsont *self, const char *key) {
   return(self);
 }
 
-internal smallJsont* removeSmallJson(smallJsont *self, intmax_t start, intmax_t end) {
+internal smallJsont* removeSmallJson(smallJsont *self, int64_t start, int64_t end) {
   size_t len;
 
   switch(self->topIsA) {
@@ -22167,16 +22166,16 @@ internal smallJsont* removeSmallJson(smallJsont *self, intmax_t start, intmax_t 
         return(NULL);
       }
 
-      if (start >= (intmax_t)len) {
+      if (start >= (int64_t)len) {
         start = len;
       }
-      if (end > (intmax_t)len) {
+      if (end > (int64_t)len) {
         end = len;
       }
-      if (start <= -(intmax_t)len) {
+      if (start <= -(int64_t)len) {
         start = -len;
       }
-      if (end <= -(intmax_t)len) {
+      if (end <= -(int64_t)len) {
         end = -len;
       }
       if (start < 0) {
@@ -22195,7 +22194,7 @@ internal smallJsont* removeSmallJson(smallJsont *self, intmax_t start, intmax_t 
 
       // start < end < len
       // copy range to a new smallString
-      intmax_t n;
+      int64_t n;
       n = end - start;
       // +2 for sType at the beginning
       s = malloc(len - n +2);
@@ -22218,16 +22217,16 @@ internal smallJsont* removeSmallJson(smallJsont *self, intmax_t start, intmax_t 
         return(NULL);
       }
 
-      if (start >= (intmax_t)len) {
+      if (start >= (int64_t)len) {
         start = len;
       }
-      if (end > (intmax_t)len) {
+      if (end > (int64_t)len) {
         end = len;
       }
-      if (start <= -(intmax_t)len) {
+      if (start <= -(int64_t)len) {
         start = -len;
       }
-      if (end <= -(intmax_t)len) {
+      if (end <= -(int64_t)len) {
         end = -len;
       }
       if (start < 0) {
@@ -22254,7 +22253,7 @@ internal smallJsont* removeSmallJson(smallJsont *self, intmax_t start, intmax_t 
   }
 }
 
-internal smallJsont* removeElemIndexSmallJson(smallJsont *self, intmax_t index) {
+internal smallJsont* removeElemIndexSmallJson(smallJsont *self, int64_t index) {
   size_t len;
 
   switch(self->topIsA) {
@@ -22263,10 +22262,10 @@ internal smallJsont* removeElemIndexSmallJson(smallJsont *self, intmax_t index) 
 
       len = lenSmallJson(self);
 
-      if (index >= (intmax_t)len) {
+      if (index >= (int64_t)len) {
         return(NULL);
       }
-      if (index < -(intmax_t)len) {
+      if (index < -(int64_t)len) {
         return(NULL);
       }
       if (index < 0) {
@@ -22290,10 +22289,10 @@ internal smallJsont* removeElemIndexSmallJson(smallJsont *self, intmax_t index) 
     case TOP_IS_ARRAY:
       len = lenSmallJson(self);
 
-      if (index >= (intmax_t)len) {
+      if (index >= (int64_t)len) {
         return(NULL);
       }
-      if (index < -(intmax_t)len) {
+      if (index < -(int64_t)len) {
         return(NULL);
       }
       if (index < 0) {
@@ -24087,12 +24086,12 @@ internal smallStringt* typeSmallStringSmallJson(smallJsont *self, const char *ke
   return(allocSmallString(r));
 }
 
-internal const char* typeAtStringSmallJson(smallJsont *self, intmax_t index) {
+internal const char* typeAtStringSmallJson(smallJsont *self, int64_t index) {
 
   return(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)]);
 }
 
-internal smallStringt* typeAtSmallStringSmallJson(smallJsont *self, intmax_t index) {
+internal smallStringt* typeAtSmallStringSmallJson(smallJsont *self, int64_t index) {
 
   return(allocSmallString(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)]));
 }
@@ -24128,7 +24127,7 @@ internal char typeKCharSmallJson(smallJsont *self, char key) {
   return(typeSmallJson(self, s));
 }
 
-internal char typeAtSmallJson(smallJsont *self, intmax_t index) {
+internal char typeAtSmallJson(smallJsont *self, int64_t index) {
   size_t len;
 
   if (self->topIsA == TOP_IS_ARRAY) {
@@ -24138,10 +24137,10 @@ internal char typeAtSmallJson(smallJsont *self, intmax_t index) {
       return(0);
     }
 
-    if (index >= (intmax_t)len) {
+    if (index >= (int64_t)len) {
       return(0);
     }
-    if (index < -(intmax_t)len) {
+    if (index < -(int64_t)len) {
       return(0);
     }
     if (index < 0) {
@@ -24224,7 +24223,7 @@ internal smallBytest* typesSmallJson(smallJsont *self) {
   return(r);
 }
 
-internal bool isETypeAtSmallJson(smallJsont *self, intmax_t index, const char *type) {
+internal bool isETypeAtSmallJson(smallJsont *self, int64_t index, const char *type) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24237,7 +24236,7 @@ internal bool isETypeAtSmallJson(smallJsont *self, intmax_t index, const char *t
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], type));
 }
 
-internal bool isEUndefinedAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEUndefinedAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24246,7 +24245,7 @@ internal bool isEUndefinedAtSmallJson(smallJsont *self, intmax_t index) {
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], "undefined"));
 }
 
-internal bool isEBoolAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEBoolAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24255,7 +24254,7 @@ internal bool isEBoolAtSmallJson(smallJsont *self, intmax_t index) {
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], "bool"));
 }
 
-internal bool isEContainerAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEContainerAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24264,7 +24263,7 @@ internal bool isEContainerAtSmallJson(smallJsont *self, intmax_t index) {
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], "container"));
 }
 
-internal bool isEDictAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEDictAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24273,7 +24272,7 @@ internal bool isEDictAtSmallJson(smallJsont *self, intmax_t index) {
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], "dict"));
 }
 
-internal bool isEDoubleAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEDoubleAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24282,7 +24281,7 @@ internal bool isEDoubleAtSmallJson(smallJsont *self, intmax_t index) {
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], "double"));
 }
 
-internal bool isEIntAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEIntAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24291,7 +24290,7 @@ internal bool isEIntAtSmallJson(smallJsont *self, intmax_t index) {
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], "int"));
 }
 
-internal bool isEStringAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEStringAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24300,7 +24299,7 @@ internal bool isEStringAtSmallJson(smallJsont *self, intmax_t index) {
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], "string"));
 }
 
-internal bool isEFaststringAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEFaststringAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24309,7 +24308,7 @@ internal bool isEFaststringAtSmallJson(smallJsont *self, intmax_t index) {
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], "faststring"));
 }
 
-internal bool isEArrayAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEArrayAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -24318,7 +24317,7 @@ internal bool isEArrayAtSmallJson(smallJsont *self, intmax_t index) {
   return(eqS(SMALL_TYPE_NAMES[(size_t)typeAtSmallJson(self, index)], "array"));
 }
 
-internal bool isEBytesAtSmallJson(smallJsont *self, intmax_t index) {
+internal bool isEBytesAtSmallJson(smallJsont *self, int64_t index) {
 
   if (self->topIsA != TOP_IS_ARRAY) {
     return(false);
@@ -25322,12 +25321,12 @@ smallJsont* setNFreePSmallStringSmallJsonG(smallJsont *self, const char *key, sm
 
 
 
-smallJsont* setAtSmallJsonG         (smallJsont *self, intmax_t index, baset *value) {
+smallJsont* setAtSmallJsonG         (smallJsont *self, int64_t index, baset *value) {
 
   return(self->f->setAt(self, index, value));
 }
 
-smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value) {
+smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value) {
 
   if (value) {
     free(value);
@@ -25336,52 +25335,52 @@ smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *val
   return(self);
 }
 
-smallJsont* setAtBoolSmallJsonG     (smallJsont *self, intmax_t index, bool value) {
+smallJsont* setAtBoolSmallJsonG     (smallJsont *self, int64_t index, bool value) {
 
   return(self->f->setAtBool(self,index,value));
 }
 
-smallJsont* setAtDoubleSmallJsonG   (smallJsont *self, intmax_t index, double value) {
+smallJsont* setAtDoubleSmallJsonG   (smallJsont *self, int64_t index, double value) {
 
   return(self->f->setAtDouble(self,index,value));
 }
 
-smallJsont* setAtIntSmallJsonG      (smallJsont *self, intmax_t index, int64_t value) {
+smallJsont* setAtIntSmallJsonG      (smallJsont *self, int64_t index, int64_t value) {
 
   return(self->f->setAtInt(self,index,value));
 }
 
-smallJsont* setAtSSmallJsonG        (smallJsont *self, intmax_t index, const char *string) {
+smallJsont* setAtSSmallJsonG        (smallJsont *self, int64_t index, const char *string) {
 
   return(self->f->setAtS(self,index,string));
 }
 
-smallJsont* setAtCharSmallJsonG(smallJsont *self, intmax_t index, char c) {
+smallJsont* setAtCharSmallJsonG(smallJsont *self, int64_t index, char c) {
 
   return(self->f->setAtChar(self,index,c));
 }
 
-smallJsont* setAtDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict) {
+smallJsont* setAtDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict) {
 
   return(self->f->setAtDict(self,index,dict));
 }
 
-smallJsont* setAtArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array) {
+smallJsont* setAtArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array) {
 
   return(self->f->setAtArray(self,index,array));
 }
 
-smallJsont* setAtArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array) {
+smallJsont* setAtArraycSmallJsonG   (smallJsont *self, int64_t index, char **array) {
 
   return(self->f->setAtArrayc(self,index,array));
 }
 
-smallJsont* setAtCArraycSmallJsonG  (smallJsont *self, intmax_t index, const char **array) {
+smallJsont* setAtCArraycSmallJsonG  (smallJsont *self, int64_t index, const char **array) {
 
   return(self->f->setAtArrayc(self,index,(char**)array));
 }
 
-smallJsont* setAtVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value) {
+smallJsont* setAtVoidSmallJsonG     (smallJsont *self, int64_t index, void *value) {
 
   if (value) {
     smallContainert *c = allocSmallContainer(value);
@@ -25393,144 +25392,144 @@ smallJsont* setAtVoidSmallJsonG     (smallJsont *self, intmax_t index, void *val
   return(self->f->setAtUndefined(self,index));
 }
 
-smallJsont* setAtSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value) {
+smallJsont* setAtSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value) {
 
   return(self->f->setAtSmallBool(self,index,value));
 }
 
-smallJsont* setAtSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value) {
+smallJsont* setAtSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value) {
 
   return(self->f->setAtSmallBytes(self,index,value));
 }
 
-smallJsont* setAtSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value) {
+smallJsont* setAtSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value) {
 
   return(self->f->setAtSmallDouble(self,index,value));
 }
 
-smallJsont* setAtSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value) {
+smallJsont* setAtSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value) {
 
   return(self->f->setAtSmallInt(self,index,value));
 }
 
-smallJsont* setAtSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value) {
+smallJsont* setAtSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value) {
 
   return(self->f->setAtSmallJson(self,index,value));
 }
 
-smallJsont* setAtSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string) {
+smallJsont* setAtSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string) {
 
   return(self->f->setAtSmallString(self,index,string));
 }
 
-smallJsont* setAtSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container) {
+smallJsont* setAtSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container) {
 
   return(self->f->setAtSmallContainer(self,index,container));
 }
 
 
-smallJsont* setAtNFreeSmallJsonG    (smallJsont *self, intmax_t index, baset *value) {
+smallJsont* setAtNFreeSmallJsonG    (smallJsont *self, int64_t index, baset *value) {
 
   return(self->f->setAtNFree(self,index,value));
 }
 
-smallJsont* setAtNFreeUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value) {
+smallJsont* setAtNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value) {
 
   return(self->f->setAtNFreeUndefined(self,index,value));
 }
 
-smallJsont* setAtNFreeSSmallJsonG        (smallJsont *self, intmax_t index, char *string) {
+smallJsont* setAtNFreeSSmallJsonG        (smallJsont *self, int64_t index, char *string) {
 
   return(self->f->setAtNFreeS(self,index,string));
 }
 
-smallJsont* setAtNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict) {
+smallJsont* setAtNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict) {
 
   return(self->f->setAtNFreeDict(self,index,dict));
 }
 
-smallJsont* setAtNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array) {
+smallJsont* setAtNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array) {
 
   return(self->f->setAtNFreeArray(self,index,array));
 }
 
-smallJsont* setAtNFreeArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array) {
+smallJsont* setAtNFreeArraycSmallJsonG   (smallJsont *self, int64_t index, char **array) {
 
   return(self->f->setAtNFreeArrayc(self,index,array));
 }
 
-smallJsont* setAtNFreeSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value) {
+smallJsont* setAtNFreeSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value) {
 
   return(self->f->setAtNFreeSmallBool(self,index,value));
 }
 
-smallJsont* setAtNFreeSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value) {
+smallJsont* setAtNFreeSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value) {
 
   return(self->f->setAtNFreeSmallBytes(self,index,value));
 }
 
-smallJsont* setAtNFreeSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value) {
+smallJsont* setAtNFreeSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value) {
 
   return(self->f->setAtNFreeSmallDouble(self,index,value));
 }
 
-smallJsont* setAtNFreeSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value) {
+smallJsont* setAtNFreeSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value) {
 
   return(self->f->setAtNFreeSmallInt(self,index,value));
 }
 
-smallJsont* setAtNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value) {
+smallJsont* setAtNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value) {
 
   return(self->f->setAtNFreeSmallJson(self,index,value));
 }
 
-smallJsont* setAtNFreeSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string) {
+smallJsont* setAtNFreeSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string) {
 
   return(self->f->setAtNFreeSmallString(self,index,string));
 }
 
-smallJsont* setAtNFreeSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container) {
+smallJsont* setAtNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container) {
 
   return(self->f->setAtNFreeSmallContainer(self,index,container));
 }
 
 
-smallJsont* setPAtDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict) {
+smallJsont* setPAtDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict) {
 
   return(self->f->setPAtDict(self,index,dict));
 }
 
-smallJsont* setPAtArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array) {
+smallJsont* setPAtArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array) {
 
   return(self->f->setPAtArray(self,index,array));
 }
 
-smallJsont* setPAtSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value) {
+smallJsont* setPAtSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value) {
 
   return(self->f->setPAtSmallJson(self,index,value));
 }
 
-smallJsont* setPAtSmallStringSmallJsonG     (smallJsont *self, intmax_t index, smallStringt *string) {
+smallJsont* setPAtSmallStringSmallJsonG     (smallJsont *self, int64_t index, smallStringt *string) {
 
   return(self->f->setPAtSmallString(self,index,string));
 }
 
-smallJsont* setPAtNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict) {
+smallJsont* setPAtNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict) {
 
   return(self->f->setPAtNFreeDict(self,index,dict));
 }
 
-smallJsont* setPAtNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array) {
+smallJsont* setPAtNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array) {
 
   return(self->f->setPAtNFreeArray(self,index,array));
 }
 
-smallJsont* setPAtNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value) {
+smallJsont* setPAtNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value) {
 
   return(self->f->setPAtNFreeSmallJson(self,index,value));
 }
 
-smallJsont* setPAtNFreeSmallStringSmallJsonG     (smallJsont *self, intmax_t index, smallStringt *string) {
+smallJsont* setPAtNFreeSmallStringSmallJsonG     (smallJsont *self, int64_t index, smallStringt *string) {
 
   return(self->f->setPAtNFreeSmallString(self,index,string));
 }
@@ -25756,223 +25755,223 @@ smallContainert* getNDupSmallContainerSmallJsonG(smallJsont *self, smallContaine
   return(self->f->getNDupSmallContainer(self,key));
 }
 
-baset*           getAtSmallJsonG              (smallJsont *self, baset* retType UNUSED, intmax_t index) {
+baset*           getAtSmallJsonG              (smallJsont *self, baset* retType UNUSED, int64_t index) {
 
   return(self->f->getAt(self,index));
 }
 
-undefinedt*      getAtUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, intmax_t index) {
+undefinedt*      getAtUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtUndefined(self,index));
 }
 
-bool             getAtBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, intmax_t index) {
+bool             getAtBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, int64_t index) {
 
   return(self->f->getAtBool(self,index));
 }
 
-bool*            getAtBoolPSmallJsonG         (smallJsont *self, bool* retType UNUSED, intmax_t index) {
+bool*            getAtBoolPSmallJsonG         (smallJsont *self, bool* retType UNUSED, int64_t index) {
 
   return(self->f->getAtBoolP(self,index));
 }
 
-double           getAtDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, intmax_t index) {
+double           getAtDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, int64_t index) {
 
   return(self->f->getAtDouble(self,index));
 }
 
-double*          getAtDoublePSmallJsonG       (smallJsont *self, double* retType UNUSED, intmax_t index) {
+double*          getAtDoublePSmallJsonG       (smallJsont *self, double* retType UNUSED, int64_t index) {
 
   return(self->f->getAtDoubleP(self,index));
 }
 
-int64_t          getAtIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, intmax_t index) {
+int64_t          getAtIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtInt(self,index));
 }
 
-int64_t*         getAtIntPSmallJsonG          (smallJsont *self, int64_t* retType UNUSED, intmax_t index) {
+int64_t*         getAtIntPSmallJsonG          (smallJsont *self, int64_t* retType UNUSED, int64_t index) {
 
   return(self->f->getAtIntP(self,index));
 }
 
-int32_t          getAtInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, intmax_t index) {
+int32_t          getAtInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtInt32(self,index));
 }
 
-int32_t*         getAtInt32PSmallJsonG        (smallJsont *self, int32_t* retType UNUSED, intmax_t index) {
+int32_t*         getAtInt32PSmallJsonG        (smallJsont *self, int32_t* retType UNUSED, int64_t index) {
 
   return(self->f->getAtInt32P(self,index));
 }
 
-uint64_t         getAtUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, intmax_t index) {
+uint64_t         getAtUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtUint(self,index));
 }
 
-uint64_t*        getAtUintPSmallJsonG         (smallJsont *self, uint64_t* retType UNUSED, intmax_t index) {
+uint64_t*        getAtUintPSmallJsonG         (smallJsont *self, uint64_t* retType UNUSED, int64_t index) {
 
   return(self->f->getAtUintP(self,index));
 }
 
-uint32_t         getAtUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, intmax_t index) {
+uint32_t         getAtUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtUint32(self,index));
 }
 
-uint32_t*        getAtUint32PSmallJsonG       (smallJsont *self, uint32_t* retType UNUSED, intmax_t index) {
+uint32_t*        getAtUint32PSmallJsonG       (smallJsont *self, uint32_t* retType UNUSED, int64_t index) {
 
   return(self->f->getAtUint32P(self,index));
 }
 
-char*            getAtSSmallJsonG             (smallJsont *self, char* retType UNUSED, intmax_t index) {
+char*            getAtSSmallJsonG             (smallJsont *self, char* retType UNUSED, int64_t index) {
 
   return(self->f->getAtS(self,index));
 }
 
-smallDictt*      getAtDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, intmax_t index) {
+smallDictt*      getAtDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtDict(self,index));
 }
 
-smallArrayt*     getAtArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, intmax_t index) {
+smallArrayt*     getAtArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtArray(self,index));
 }
 
-smallBoolt*      getAtSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, intmax_t index) {
+smallBoolt*      getAtSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallBool(self,index));
 }
 
-smallBytest*     getAtSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, intmax_t index) {
+smallBytest*     getAtSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallBytes(self,index));
 }
 
-smallDoublet*    getAtSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, intmax_t index) {
+smallDoublet*    getAtSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallDouble(self,index));
 }
 
-smallIntt*       getAtSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, intmax_t index) {
+smallIntt*       getAtSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallInt(self,index));
 }
 
-smallJsont*       getAtSmallJsonSmallJsonG    (smallJsont *self, smallJsont* retType UNUSED, intmax_t index) {
+smallJsont*       getAtSmallJsonSmallJsonG    (smallJsont *self, smallJsont* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallJson(self,index));
 }
 
-smallStringt*    getAtSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, intmax_t index) {
+smallStringt*    getAtSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallString(self,index));
 }
 
-void*            getAtVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, intmax_t index) {
+void*            getAtVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, int64_t index) {
 
   return(self->f->getAtVoid(self,index));
 }
 
-smallContainert* getAtSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, intmax_t index) {
+smallContainert* getAtSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index) {
 
   return(self->f->getAtSmallContainer(self,index));
 }
 
 
-baset*           getAtNDupSmallJsonG              (smallJsont *self, baset* retType UNUSED, intmax_t index) {
+baset*           getAtNDupSmallJsonG              (smallJsont *self, baset* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDup(self,index));
 }
 
-undefinedt*      getAtNDupUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, intmax_t index) {
+undefinedt*      getAtNDupUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupUndefined(self,index));
 }
 
-bool             getAtNDupBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, intmax_t index) {
+bool             getAtNDupBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupBool(self,index));
 }
 
-double           getAtNDupDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, intmax_t index) {
+double           getAtNDupDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupDouble(self,index));
 }
 
-int64_t          getAtNDupIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, intmax_t index) {
+int64_t          getAtNDupIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupInt(self,index));
 }
 
-int32_t          getAtNDupInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, intmax_t index) {
+int32_t          getAtNDupInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupInt32(self,index));
 }
 
-uint64_t         getAtNDupUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, intmax_t index) {
+uint64_t         getAtNDupUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupUint(self,index));
 }
 
-uint32_t         getAtNDupUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, intmax_t index) {
+uint32_t         getAtNDupUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupUint32(self,index));
 }
 
-char*            getAtNDupSSmallJsonG             (smallJsont *self, char* retType UNUSED, intmax_t index) {
+char*            getAtNDupSSmallJsonG             (smallJsont *self, char* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupS(self,index));
 }
 
-smallDictt*      getAtNDupDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, intmax_t index) {
+smallDictt*      getAtNDupDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupDict(self,index));
 }
 
-smallArrayt*     getAtNDupArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, intmax_t index) {
+smallArrayt*     getAtNDupArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupArray(self,index));
 }
 
-smallBoolt*      getAtNDupSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, intmax_t index) {
+smallBoolt*      getAtNDupSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallBool(self,index));
 }
 
-smallBytest*     getAtNDupSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, intmax_t index) {
+smallBytest*     getAtNDupSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallBytes(self,index));
 }
 
-smallDoublet*    getAtNDupSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, intmax_t index) {
+smallDoublet*    getAtNDupSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallDouble(self,index));
 }
 
-smallIntt*       getAtNDupSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, intmax_t index) {
+smallIntt*       getAtNDupSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallInt(self,index));
 }
 
-smallJsont*       getAtNDupSmallJsonSmallJsonG    (smallJsont *self, smallJsont* retType UNUSED, intmax_t index) {
+smallJsont*       getAtNDupSmallJsonSmallJsonG    (smallJsont *self, smallJsont* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallJson(self,index));
 }
 
-smallStringt*    getAtNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, intmax_t index) {
+smallStringt*    getAtNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallString(self,index));
 }
 
-void*            getAtNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, intmax_t index) {
+void*            getAtNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupVoid(self,index));
 }
 
-smallContainert* getAtNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, intmax_t index) {
+smallContainert* getAtNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index) {
 
   return(self->f->getAtNDupSmallContainer(self,index));
 }
@@ -25982,7 +25981,7 @@ double getNumSmallJsonG(smallJsont *self, const char *key) {
   return(self->f->getNum(self, key));
 }
 
-double getNumAtSmallJsonG(smallJsont *self, intmax_t index) {
+double getNumAtSmallJsonG(smallJsont *self, int64_t index) {
 
   return(self->f->getNumAt(self, index));
 }
@@ -25992,7 +25991,7 @@ smallJsont* delKeySmallJsonG(smallJsont *self, const char *key, int unused UNUSE
   return(self->f->delElem(self,key));
 }
 
-smallJsont* delSmallJsonG(smallJsont *self, intmax_t start, intmax_t end) {
+smallJsont* delSmallJsonG(smallJsont *self, int64_t start, int64_t end) {
 
   return(self->f->del(self, start, end));
 }
@@ -26002,7 +26001,7 @@ smallJsont* delElemSmallJsonG(smallJsont *self, const char *key) {
   return(self->f->delElem(self,key));
 }
 
-smallJsont* delElemIndexSmallJsonG(smallJsont *self, intmax_t index) {
+smallJsont* delElemIndexSmallJsonG(smallJsont *self, int64_t index) {
 
   return(self->f->delElemIndex(self,index));
 }
@@ -26367,122 +26366,122 @@ smallJsont* addJsonSmallJsonG  (smallJsont *self, smallJsont *array) {
   return(self->f->addJson(self, array));
 }
 
-smallJsont* sliceSmallJsonG(smallJsont *self, intmax_t start, intmax_t end) {
+smallJsont* sliceSmallJsonG(smallJsont *self, int64_t start, int64_t end) {
 
   return(self->f->slice(self, start, end));
 }
 
-smallJsont* cropSmallJsonG                          (smallJsont *self, intmax_t start, intmax_t end) {
+smallJsont* cropSmallJsonG                          (smallJsont *self, int64_t start, int64_t end) {
 
   return(self->f->crop(self, start, end));
 }
 
-char* cropSSmallJsonG                               (smallJsont *self, intmax_t start, intmax_t end) {
+char* cropSSmallJsonG                               (smallJsont *self, int64_t start, int64_t end) {
 
   return(self->f->cropS(self, start, end));
 }
 
-smallStringt* cropSmallStringSmallJsonG             (smallJsont *self, intmax_t start, intmax_t end) {
+smallStringt* cropSmallStringSmallJsonG             (smallJsont *self, int64_t start, int64_t end) {
 
   return(self->f->cropSmallString(self, start, end));
 }
 
-baset* cropElemAtSmallJsonG                         (smallJsont *self, intmax_t index) {
+baset* cropElemAtSmallJsonG                         (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAt(self, index));
 }
 
-undefinedt* cropElemAtUndefinedSmallJsonG           (smallJsont *self, intmax_t index) {
+undefinedt* cropElemAtUndefinedSmallJsonG           (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtUndefined(self, index));
 }
 
-bool cropElemAtBoolSmallJsonG                       (smallJsont *self, intmax_t index) {
+bool cropElemAtBoolSmallJsonG                       (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtBool(self, index));
 }
 
-double cropElemAtDoubleSmallJsonG                   (smallJsont *self, intmax_t index) {
+double cropElemAtDoubleSmallJsonG                   (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtDouble(self, index));
 }
 
-int64_t cropElemAtIntSmallJsonG                     (smallJsont *self, intmax_t index) {
+int64_t cropElemAtIntSmallJsonG                     (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtInt(self, index));
 }
 
-int32_t cropElemAtInt32SmallJsonG                   (smallJsont *self, intmax_t index) {
+int32_t cropElemAtInt32SmallJsonG                   (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtInt32(self, index));
 }
 
-uint64_t cropElemAtUintSmallJsonG                   (smallJsont *self, intmax_t index) {
+uint64_t cropElemAtUintSmallJsonG                   (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtUint(self, index));
 }
 
-uint32_t cropElemAtUint32SmallJsonG                 (smallJsont *self, intmax_t index) {
+uint32_t cropElemAtUint32SmallJsonG                 (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtUint32(self, index));
 }
 
-char* cropElemAtSSmallJsonG                         (smallJsont *self, intmax_t index) {
+char* cropElemAtSSmallJsonG                         (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtS(self, index));
 }
 
-char cropElemAtCharSmallJsonG                       (smallJsont *self, intmax_t index) {
+char cropElemAtCharSmallJsonG                       (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtChar(self, index));
 }
 
-smallDictt* cropElemAtDictSmallJsonG                (smallJsont *self, intmax_t index) {
+smallDictt* cropElemAtDictSmallJsonG                (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtDict(self, index));
 }
 
-smallArrayt* cropElemAtArraySmallJsonG              (smallJsont *self, intmax_t index) {
+smallArrayt* cropElemAtArraySmallJsonG              (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtArray(self, index));
 }
 
-smallBoolt* cropElemAtSmallBoolSmallJsonG           (smallJsont *self, intmax_t index) {
+smallBoolt* cropElemAtSmallBoolSmallJsonG           (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtSmallBool(self, index));
 }
 
-smallBytest* cropElemAtSmallBytesSmallJsonG         (smallJsont *self, intmax_t index) {
+smallBytest* cropElemAtSmallBytesSmallJsonG         (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtSmallBytes(self, index));
 }
 
-smallDoublet* cropElemAtSmallDoubleSmallJsonG       (smallJsont *self, intmax_t index) {
+smallDoublet* cropElemAtSmallDoubleSmallJsonG       (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtSmallDouble(self, index));
 }
 
-smallIntt* cropElemAtSmallIntSmallJsonG             (smallJsont *self, intmax_t index) {
+smallIntt* cropElemAtSmallIntSmallJsonG             (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtSmallInt(self, index));
 }
 
-smallJsont* cropElemAtSmallJsonSmallJsonG           (smallJsont *self, intmax_t index) {
+smallJsont* cropElemAtSmallJsonSmallJsonG           (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtSmallJson(self, index));
 }
 
-smallStringt* cropElemAtSmallStringSmallJsonG       (smallJsont *self, intmax_t index) {
+smallStringt* cropElemAtSmallStringSmallJsonG       (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtSmallString(self, index));
 }
 
-void* cropElemAtVoidSmallJsonG                      (smallJsont *self, intmax_t index) {
+void* cropElemAtVoidSmallJsonG                      (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtVoid(self, index));
 }
 
-smallContainert* cropElemAtSmallContainerSmallJsonG (smallJsont *self, intmax_t index) {
+smallContainert* cropElemAtSmallContainerSmallJsonG (smallJsont *self, int64_t index) {
 
   return(self->f->cropElemAtSmallContainer(self, index));
 }
@@ -26582,108 +26581,108 @@ smallContainert* cropElemKeySmallContainerSmallJsonG(smallJsont *self, const cha
   return(self->f->cropElemKeySmallContainer(self, (char*)key));
 }
 
-smallJsont* copySmallJsonG (smallJsont *self, intmax_t start, intmax_t end) {
+smallJsont* copySmallJsonG (smallJsont *self, int64_t start, int64_t end) {
 
   return(self->f->copy(self, start, end));
 }
 
-smallJsont*          insertSmallJsonG(smallJsont *self, intmax_t index, smallArrayt *toInsert) {
+smallJsont*          insertSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert) {
 
   return(self->f->insert(self, index, toInsert));
 }
 
-smallJsont*          insertNSmashSmallJsonG(smallJsont *self, intmax_t index, smallArrayt *toInsert) {
+smallJsont*          insertNSmashSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert) {
 
   return(self->f->insertNSmash(self, index, toInsert));
 }
 
-smallJsont*          insertSmallJsonSmallJsonG(smallJsont *self, intmax_t index, smallJsont *toInsert) {
+smallJsont*          insertSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert) {
 
   return(self->f->insertSmallJson(self, index, toInsert));
 }
 
-smallJsont*          insertNSmashSmallJsonSmallJsonG(smallJsont *self, intmax_t index, smallJsont *toInsert) {
+smallJsont*          insertNSmashSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert) {
 
   return(self->f->insertNSmashSmallJson(self, index, toInsert));
 }
 
-smallJsont*    insertStringSmallJsonG     (smallJsont *self, intmax_t index, smallStringt *toInsert) {
+smallJsont*    insertStringSmallJsonG     (smallJsont *self, int64_t index, smallStringt *toInsert) {
 
   return(self->f->insertString(self, index, toInsert));
 }
 
-smallJsont*    insertSSmallJsonG    (smallJsont *self, intmax_t index, const char *toInsert) {
+smallJsont*    insertSSmallJsonG    (smallJsont *self, int64_t index, const char *toInsert) {
 
   return(self->f->insertS(self, index, toInsert));
 }
 
-smallJsont*    insertNFreeStringSmallJsonG(smallJsont *self, intmax_t index, smallStringt *toInsert) {
+smallJsont*    insertNFreeStringSmallJsonG(smallJsont *self, int64_t index, smallStringt *toInsert) {
 
   return(self->f->insertNFreeString(self, index, toInsert));
 }
 
-smallJsont*    insertNFreeSSmallJsonG(smallJsont *self, intmax_t index, char *toInsert) {
+smallJsont*    insertNFreeSSmallJsonG(smallJsont *self, int64_t index, char *toInsert) {
 
   return(self->f->insertSNFree(self, index, toInsert));
 }
 
 
-smallJsont* injectSmallJsonG         (smallJsont *self, intmax_t index, baset *value) {
+smallJsont* injectSmallJsonG         (smallJsont *self, int64_t index, baset *value) {
 
   return(self->f->inject(self, index, value));
 }
 
-smallJsont* injectUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value UNUSED) {
+smallJsont* injectUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value UNUSED) {
 
   return(self->f->injectUndefined(self,index));
 }
 
-smallJsont* injectBoolSmallJsonG     (smallJsont *self, intmax_t index, bool value) {
+smallJsont* injectBoolSmallJsonG     (smallJsont *self, int64_t index, bool value) {
 
   return(self->f->injectBool(self,index,value));
 }
 
-smallJsont* injectDoubleSmallJsonG   (smallJsont *self, intmax_t index, double value) {
+smallJsont* injectDoubleSmallJsonG   (smallJsont *self, int64_t index, double value) {
 
   return(self->f->injectDouble(self,index,value));
 }
 
-smallJsont* injectIntSmallJsonG      (smallJsont *self, intmax_t index, int64_t value) {
+smallJsont* injectIntSmallJsonG      (smallJsont *self, int64_t index, int64_t value) {
 
   return(self->f->injectInt(self,index,value));
 }
 
-smallJsont* injectSSmallJsonG        (smallJsont *self, intmax_t index, const char *string) {
+smallJsont* injectSSmallJsonG        (smallJsont *self, int64_t index, const char *string) {
 
   return(self->f->injectS(self,index,string));
 }
 
-smallJsont* injectCharSmallJsonG(smallJsont *self, intmax_t index, char c) {
+smallJsont* injectCharSmallJsonG(smallJsont *self, int64_t index, char c) {
 
   return(self->f->injectChar(self,index,c));
 }
 
-smallJsont* injectDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict) {
+smallJsont* injectDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict) {
 
   return(self->f->injectDict(self,index,dict));
 }
 
-smallJsont* injectArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array) {
+smallJsont* injectArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array) {
 
   return(self->f->injectArray(self,index,array));
 }
 
-smallJsont* injectArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array) {
+smallJsont* injectArraycSmallJsonG   (smallJsont *self, int64_t index, char **array) {
 
   return(self->f->injectArrayc(self,index,array));
 }
 
-smallJsont* injectCArraycSmallJsonG   (smallJsont *self, intmax_t index, const char **array) {
+smallJsont* injectCArraycSmallJsonG   (smallJsont *self, int64_t index, const char **array) {
 
   return(self->f->injectArrayc(self,index,(char**)array));
 }
 
-smallJsont* injectVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value) {
+smallJsont* injectVoidSmallJsonG     (smallJsont *self, int64_t index, void *value) {
 
   if (value) {
     smallContainert *c = allocSmallContainer(value);
@@ -26697,103 +26696,103 @@ smallJsont* injectVoidSmallJsonG     (smallJsont *self, intmax_t index, void *va
   return(self);
 }
 
-smallJsont* injectSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value) {
+smallJsont* injectSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value) {
 
   return(self->f->injectSmallBool(self,index,value));
 }
 
-smallJsont* injectSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value) {
+smallJsont* injectSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value) {
 
   return(self->f->injectSmallBytes(self,index,value));
 }
 
-smallJsont* injectSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value) {
+smallJsont* injectSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value) {
 
   return(self->f->injectSmallDouble(self,index,value));
 }
 
-smallJsont* injectSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value) {
+smallJsont* injectSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value) {
 
   return(self->f->injectSmallInt(self,index,value));
 }
 
-smallJsont* injectSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value) {
+smallJsont* injectSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value) {
 
   return(self->f->injectSmallJson(self,index,value));
 }
 
-smallJsont* injectSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string) {
+smallJsont* injectSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string) {
 
   return(self->f->injectSmallString(self,index,string));
 }
 
-smallJsont* injectSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container) {
+smallJsont* injectSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container) {
 
   return(self->f->injectSmallContainer(self,index,container));
 }
 
 
-smallJsont* injectNFreeSmallJsonG    (smallJsont *self, intmax_t index, baset *value) {
+smallJsont* injectNFreeSmallJsonG    (smallJsont *self, int64_t index, baset *value) {
 
   return(self->f->injectNFree(self,index,value));
 }
 
-smallJsont* injectNFreeUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value) {
+smallJsont* injectNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value) {
 
   return(self->f->injectNFreeUndefined(self,index,value));
 }
 
-smallJsont* injectNFreeSSmallJsonG        (smallJsont *self, intmax_t index, char *string) {
+smallJsont* injectNFreeSSmallJsonG        (smallJsont *self, int64_t index, char *string) {
 
   return(self->f->injectNFreeS(self,index,string));
 }
 
-smallJsont* injectNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict) {
+smallJsont* injectNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict) {
 
   return(self->f->injectNFreeDict(self,index,dict));
 }
 
-smallJsont* injectNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array) {
+smallJsont* injectNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array) {
 
   return(self->f->injectNFreeArray(self,index,array));
 }
 
-smallJsont* injectNFreeArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array) {
+smallJsont* injectNFreeArraycSmallJsonG   (smallJsont *self, int64_t index, char **array) {
 
   return(self->f->injectNFreeArrayc(self,index,array));
 }
 
-smallJsont* injectNFreeSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value) {
+smallJsont* injectNFreeSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value) {
 
   return(self->f->injectNFreeSmallBool(self,index,value));
 }
 
-smallJsont* injectNFreeSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value) {
+smallJsont* injectNFreeSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value) {
 
   return(self->f->injectNFreeSmallBytes(self,index,value));
 }
 
-smallJsont* injectNFreeSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value) {
+smallJsont* injectNFreeSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value) {
 
   return(self->f->injectNFreeSmallDouble(self,index,value));
 }
 
-smallJsont* injectNFreeSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value) {
+smallJsont* injectNFreeSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value) {
 
   return(self->f->injectNFreeSmallInt(self,index,value));
 }
 
-smallJsont* injectNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value) {
+smallJsont* injectNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value) {
 
   return(self->f->injectNFreeSmallJson(self,index,value));
 }
 
-smallJsont* injectNFreeSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string) {
+smallJsont* injectNFreeSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string) {
 
   return(self->f->injectNFreeSmallString(self,index,string));
 }
 
-smallJsont* injectNFreeSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container) {
+smallJsont* injectNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container) {
 
   return(self->f->injectNFreeSmallContainer(self,index,container));
 }
@@ -27695,22 +27694,22 @@ bool icEqualSSmallJsonG       (smallJsont *self, const char *string) {
   return(self->f->icEqualS(self, string));
 }
 
-bool equalISSmallJsonG      (smallJsont *self, const char *string, intmax_t index) {
+bool equalISSmallJsonG      (smallJsont *self, const char *string, int64_t index) {
 
   return(self->f->equalIS(self, string, index));
 }
 
-bool equalICharSmallJsonG(smallJsont *self, char c, intmax_t index) {
+bool equalICharSmallJsonG(smallJsont *self, char c, int64_t index) {
 
   return(self->f->equalIChar(self,c,index));
 }
 
-bool equalIJsonSmallJsonG(smallJsont *self, smallJsont *string, intmax_t index) {
+bool equalIJsonSmallJsonG(smallJsont *self, smallJsont *string, int64_t index) {
 
   return(self->f->equalIJson(self,string,index));
 }
 
-bool equalISmallStringSmallJsonG(smallJsont *self, smallStringt *string, intmax_t index) {
+bool equalISmallStringSmallJsonG(smallJsont *self, smallStringt *string, int64_t index) {
 
   return(self->f->equalISmallString(self,string,index));
 }
@@ -27845,7 +27844,7 @@ bool isIntSmallJsonG(smallJsont *self) {
   return(self->f->isInt(self));
 }
 
-intmax_t parseIntSmallJsonG (smallJsont *self) {
+int64_t parseIntSmallJsonG (smallJsont *self) {
 
   return(self->f->parseInt(self));
 }
@@ -27855,7 +27854,7 @@ double parseDoubleSmallJsonG (smallJsont *self) {
   return(self->f->parseDouble(self));
 }
 
-smallJsont* intToSmallJsonG        (smallJsont *self, intmax_t n) {
+smallJsont* intToSmallJsonG        (smallJsont *self, int64_t n) {
 
   return(self->f->intTo(self, n));
 }
diff --git a/src/json/libsheepyCSmallJson.h b/src/json/libsheepyCSmallJson.h
@@ -446,23 +446,23 @@ typedef smallJsont*         (*setNFreePSmallStringSmallJsonFt)(smallJsont *self,
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallJsont*         (*setAtSmallJsonFt)     (smallJsont *self, intmax_t index, baset *value);
-typedef smallJsont*         (*setAtUndefinedSmallJsonFt)(smallJsont *self, intmax_t index);
-typedef smallJsont*         (*setAtBoolSmallJsonFt)     (smallJsont *self, intmax_t index, bool value);
-typedef smallJsont*         (*setAtDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, double value);
-typedef smallJsont*         (*setAtIntSmallJsonFt)      (smallJsont *self, intmax_t index, int64_t value);
-typedef smallJsont*         (*setAtSSmallJsonFt)        (smallJsont *self, intmax_t index, const char *string);
-typedef smallJsont*         (*setAtCharSmallJsonFt)     (smallJsont *self, intmax_t index, char c);
-typedef smallJsont*         (*setAtDictSmallJsonFt)     (smallJsont *self, intmax_t index, smallDictt *dict);
-typedef smallJsont*         (*setAtArraySmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *array);
-typedef smallJsont*         (*setAtArraycSmallJsonFt)   (smallJsont *self, intmax_t index, char **array);
-typedef smallJsont*         (*setAtSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index, smallBoolt *value);
-typedef smallJsont*         (*setAtSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index, smallBytest *value);
-typedef smallJsont*         (*setAtSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, smallDoublet *value);
-typedef smallJsont*         (*setAtSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index, smallIntt *value);
-typedef smallJsont*         (*setAtSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index, smallJsont *value);
-typedef smallJsont*         (*setAtSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index, smallStringt *string);
-typedef smallJsont*         (*setAtSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index, smallContainert *container);
+typedef smallJsont*         (*setAtSmallJsonFt)     (smallJsont *self, int64_t index, baset *value);
+typedef smallJsont*         (*setAtUndefinedSmallJsonFt)(smallJsont *self, int64_t index);
+typedef smallJsont*         (*setAtBoolSmallJsonFt)     (smallJsont *self, int64_t index, bool value);
+typedef smallJsont*         (*setAtDoubleSmallJsonFt)   (smallJsont *self, int64_t index, double value);
+typedef smallJsont*         (*setAtIntSmallJsonFt)      (smallJsont *self, int64_t index, int64_t value);
+typedef smallJsont*         (*setAtSSmallJsonFt)        (smallJsont *self, int64_t index, const char *string);
+typedef smallJsont*         (*setAtCharSmallJsonFt)     (smallJsont *self, int64_t index, char c);
+typedef smallJsont*         (*setAtDictSmallJsonFt)     (smallJsont *self, int64_t index, smallDictt *dict);
+typedef smallJsont*         (*setAtArraySmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *array);
+typedef smallJsont*         (*setAtArraycSmallJsonFt)   (smallJsont *self, int64_t index, char **array);
+typedef smallJsont*         (*setAtSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index, smallBoolt *value);
+typedef smallJsont*         (*setAtSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index, smallBytest *value);
+typedef smallJsont*         (*setAtSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index, smallDoublet *value);
+typedef smallJsont*         (*setAtSmallIntSmallJsonFt)      (smallJsont *self, int64_t index, smallIntt *value);
+typedef smallJsont*         (*setAtSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index, smallJsont *value);
+typedef smallJsont*         (*setAtSmallStringSmallJsonFt)   (smallJsont *self, int64_t index, smallStringt *string);
+typedef smallJsont*         (*setAtSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *container);
 
 /**
  * store object at given index (free already existing elements)
@@ -480,19 +480,19 @@ typedef smallJsont*         (*setAtSmallContainerSmallJsonFt)(smallJsont *self, 
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallJsont*         (*setAtNFreeSmallJsonFt)         (smallJsont *self, intmax_t index, baset *value);
-typedef smallJsont*         (*setAtNFreeUndefinedSmallJsonFt)(smallJsont *self, intmax_t index, undefinedt *undefined);
-typedef smallJsont*         (*setAtNFreeSSmallJsonFt)        (smallJsont *self, intmax_t index, char *string);
-typedef smallJsont*         (*setAtNFreeDictSmallJsonFt)     (smallJsont *self, intmax_t index, smallDictt *dict);
-typedef smallJsont*         (*setAtNFreeArraySmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *array);
-typedef smallJsont*         (*setAtNFreeArraycSmallJsonFt)   (smallJsont *self, intmax_t index, char **array);
-typedef smallJsont*         (*setAtNFreeSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index, smallBoolt *value);
-typedef smallJsont*         (*setAtNFreeSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index, smallBytest *value);
-typedef smallJsont*         (*setAtNFreeSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, smallDoublet *value);
-typedef smallJsont*         (*setAtNFreeSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index, smallIntt *value);
-typedef smallJsont*         (*setAtNFreeSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index, smallJsont *value);
-typedef smallJsont*         (*setAtNFreeSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index, smallStringt *string);
-typedef smallJsont*         (*setAtNFreeSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index, smallContainert *container);
+typedef smallJsont*         (*setAtNFreeSmallJsonFt)         (smallJsont *self, int64_t index, baset *value);
+typedef smallJsont*         (*setAtNFreeUndefinedSmallJsonFt)(smallJsont *self, int64_t index, undefinedt *undefined);
+typedef smallJsont*         (*setAtNFreeSSmallJsonFt)        (smallJsont *self, int64_t index, char *string);
+typedef smallJsont*         (*setAtNFreeDictSmallJsonFt)     (smallJsont *self, int64_t index, smallDictt *dict);
+typedef smallJsont*         (*setAtNFreeArraySmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *array);
+typedef smallJsont*         (*setAtNFreeArraycSmallJsonFt)   (smallJsont *self, int64_t index, char **array);
+typedef smallJsont*         (*setAtNFreeSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index, smallBoolt *value);
+typedef smallJsont*         (*setAtNFreeSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index, smallBytest *value);
+typedef smallJsont*         (*setAtNFreeSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index, smallDoublet *value);
+typedef smallJsont*         (*setAtNFreeSmallIntSmallJsonFt)      (smallJsont *self, int64_t index, smallIntt *value);
+typedef smallJsont*         (*setAtNFreeSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index, smallJsont *value);
+typedef smallJsont*         (*setAtNFreeSmallStringSmallJsonFt)   (smallJsont *self, int64_t index, smallStringt *string);
+typedef smallJsont*         (*setAtNFreeSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *container);
 
 /**
  * store pointer at given index (existing element is not freed)
@@ -508,14 +508,14 @@ typedef smallJsont*         (*setAtNFreeSmallContainerSmallJsonFt)(smallJsont *s
  * Does nothing when:
  * when array is NULL, index is not set correctly or s is NULL
  */
-typedef smallJsont*         (*setPAtArraySmallJsonFt)           (smallJsont *self, intmax_t index, smallArrayt *array);
-typedef smallJsont*         (*setPAtDictSmallJsonFt)            (smallJsont *self, intmax_t index, smallDictt *dict);
-typedef smallJsont*         (*setPAtSmallJsonSmallJsonFt)       (smallJsont *self, intmax_t index, smallJsont *value);
-typedef smallJsont*         (*setPAtSmallStringSmallJsonFt)     (smallJsont *self, intmax_t index, smallStringt *string);
-typedef smallJsont*         (*setPAtNFreeArraySmallJsonFt)      (smallJsont *self, intmax_t index, smallArrayt *array);
-typedef smallJsont*         (*setPAtNFreeDictSmallJsonFt)       (smallJsont *self, intmax_t index, smallDictt *dict);
-typedef smallJsont*         (*setPAtNFreeSmallJsonSmallJsonFt)  (smallJsont *self, intmax_t index, smallJsont *value);
-typedef smallJsont*         (*setPAtNFreeSmallStringSmallJsonFt)(smallJsont *self, intmax_t index, smallStringt *string);
+typedef smallJsont*         (*setPAtArraySmallJsonFt)           (smallJsont *self, int64_t index, smallArrayt *array);
+typedef smallJsont*         (*setPAtDictSmallJsonFt)            (smallJsont *self, int64_t index, smallDictt *dict);
+typedef smallJsont*         (*setPAtSmallJsonSmallJsonFt)       (smallJsont *self, int64_t index, smallJsont *value);
+typedef smallJsont*         (*setPAtSmallStringSmallJsonFt)     (smallJsont *self, int64_t index, smallStringt *string);
+typedef smallJsont*         (*setPAtNFreeArraySmallJsonFt)      (smallJsont *self, int64_t index, smallArrayt *array);
+typedef smallJsont*         (*setPAtNFreeDictSmallJsonFt)       (smallJsont *self, int64_t index, smallDictt *dict);
+typedef smallJsont*         (*setPAtNFreeSmallJsonSmallJsonFt)  (smallJsont *self, int64_t index, smallJsont *value);
+typedef smallJsont*         (*setPAtNFreeSmallStringSmallJsonFt)(smallJsont *self, int64_t index, smallStringt *string);
 
 /**
  * get element
@@ -589,31 +589,31 @@ typedef smallContainert* (*getNDupSmallContainerSmallJsonFt)(smallJsont *self, c
  *   pointer to object
  *   NULL when array is NULL or index is not set correctly
  */
-typedef baset*           (*getAtSmallJsonFt)              (smallJsont *self, intmax_t index);
-typedef undefinedt*      (*getAtUndefinedSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef bool             (*getAtBoolSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef bool*            (*getAtBoolPSmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef double           (*getAtDoubleSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef double*          (*getAtDoublePSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef int64_t          (*getAtIntSmallJsonFt)           (smallJsont *self, intmax_t index);
-typedef int64_t*         (*getAtIntPSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef int32_t          (*getAtInt32SmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef int32_t*         (*getAtInt32PSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef uint64_t         (*getAtUintSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef uint64_t*        (*getAtUintPSmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef uint32_t         (*getAtUint32SmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef uint32_t*        (*getAtUint32PSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef char*            (*getAtSSmallJsonFt)             (smallJsont *self, intmax_t index);
-typedef smallDictt*      (*getAtDictSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef smallArrayt*     (*getAtArraySmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef smallBoolt*      (*getAtSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallBytest*     (*getAtSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef smallDoublet*    (*getAtSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index);
-typedef smallIntt*       (*getAtSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef smallJsont*      (*getAtSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallStringt*    (*getAtSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index);
-typedef void*            (*getAtVoidSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef smallContainert* (*getAtSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index);
+typedef baset*           (*getAtSmallJsonFt)              (smallJsont *self, int64_t index);
+typedef undefinedt*      (*getAtUndefinedSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef bool             (*getAtBoolSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef bool*            (*getAtBoolPSmallJsonFt)         (smallJsont *self, int64_t index);
+typedef double           (*getAtDoubleSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef double*          (*getAtDoublePSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef int64_t          (*getAtIntSmallJsonFt)           (smallJsont *self, int64_t index);
+typedef int64_t*         (*getAtIntPSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef int32_t          (*getAtInt32SmallJsonFt)         (smallJsont *self, int64_t index);
+typedef int32_t*         (*getAtInt32PSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef uint64_t         (*getAtUintSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef uint64_t*        (*getAtUintPSmallJsonFt)         (smallJsont *self, int64_t index);
+typedef uint32_t         (*getAtUint32SmallJsonFt)        (smallJsont *self, int64_t index);
+typedef uint32_t*        (*getAtUint32PSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef char*            (*getAtSSmallJsonFt)             (smallJsont *self, int64_t index);
+typedef smallDictt*      (*getAtDictSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef smallArrayt*     (*getAtArraySmallJsonFt)         (smallJsont *self, int64_t index);
+typedef smallBoolt*      (*getAtSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallBytest*     (*getAtSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef smallDoublet*    (*getAtSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index);
+typedef smallIntt*       (*getAtSmallIntSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef smallJsont*      (*getAtSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallStringt*    (*getAtSmallStringSmallJsonFt)   (smallJsont *self, int64_t index);
+typedef void*            (*getAtVoidSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef smallContainert* (*getAtSmallContainerSmallJsonFt)(smallJsont *self, int64_t index);
 
 /**
  * get duplicated object at index
@@ -625,25 +625,25 @@ typedef smallContainert* (*getAtSmallContainerSmallJsonFt)(smallJsont *self, int
  *   duplicated object
  *   NULL when array is NULL or index is not set correctly
  */
-typedef baset*           (*getAtNDupSmallJsonFt)              (smallJsont *self, intmax_t index);
-typedef undefinedt*      (*getAtNDupUndefinedSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef bool             (*getAtNDupBoolSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef double           (*getAtNDupDoubleSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef int64_t          (*getAtNDupIntSmallJsonFt)           (smallJsont *self, intmax_t index);
-typedef int32_t          (*getAtNDupInt32SmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef uint64_t         (*getAtNDupUintSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef uint32_t         (*getAtNDupUint32SmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef char*            (*getAtNDupSSmallJsonFt)             (smallJsont *self, intmax_t index);
-typedef smallDictt*      (*getAtNDupDictSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef smallArrayt*     (*getAtNDupArraySmallJsonFt)         (smallJsont *self, intmax_t index);
-typedef smallBoolt*      (*getAtNDupSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallBytest*     (*getAtNDupSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef smallDoublet*    (*getAtNDupSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index);
-typedef smallIntt*       (*getAtNDupSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef smallJsont*      (*getAtNDupSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallStringt*    (*getAtNDupSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index);
-typedef void*            (*getAtNDupVoidSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef smallContainert* (*getAtNDupSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index);
+typedef baset*           (*getAtNDupSmallJsonFt)              (smallJsont *self, int64_t index);
+typedef undefinedt*      (*getAtNDupUndefinedSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef bool             (*getAtNDupBoolSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef double           (*getAtNDupDoubleSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef int64_t          (*getAtNDupIntSmallJsonFt)           (smallJsont *self, int64_t index);
+typedef int32_t          (*getAtNDupInt32SmallJsonFt)         (smallJsont *self, int64_t index);
+typedef uint64_t         (*getAtNDupUintSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef uint32_t         (*getAtNDupUint32SmallJsonFt)        (smallJsont *self, int64_t index);
+typedef char*            (*getAtNDupSSmallJsonFt)             (smallJsont *self, int64_t index);
+typedef smallDictt*      (*getAtNDupDictSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef smallArrayt*     (*getAtNDupArraySmallJsonFt)         (smallJsont *self, int64_t index);
+typedef smallBoolt*      (*getAtNDupSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallBytest*     (*getAtNDupSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef smallDoublet*    (*getAtNDupSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index);
+typedef smallIntt*       (*getAtNDupSmallIntSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef smallJsont*      (*getAtNDupSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallStringt*    (*getAtNDupSmallStringSmallJsonFt)   (smallJsont *self, int64_t index);
+typedef void*            (*getAtNDupVoidSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef smallContainert* (*getAtNDupSmallContainerSmallJsonFt)(smallJsont *self, int64_t index);
 
 /**
  * get number
@@ -658,7 +658,7 @@ typedef smallContainert* (*getAtNDupSmallContainerSmallJsonFt)(smallJsont *self,
  *   double type number or 0
  */
 typedef double           (*getNumSmallJsonFt)                 (smallJsont *self, const char *key);
-typedef double           (*getNumAtSmallJsonFt)               (smallJsont *self, intmax_t index);
+typedef double           (*getNumAtSmallJsonFt)               (smallJsont *self, int64_t index);
 
 /**
  * delete element
@@ -696,7 +696,7 @@ typedef smallJsont*      (*delElemSmallJsonFt)              (smallJsont *self, c
  *   0  success
  *   -1 error
  */
-typedef smallJsont*      (*delSmallJsonFt)                  (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont*      (*delSmallJsonFt)                  (smallJsont *self, int64_t start, int64_t end);
 
 /**
  * delete element
@@ -714,7 +714,7 @@ typedef smallJsont*      (*delSmallJsonFt)                  (smallJsont *self, i
  * To dispose a and be able to free all objects, the element at index 0 must be freed with delElem
  * The sObject at index 1 and in s are identical, so the element 1 is freed when s is freed
  */
-typedef smallJsont*      (*delElemIndexSmallJsonFt)         (smallJsont *self, intmax_t index);
+typedef smallJsont*      (*delElemIndexSmallJsonFt)         (smallJsont *self, int64_t index);
 
 /**
  * remove without freeing element
@@ -753,7 +753,7 @@ typedef smallJsont*      (*removeElemSmallJsonFt)           (smallJsont *self, c
  *   0  success
  *   -1 error
  */
-typedef smallJsont*      (*removeSmallJsonFt)               (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont*      (*removeSmallJsonFt)               (smallJsont *self, int64_t start, int64_t end);
 
 /**
  * remove without freeing element
@@ -772,7 +772,7 @@ typedef smallJsont*      (*removeSmallJsonFt)               (smallJsont *self, i
  * // to do so, it uses removeElemG since S will free the sString object
  * removeElemG(a, 0);
  */
-typedef smallJsont*      (*removeElemIndexSmallJsonFt)      (smallJsont *self, intmax_t index);
+typedef smallJsont*      (*removeElemIndexSmallJsonFt)      (smallJsont *self, int64_t index);
 
  /**
  * push value to json
@@ -1094,7 +1094,7 @@ typedef smallJsont*          (*addJsonSmallJsonFt)   (smallJsont *self, smallJso
  *   0  success
  *   -1 error
  */
-typedef smallJsont*          (*sliceSmallJsonFt)     (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont*          (*sliceSmallJsonFt)     (smallJsont *self, int64_t start, int64_t end);
 
 /**
  * Crop elements from start to end
@@ -1116,9 +1116,9 @@ typedef smallJsont*          (*sliceSmallJsonFt)     (smallJsont *self, intmax_t
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallJsont*      (*cropSmallJsonFt)                      (smallJsont *self, intmax_t start, intmax_t end);
-typedef char*            (*cropSSmallJsonFt)                     (smallJsont *self, intmax_t start, intmax_t end);
-typedef smallStringt*    (*cropSmallStringSmallJsonFt)           (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont*      (*cropSmallJsonFt)                      (smallJsont *self, int64_t start, int64_t end);
+typedef char*            (*cropSSmallJsonFt)                     (smallJsont *self, int64_t start, int64_t end);
+typedef smallStringt*    (*cropSmallStringSmallJsonFt)           (smallJsont *self, int64_t start, int64_t end);
 
 
 /**
@@ -1134,26 +1134,26 @@ typedef smallStringt*    (*cropSmallStringSmallJsonFt)           (smallJsont *se
  *   unchanged when list is empty
  *   NULL error
  */
-typedef baset*           (*cropElemAtSmallJsonFt)                (smallJsont *self, intmax_t index);
-typedef undefinedt*      (*cropElemAtUndefinedSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef bool             (*cropElemAtBoolSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef double           (*cropElemAtDoubleSmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef int64_t          (*cropElemAtIntSmallJsonFt)             (smallJsont *self, intmax_t index);
-typedef int32_t          (*cropElemAtInt32SmallJsonFt)           (smallJsont *self, intmax_t index);
-typedef uint64_t         (*cropElemAtUintSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef uint32_t         (*cropElemAtUint32SmallJsonFt)          (smallJsont *self, intmax_t index);
-typedef char*            (*cropElemAtSSmallJsonFt)               (smallJsont *self, intmax_t index);
-typedef char             (*cropElemAtCharSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef smallDictt*      (*cropElemAtDictSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef smallArrayt*     (*cropElemAtArraySmallJsonFt)           (smallJsont *self, intmax_t index);
-typedef smallBoolt*      (*cropElemAtSmallBoolSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef smallBytest*     (*cropElemAtSmallBytesSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef smallDoublet*    (*cropElemAtSmallDoubleSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef smallIntt*       (*cropElemAtSmallIntSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef smallJsont*      (*cropElemAtSmallJsonSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef smallStringt*    (*cropElemAtSmallStringSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef void*            (*cropElemAtVoidSmallJsonFt)            (smallJsont *self, intmax_t index);
-typedef smallContainert* (*cropElemAtSmallContainerSmallJsonFt)  (smallJsont *self, intmax_t index);
+typedef baset*           (*cropElemAtSmallJsonFt)                (smallJsont *self, int64_t index);
+typedef undefinedt*      (*cropElemAtUndefinedSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef bool             (*cropElemAtBoolSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef double           (*cropElemAtDoubleSmallJsonFt)          (smallJsont *self, int64_t index);
+typedef int64_t          (*cropElemAtIntSmallJsonFt)             (smallJsont *self, int64_t index);
+typedef int32_t          (*cropElemAtInt32SmallJsonFt)           (smallJsont *self, int64_t index);
+typedef uint64_t         (*cropElemAtUintSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef uint32_t         (*cropElemAtUint32SmallJsonFt)          (smallJsont *self, int64_t index);
+typedef char*            (*cropElemAtSSmallJsonFt)               (smallJsont *self, int64_t index);
+typedef char             (*cropElemAtCharSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef smallDictt*      (*cropElemAtDictSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef smallArrayt*     (*cropElemAtArraySmallJsonFt)           (smallJsont *self, int64_t index);
+typedef smallBoolt*      (*cropElemAtSmallBoolSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef smallBytest*     (*cropElemAtSmallBytesSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef smallDoublet*    (*cropElemAtSmallDoubleSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef smallIntt*       (*cropElemAtSmallIntSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef smallJsont*      (*cropElemAtSmallJsonSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef smallStringt*    (*cropElemAtSmallStringSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef void*            (*cropElemAtVoidSmallJsonFt)            (smallJsont *self, int64_t index);
+typedef smallContainert* (*cropElemAtSmallContainerSmallJsonFt)  (smallJsont *self, int64_t index);
 
 /**
  * Crop an Element
@@ -1202,7 +1202,7 @@ typedef smallContainert* (*cropElemKeySmallContainerSmallJsonFt) (smallJsont *se
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallJsont* (*copySmallJsonFt)          (smallJsont *self, intmax_t start, intmax_t end);
+typedef smallJsont* (*copySmallJsonFt)          (smallJsont *self, int64_t start, int64_t end);
 
 /**
  * insert array in self at index
@@ -1220,10 +1220,10 @@ typedef smallJsont* (*copySmallJsonFt)          (smallJsont *self, intmax_t star
  *   unchanged array when array is NULL or invalid index
  *   NULL error
  */
-typedef smallJsont*          (*insertSmallJsonFt)          (smallJsont *self, intmax_t index, smallArrayt *toInsert);
-typedef smallJsont*          (*insertNSmashSmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *toInsert);
-typedef smallJsont*          (*insertSmallJsonSmallJsonFt)      (smallJsont *self, intmax_t index, smallJsont *toInsert);
-typedef smallJsont*          (*insertNSmashSmallJsonSmallJsonFt)(smallJsont *self, intmax_t index, smallJsont *toInsert);
+typedef smallJsont*          (*insertSmallJsonFt)          (smallJsont *self, int64_t index, smallArrayt *toInsert);
+typedef smallJsont*          (*insertNSmashSmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *toInsert);
+typedef smallJsont*          (*insertSmallJsonSmallJsonFt)      (smallJsont *self, int64_t index, smallJsont *toInsert);
+typedef smallJsont*          (*insertNSmashSmallJsonSmallJsonFt)(smallJsont *self, int64_t index, smallJsont *toInsert);
 
 /**
  * insert smallString in self at index
@@ -1240,10 +1240,10 @@ typedef smallJsont*          (*insertNSmashSmallJsonSmallJsonFt)(smallJsont *sel
  *   self smallString
  *   NULL unchanged smallString when smallString is NULL or invalid index
  */
-typedef smallJsont* (*insertStringSmallJsonFt)    (smallJsont *self, intmax_t index, smallStringt *toInsert);
-typedef smallJsont* (*insertSSmallJsonFt)    (smallJsont *self, intmax_t index, const char *toInsert);
-typedef smallJsont* (*insertNFreeStringSmallJsonFt)(smallJsont *self, intmax_t index, smallStringt *toInsert);
-typedef smallJsont* (*insertSNFreeSmallJsonFt)    (smallJsont *self, intmax_t index, char *toInsert);
+typedef smallJsont* (*insertStringSmallJsonFt)    (smallJsont *self, int64_t index, smallStringt *toInsert);
+typedef smallJsont* (*insertSSmallJsonFt)    (smallJsont *self, int64_t index, const char *toInsert);
+typedef smallJsont* (*insertNFreeStringSmallJsonFt)(smallJsont *self, int64_t index, smallStringt *toInsert);
+typedef smallJsont* (*insertSNFreeSmallJsonFt)    (smallJsont *self, int64_t index, char *toInsert);
 
 /**
  * inject an element in self at index
@@ -1260,37 +1260,37 @@ typedef smallJsont* (*insertSNFreeSmallJsonFt)    (smallJsont *self, intmax_t in
  *   unchanged array when array is NULL or invalid index
  *   NULL error
  */
-typedef smallJsont* (*injectSmallJsonFt)     (smallJsont *self, intmax_t index, baset *toInject);
-typedef smallJsont* (*injectUndefinedSmallJsonFt)(smallJsont *self, intmax_t index);
-typedef smallJsont* (*injectBoolSmallJsonFt)     (smallJsont *self, intmax_t index, bool toInject);
-typedef smallJsont* (*injectDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, double toInject);
-typedef smallJsont* (*injectIntSmallJsonFt)      (smallJsont *self, intmax_t index, int64_t toInject);
-typedef smallJsont* (*injectSSmallJsonFt)        (smallJsont *self, intmax_t index, const char *toInject);
-typedef smallJsont* (*injectCharSmallJsonFt)     (smallJsont *self, intmax_t index, char c);
-typedef smallJsont* (*injectDictSmallJsonFt)     (smallJsont *self, intmax_t index, smallDictt *toInject);
-typedef smallJsont* (*injectArraySmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *toInject);
-typedef smallJsont* (*injectArraycSmallJsonFt)   (smallJsont *self, intmax_t index, char **toInject);
-typedef smallJsont* (*injectSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index, smallBoolt *toInject);
-typedef smallJsont* (*injectSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index, smallBytest *toInject);
-typedef smallJsont* (*injectSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, smallDoublet *toInject);
-typedef smallJsont* (*injectSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index, smallIntt *toInject);
-typedef smallJsont* (*injectSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index, smallJsont *toInject);
-typedef smallJsont* (*injectSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index, smallStringt *toInject);
-typedef smallJsont* (*injectSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index, smallContainert *toInject);
-
-typedef smallJsont* (*injectNFreeSmallJsonFt)         (smallJsont *self, intmax_t index, baset *toInject);
-typedef smallJsont* (*injectNFreeUndefinedSmallJsonFt)(smallJsont *self, intmax_t index, undefinedt *undefined);
-typedef smallJsont* (*injectNFreeSSmallJsonFt)        (smallJsont *self, intmax_t index, char *toInject);
-typedef smallJsont* (*injectNFreeDictSmallJsonFt)     (smallJsont *self, intmax_t index, smallDictt *toInject);
-typedef smallJsont* (*injectNFreeArraySmallJsonFt)    (smallJsont *self, intmax_t index, smallArrayt *toInject);
-typedef smallJsont* (*injectNFreeArraycSmallJsonFt)   (smallJsont *self, intmax_t index, char **toInject);
-typedef smallJsont* (*injectNFreeSmallBoolSmallJsonFt)     (smallJsont *self, intmax_t index, smallBoolt *toInject);
-typedef smallJsont* (*injectNFreeSmallBytesSmallJsonFt)    (smallJsont *self, intmax_t index, smallBytest *toInject);
-typedef smallJsont* (*injectNFreeSmallDoubleSmallJsonFt)   (smallJsont *self, intmax_t index, smallDoublet *toInject);
-typedef smallJsont* (*injectNFreeSmallIntSmallJsonFt)      (smallJsont *self, intmax_t index, smallIntt *toInject);
-typedef smallJsont* (*injectNFreeSmallJsonSmallJsonFt)     (smallJsont *self, intmax_t index, smallJsont *toInject);
-typedef smallJsont* (*injectNFreeSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index, smallStringt *toInject);
-typedef smallJsont* (*injectNFreeSmallContainerSmallJsonFt)(smallJsont *self, intmax_t index, smallContainert *toInject);
+typedef smallJsont* (*injectSmallJsonFt)     (smallJsont *self, int64_t index, baset *toInject);
+typedef smallJsont* (*injectUndefinedSmallJsonFt)(smallJsont *self, int64_t index);
+typedef smallJsont* (*injectBoolSmallJsonFt)     (smallJsont *self, int64_t index, bool toInject);
+typedef smallJsont* (*injectDoubleSmallJsonFt)   (smallJsont *self, int64_t index, double toInject);
+typedef smallJsont* (*injectIntSmallJsonFt)      (smallJsont *self, int64_t index, int64_t toInject);
+typedef smallJsont* (*injectSSmallJsonFt)        (smallJsont *self, int64_t index, const char *toInject);
+typedef smallJsont* (*injectCharSmallJsonFt)     (smallJsont *self, int64_t index, char c);
+typedef smallJsont* (*injectDictSmallJsonFt)     (smallJsont *self, int64_t index, smallDictt *toInject);
+typedef smallJsont* (*injectArraySmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *toInject);
+typedef smallJsont* (*injectArraycSmallJsonFt)   (smallJsont *self, int64_t index, char **toInject);
+typedef smallJsont* (*injectSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index, smallBoolt *toInject);
+typedef smallJsont* (*injectSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index, smallBytest *toInject);
+typedef smallJsont* (*injectSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index, smallDoublet *toInject);
+typedef smallJsont* (*injectSmallIntSmallJsonFt)      (smallJsont *self, int64_t index, smallIntt *toInject);
+typedef smallJsont* (*injectSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index, smallJsont *toInject);
+typedef smallJsont* (*injectSmallStringSmallJsonFt)   (smallJsont *self, int64_t index, smallStringt *toInject);
+typedef smallJsont* (*injectSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *toInject);
+
+typedef smallJsont* (*injectNFreeSmallJsonFt)         (smallJsont *self, int64_t index, baset *toInject);
+typedef smallJsont* (*injectNFreeUndefinedSmallJsonFt)(smallJsont *self, int64_t index, undefinedt *undefined);
+typedef smallJsont* (*injectNFreeSSmallJsonFt)        (smallJsont *self, int64_t index, char *toInject);
+typedef smallJsont* (*injectNFreeDictSmallJsonFt)     (smallJsont *self, int64_t index, smallDictt *toInject);
+typedef smallJsont* (*injectNFreeArraySmallJsonFt)    (smallJsont *self, int64_t index, smallArrayt *toInject);
+typedef smallJsont* (*injectNFreeArraycSmallJsonFt)   (smallJsont *self, int64_t index, char **toInject);
+typedef smallJsont* (*injectNFreeSmallBoolSmallJsonFt)     (smallJsont *self, int64_t index, smallBoolt *toInject);
+typedef smallJsont* (*injectNFreeSmallBytesSmallJsonFt)    (smallJsont *self, int64_t index, smallBytest *toInject);
+typedef smallJsont* (*injectNFreeSmallDoubleSmallJsonFt)   (smallJsont *self, int64_t index, smallDoublet *toInject);
+typedef smallJsont* (*injectNFreeSmallIntSmallJsonFt)      (smallJsont *self, int64_t index, smallIntt *toInject);
+typedef smallJsont* (*injectNFreeSmallJsonSmallJsonFt)     (smallJsont *self, int64_t index, smallJsont *toInject);
+typedef smallJsont* (*injectNFreeSmallStringSmallJsonFt)   (smallJsont *self, int64_t index, smallStringt *toInject);
+typedef smallJsont* (*injectNFreeSmallContainerSmallJsonFt)(smallJsont *self, int64_t index, smallContainert *toInject);
 
 /**
  * Uniquify elements of list
@@ -1763,10 +1763,10 @@ typedef bool (*icEqualCharSmallJsonFt)       (smallJsont *self, char c);
  *   true smallString at index is equal to string
  *   false they differ
  */
-typedef bool     (*equalISSmallJsonFt)   (smallJsont *self, const char *string, intmax_t index);
-typedef bool     (*equalICharSmallJsonFt)(smallJsont *self, char c, intmax_t index);
-typedef bool     (*equalIJsonSmallJsonFt)(smallJsont *self, smallJsont *string, intmax_t index);
-typedef bool     (*equalISmallStringSmallJsonFt)   (smallJsont *self, smallStringt *string, intmax_t index);
+typedef bool     (*equalISSmallJsonFt)   (smallJsont *self, const char *string, int64_t index);
+typedef bool     (*equalICharSmallJsonFt)(smallJsont *self, char c, int64_t index);
+typedef bool     (*equalIJsonSmallJsonFt)(smallJsont *self, smallJsont *string, int64_t index);
+typedef bool     (*equalISmallStringSmallJsonFt)   (smallJsont *self, smallStringt *string, int64_t index);
 
 /**
  * starts With String
@@ -1899,9 +1899,9 @@ typedef bool (*isIntSmallJsonFt) (smallJsont *self);
  * \return
  *   int64_t
  *   0 when smallString represents 0 or doesnt represent a number or the input is NULL
- *   INTMAX_MAX or INTMAX_MIN for strtoimax parse errors.
+ *   INT64_MAX or INT64_MIN for strtoll parse errors.
  */
-typedef intmax_t (*parseIntSmallJsonFt)  (smallJsont *self);
+typedef int64_t (*parseIntSmallJsonFt)  (smallJsont *self);
 
 /**
  * convert self to double
@@ -1918,9 +1918,9 @@ typedef double (*parseDoubleSmallJsonFt)  (smallJsont *self);
  * convert int to smallString, assign result to self
  *
  * \param
- *   intmax_t number
+ *   int64_t number
  */
-typedef smallJsont*     (*intToSmallJsonFt)     (smallJsont *self, intmax_t n);
+typedef smallJsont*     (*intToSmallJsonFt)     (smallJsont *self, int64_t n);
 
 /**
  * double To String
@@ -2286,14 +2286,14 @@ typedef smallJsont*  (*zipCArrayJsonSmallJsonFt)    (smallJsont *self, const cha
 typedef baset*         (*iterStartSmallJsonFt)        (smallJsont *self);
 typedef const char*    (*iterStartKeySmallJsonFt)     (smallJsont *self);
 typedef baset*         (*iterStartLastSmallJsonFt)    (smallJsont *self);
-typedef baset*         (*iterStartFromSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef baset*         (*iterStartFromStepSmallJsonFt)(smallJsont *self, intmax_t index, intmax_t step);
+typedef baset*         (*iterStartFromSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef baset*         (*iterStartFromStepSmallJsonFt)(smallJsont *self, int64_t index, int64_t step);
 typedef baset*         (*iterNextSmallJsonFt)         (smallJsont *self);
 typedef const char*    (*iterNextKeySmallJsonFt)      (smallJsont *self);
 typedef baset*         (*iterElementSmallJsonFt)      (smallJsont *self);
 typedef const char*    (*iterKeySmallJsonFt)          (smallJsont *self);
 typedef ssize_t        (*iterIndexSmallJsonFt)        (smallJsont *self);
-typedef intmax_t       (*iterStepSmallJsonFt)         (smallJsont *self);
+typedef int64_t       (*iterStepSmallJsonFt)         (smallJsont *self);
 
 /**
  * stringify self
@@ -2493,8 +2493,8 @@ typedef bool          (*appendTextJsonSmallJsonFt)       (smallJsont *self, smal
  */
 typedef const char*   (*typeStringSmallJsonFt)          (smallJsont *self, const char *key);
 typedef smallStringt* (*typeSmallStringSmallJsonFt)     (smallJsont *self, const char *key);
-typedef const char*   (*typeAtStringSmallJsonFt)        (smallJsont *self, intmax_t index);
-typedef smallStringt* (*typeAtSmallStringSmallJsonFt)   (smallJsont *self, intmax_t index);
+typedef const char*   (*typeAtStringSmallJsonFt)        (smallJsont *self, int64_t index);
+typedef smallStringt* (*typeAtSmallStringSmallJsonFt)   (smallJsont *self, int64_t index);
 
 typedef const char*   (*typeStringKCharSmallJsonFt)     (smallJsont *self, char key);
 typedef smallStringt* (*typeSmallStringKCharSmallJsonFt)(smallJsont *self, char key);
@@ -2509,7 +2509,7 @@ typedef smallStringt* (*typeSmallStringKCharSmallJsonFt)(smallJsont *self, char 
  */
 typedef char         (*typeSmallJsonFt)       (smallJsont *self, const char *key);
 typedef char         (*typeKCharSmallJsonFt)  (smallJsont *self, char key);
-typedef char         (*typeAtSmallJsonFt)     (smallJsont *self, intmax_t index);
+typedef char         (*typeAtSmallJsonFt)     (smallJsont *self, int64_t index);
 
 /**
  * get first level of object type string in json
@@ -2530,17 +2530,17 @@ typedef smallBytest* (*typesSmallJsonFt)          (smallJsont *self);
 /**
  * is element at index of type type
  */
-typedef bool (*isETypeAtSmallJsonFt)      (smallJsont *self, intmax_t index, const char *type);
-typedef bool (*isEUndefinedAtSmallJsonFt) (smallJsont *self, intmax_t index);
-typedef bool (*isEBoolAtSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef bool (*isEContainerAtSmallJsonFt) (smallJsont *self, intmax_t index);
-typedef bool (*isEDictAtSmallJsonFt)      (smallJsont *self, intmax_t index);
-typedef bool (*isEDoubleAtSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef bool (*isEIntAtSmallJsonFt)       (smallJsont *self, intmax_t index);
-typedef bool (*isEStringAtSmallJsonFt)    (smallJsont *self, intmax_t index);
-typedef bool (*isEFaststringAtSmallJsonFt)(smallJsont *self, intmax_t index);
-typedef bool (*isEArrayAtSmallJsonFt)     (smallJsont *self, intmax_t index);
-typedef bool (*isEBytesAtSmallJsonFt)     (smallJsont *self, intmax_t index);
+typedef bool (*isETypeAtSmallJsonFt)      (smallJsont *self, int64_t index, const char *type);
+typedef bool (*isEUndefinedAtSmallJsonFt) (smallJsont *self, int64_t index);
+typedef bool (*isEBoolAtSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef bool (*isEContainerAtSmallJsonFt) (smallJsont *self, int64_t index);
+typedef bool (*isEDictAtSmallJsonFt)      (smallJsont *self, int64_t index);
+typedef bool (*isEDoubleAtSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef bool (*isEIntAtSmallJsonFt)       (smallJsont *self, int64_t index);
+typedef bool (*isEStringAtSmallJsonFt)    (smallJsont *self, int64_t index);
+typedef bool (*isEFaststringAtSmallJsonFt)(smallJsont *self, int64_t index);
+typedef bool (*isEArrayAtSmallJsonFt)     (smallJsont *self, int64_t index);
+typedef bool (*isEBytesAtSmallJsonFt)     (smallJsont *self, int64_t index);
 
 /**
  * is element at key of type type
@@ -3469,7 +3469,7 @@ struct smallJson {
   void        **propertyOrValue;
   ssize_t     iterIndex;
   char*       iterKey;
-  intmax_t    iterStep;
+  int64_t    iterStep;
   baset*      iterElement;
 };
 
@@ -3713,48 +3713,48 @@ smallJsont* setNFreePArraySmallJsonG      (smallJsont *self, const char *key, sm
 smallJsont* setNFreePSmallJsonSmallJsonG  (smallJsont *self, const char *key, smallJsont *value);
 smallJsont* setNFreePSmallStringSmallJsonG(smallJsont *self, const char *key, smallStringt *string);
 
-smallJsont* setAtSmallJsonG         (smallJsont *self, intmax_t index, baset *value);
-smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtBoolSmallJsonG     (smallJsont *self, intmax_t index, bool value);
-smallJsont* setAtDoubleSmallJsonG   (smallJsont *self, intmax_t index, double value);
-smallJsont* setAtIntSmallJsonG      (smallJsont *self, intmax_t index, int64_t value);
-smallJsont* setAtSSmallJsonG        (smallJsont *self, intmax_t index, const char *string);
-smallJsont* setAtCharSmallJsonG     (smallJsont *self, intmax_t index, char c);
-smallJsont* setAtDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setAtArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setAtArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* setAtCArraycSmallJsonG  (smallJsont *self, intmax_t index, const char **array);
-smallJsont* setAtVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* setAtSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* setAtSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* setAtSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* setAtSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setAtSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* setAtSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
-smallJsont* setAtNFreeSmallJsonG         (smallJsont *self, intmax_t index, baset *value);
-smallJsont* setAtNFreeUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtNFreeSSmallJsonG        (smallJsont *self, intmax_t index, char *string);
-smallJsont* setAtNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setAtNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setAtNFreeArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* setAtNFreeVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* setAtNFreeSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* setAtNFreeSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* setAtNFreeSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* setAtNFreeSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* setAtNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setAtNFreeSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* setAtNFreeSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
-
-smallJsont* setPAtDictSmallJsonG              (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setPAtArraySmallJsonG             (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setPAtSmallJsonSmallJsonG         (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setPAtSmallStringSmallJsonG       (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* setPAtNFreeDictSmallJsonG         (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* setPAtNFreeArraySmallJsonG        (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* setPAtNFreeSmallJsonSmallJsonG    (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* setPAtNFreeSmallStringSmallJsonG  (smallJsont *self, intmax_t index, smallStringt *string);
+smallJsont* setAtSmallJsonG         (smallJsont *self, int64_t index, baset *value);
+smallJsont* setAtUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* setAtBoolSmallJsonG     (smallJsont *self, int64_t index, bool value);
+smallJsont* setAtDoubleSmallJsonG   (smallJsont *self, int64_t index, double value);
+smallJsont* setAtIntSmallJsonG      (smallJsont *self, int64_t index, int64_t value);
+smallJsont* setAtSSmallJsonG        (smallJsont *self, int64_t index, const char *string);
+smallJsont* setAtCharSmallJsonG     (smallJsont *self, int64_t index, char c);
+smallJsont* setAtDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setAtArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setAtArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* setAtCArraycSmallJsonG  (smallJsont *self, int64_t index, const char **array);
+smallJsont* setAtVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* setAtSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* setAtSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* setAtSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* setAtSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* setAtSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setAtSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* setAtSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
+smallJsont* setAtNFreeSmallJsonG         (smallJsont *self, int64_t index, baset *value);
+smallJsont* setAtNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* setAtNFreeSSmallJsonG        (smallJsont *self, int64_t index, char *string);
+smallJsont* setAtNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setAtNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setAtNFreeArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* setAtNFreeVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* setAtNFreeSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* setAtNFreeSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* setAtNFreeSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* setAtNFreeSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* setAtNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setAtNFreeSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* setAtNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
+
+smallJsont* setPAtDictSmallJsonG              (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setPAtArraySmallJsonG             (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setPAtSmallJsonSmallJsonG         (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setPAtSmallStringSmallJsonG       (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* setPAtNFreeDictSmallJsonG         (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* setPAtNFreeArraySmallJsonG        (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* setPAtNFreeSmallJsonSmallJsonG    (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* setPAtNFreeSmallStringSmallJsonG  (smallJsont *self, int64_t index, smallStringt *string);
 
 baset*           getSmallJsonG              (smallJsont *self, baset* retType UNUSED, const char *key);
 undefinedt*      getUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, const char *key);
@@ -3802,63 +3802,63 @@ smallStringt*    getNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt*
 void*            getNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, const char *key);
 smallContainert* getNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, const char *key);
 
-baset*           getAtSmallJsonG              (smallJsont *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, intmax_t index);
-bool*            getAtBoolPSmallJsonG         (smallJsont *self, bool* retType UNUSED, intmax_t index);
-double           getAtDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, intmax_t index);
-double*          getAtDoublePSmallJsonG       (smallJsont *self, double* retType UNUSED, intmax_t index);
-int64_t          getAtIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, intmax_t index);
-int64_t*         getAtIntPSmallJsonG          (smallJsont *self, int64_t* retType UNUSED, intmax_t index);
-int32_t          getAtInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, intmax_t index);
-int32_t*         getAtInt32PSmallJsonG        (smallJsont *self, int32_t* retType UNUSED, intmax_t index);
-uint64_t         getAtUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, intmax_t index);
-uint64_t*        getAtUintPSmallJsonG         (smallJsont *self, uint64_t* retType UNUSED, intmax_t index);
-uint32_t         getAtUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, intmax_t index);
-uint32_t*        getAtUint32PSmallJsonG       (smallJsont *self, uint32_t* retType UNUSED, intmax_t index);
-char*            getAtSSmallJsonG             (smallJsont *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*      getAtSmallJsonSmallJsonG     (smallJsont *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, intmax_t index);
-
-baset*           getAtNDupSmallJsonG              (smallJsont *self, baset* retType UNUSED, intmax_t index);
-undefinedt*      getAtNDupUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, intmax_t index);
-bool             getAtNDupBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, intmax_t index);
-double           getAtNDupDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, intmax_t index);
-int64_t          getAtNDupIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, intmax_t index);
-int32_t          getAtNDupInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, intmax_t index);
-uint64_t         getAtNDupUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, intmax_t index);
-uint32_t         getAtNDupUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, intmax_t index);
-char*            getAtNDupSSmallJsonG             (smallJsont *self, char* retType UNUSED, intmax_t index);
-smallDictt*      getAtNDupDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, intmax_t index);
-smallArrayt*     getAtNDupArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, intmax_t index);
-smallBoolt*      getAtNDupSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, intmax_t index);
-smallBytest*     getAtNDupSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, intmax_t index);
-smallDoublet*    getAtNDupSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, intmax_t index);
-smallIntt*       getAtNDupSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, intmax_t index);
-smallJsont*      getAtNDupSmallJsonSmallJsonG     (smallJsont *self, smallJsont* retType UNUSED, intmax_t index);
-smallStringt*    getAtNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, intmax_t index);
-void*            getAtNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, intmax_t index);
-smallContainert* getAtNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, intmax_t index);
+baset*           getAtSmallJsonG              (smallJsont *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, int64_t index);
+bool*            getAtBoolPSmallJsonG         (smallJsont *self, bool* retType UNUSED, int64_t index);
+double           getAtDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, int64_t index);
+double*          getAtDoublePSmallJsonG       (smallJsont *self, double* retType UNUSED, int64_t index);
+int64_t          getAtIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, int64_t index);
+int64_t*         getAtIntPSmallJsonG          (smallJsont *self, int64_t* retType UNUSED, int64_t index);
+int32_t          getAtInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, int64_t index);
+int32_t*         getAtInt32PSmallJsonG        (smallJsont *self, int32_t* retType UNUSED, int64_t index);
+uint64_t         getAtUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, int64_t index);
+uint64_t*        getAtUintPSmallJsonG         (smallJsont *self, uint64_t* retType UNUSED, int64_t index);
+uint32_t         getAtUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, int64_t index);
+uint32_t*        getAtUint32PSmallJsonG       (smallJsont *self, uint32_t* retType UNUSED, int64_t index);
+char*            getAtSSmallJsonG             (smallJsont *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*      getAtSmallJsonSmallJsonG     (smallJsont *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index);
+
+baset*           getAtNDupSmallJsonG              (smallJsont *self, baset* retType UNUSED, int64_t index);
+undefinedt*      getAtNDupUndefinedSmallJsonG     (smallJsont *self, undefinedt* retType UNUSED, int64_t index);
+bool             getAtNDupBoolSmallJsonG          (smallJsont *self, bool retType UNUSED, int64_t index);
+double           getAtNDupDoubleSmallJsonG        (smallJsont *self, double retType UNUSED, int64_t index);
+int64_t          getAtNDupIntSmallJsonG           (smallJsont *self, int64_t retType UNUSED, int64_t index);
+int32_t          getAtNDupInt32SmallJsonG         (smallJsont *self, int32_t retType UNUSED, int64_t index);
+uint64_t         getAtNDupUintSmallJsonG          (smallJsont *self, uint64_t retType UNUSED, int64_t index);
+uint32_t         getAtNDupUint32SmallJsonG        (smallJsont *self, uint32_t retType UNUSED, int64_t index);
+char*            getAtNDupSSmallJsonG             (smallJsont *self, char* retType UNUSED, int64_t index);
+smallDictt*      getAtNDupDictSmallJsonG          (smallJsont *self, smallDictt* retType UNUSED, int64_t index);
+smallArrayt*     getAtNDupArraySmallJsonG         (smallJsont *self, smallArrayt* retType UNUSED, int64_t index);
+smallBoolt*      getAtNDupSmallBoolSmallJsonG     (smallJsont *self, smallBoolt* retType UNUSED, int64_t index);
+smallBytest*     getAtNDupSmallBytesSmallJsonG    (smallJsont *self, smallBytest* retType UNUSED, int64_t index);
+smallDoublet*    getAtNDupSmallDoubleSmallJsonG   (smallJsont *self, smallDoublet* retType UNUSED, int64_t index);
+smallIntt*       getAtNDupSmallIntSmallJsonG      (smallJsont *self, smallIntt* retType UNUSED, int64_t index);
+smallJsont*      getAtNDupSmallJsonSmallJsonG     (smallJsont *self, smallJsont* retType UNUSED, int64_t index);
+smallStringt*    getAtNDupSmallStringSmallJsonG   (smallJsont *self, smallStringt* retType UNUSED, int64_t index);
+void*            getAtNDupVoidSmallJsonG          (smallJsont *self, void* retType UNUSED, int64_t index);
+smallContainert* getAtNDupSmallContainerSmallJsonG(smallJsont *self, smallContainert* retType UNUSED, int64_t index);
 
 double           getNumSmallJsonG                 (smallJsont *self, const char *key);
-double           getNumAtSmallJsonG               (smallJsont *self, intmax_t index);
+double           getNumAtSmallJsonG               (smallJsont *self, int64_t index);
 
 smallJsont*      delKeySmallJsonG               (smallJsont *self, const char *key, int unused UNUSED);
 smallJsont*      delElemSmallJsonG              (smallJsont *self, const char *key);
-smallJsont*      delSmallJsonG                  (smallJsont *self, intmax_t start, intmax_t end);
-smallJsont*      delElemIndexSmallJsonG         (smallJsont *self, intmax_t index);
+smallJsont*      delSmallJsonG                  (smallJsont *self, int64_t start, int64_t end);
+smallJsont*      delElemIndexSmallJsonG         (smallJsont *self, int64_t index);
 smallJsont*      removeKeySmallJsonG            (smallJsont *self, const char *key, int unused UNUSED);
 smallJsont*      removeElemSmallJsonG           (smallJsont *self, const char *key);
-smallJsont*      removeSmallJsonG               (smallJsont *self, intmax_t start, intmax_t end);
-smallJsont*      removeElemIndexSmallJsonG      (smallJsont *self, intmax_t index);
+smallJsont*      removeSmallJsonG               (smallJsont *self, int64_t start, int64_t end);
+smallJsont*      removeElemIndexSmallJsonG      (smallJsont *self, int64_t index);
 
 smallJsont* prependSmallJsonG         (smallJsont *self, baset *value);
 smallJsont* prependUndefinedSmallJsonG(smallJsont *self, void *value UNUSED);
@@ -3935,30 +3935,30 @@ smallJsont* shiftNSmashSmallJsonSmallJsonG(smallJsont *self, smallJsont *array);
 
 smallJsont* addSmallJsonG  (smallJsont *self, smallArrayt *array);
 smallJsont* addJsonSmallJsonG(smallJsont *self, smallJsont *array);
-smallJsont* sliceSmallJsonG(smallJsont *self, intmax_t start, intmax_t end);
-smallJsont* cropSmallJsonG                          (smallJsont *self, intmax_t start, intmax_t end);
-char* cropSSmallJsonG                               (smallJsont *self, intmax_t start, intmax_t end);
-smallStringt* cropSmallStringSmallJsonG             (smallJsont *self, intmax_t start, intmax_t end);
-baset* cropElemAtSmallJsonG                         (smallJsont *self, intmax_t index);
-undefinedt* cropElemAtUndefinedSmallJsonG           (smallJsont *self, intmax_t index);
-bool cropElemAtBoolSmallJsonG                       (smallJsont *self, intmax_t index);
-double cropElemAtDoubleSmallJsonG                   (smallJsont *self, intmax_t index);
-int64_t cropElemAtIntSmallJsonG                     (smallJsont *self, intmax_t index);
-int32_t cropElemAtInt32SmallJsonG                   (smallJsont *self, intmax_t index);
-uint64_t cropElemAtUintSmallJsonG                   (smallJsont *self, intmax_t index);
-uint32_t cropElemAtUint32SmallJsonG                 (smallJsont *self, intmax_t index);
-char* cropElemAtSSmallJsonG                         (smallJsont *self, intmax_t index);
-char cropElemAtCharSmallJsonG                       (smallJsont *self, intmax_t index);
-smallDictt* cropElemAtDictSmallJsonG                (smallJsont *self, intmax_t index);
-smallArrayt* cropElemAtArraySmallJsonG              (smallJsont *self, intmax_t index);
-smallBoolt* cropElemAtSmallBoolSmallJsonG           (smallJsont *self, intmax_t index);
-smallBytest* cropElemAtSmallBytesSmallJsonG         (smallJsont *self, intmax_t index);
-smallDoublet* cropElemAtSmallDoubleSmallJsonG       (smallJsont *self, intmax_t index);
-smallIntt* cropElemAtSmallIntSmallJsonG             (smallJsont *self, intmax_t index);
-smallJsont* cropElemAtSmallJsonSmallJsonG           (smallJsont *self, intmax_t index);
-smallStringt* cropElemAtSmallStringSmallJsonG       (smallJsont *self, intmax_t index);
-void* cropElemAtVoidSmallJsonG                      (smallJsont *self, intmax_t index);
-smallContainert* cropElemAtSmallContainerSmallJsonG (smallJsont *self, intmax_t index);
+smallJsont* sliceSmallJsonG(smallJsont *self, int64_t start, int64_t end);
+smallJsont* cropSmallJsonG                          (smallJsont *self, int64_t start, int64_t end);
+char* cropSSmallJsonG                               (smallJsont *self, int64_t start, int64_t end);
+smallStringt* cropSmallStringSmallJsonG             (smallJsont *self, int64_t start, int64_t end);
+baset* cropElemAtSmallJsonG                         (smallJsont *self, int64_t index);
+undefinedt* cropElemAtUndefinedSmallJsonG           (smallJsont *self, int64_t index);
+bool cropElemAtBoolSmallJsonG                       (smallJsont *self, int64_t index);
+double cropElemAtDoubleSmallJsonG                   (smallJsont *self, int64_t index);
+int64_t cropElemAtIntSmallJsonG                     (smallJsont *self, int64_t index);
+int32_t cropElemAtInt32SmallJsonG                   (smallJsont *self, int64_t index);
+uint64_t cropElemAtUintSmallJsonG                   (smallJsont *self, int64_t index);
+uint32_t cropElemAtUint32SmallJsonG                 (smallJsont *self, int64_t index);
+char* cropElemAtSSmallJsonG                         (smallJsont *self, int64_t index);
+char cropElemAtCharSmallJsonG                       (smallJsont *self, int64_t index);
+smallDictt* cropElemAtDictSmallJsonG                (smallJsont *self, int64_t index);
+smallArrayt* cropElemAtArraySmallJsonG              (smallJsont *self, int64_t index);
+smallBoolt* cropElemAtSmallBoolSmallJsonG           (smallJsont *self, int64_t index);
+smallBytest* cropElemAtSmallBytesSmallJsonG         (smallJsont *self, int64_t index);
+smallDoublet* cropElemAtSmallDoubleSmallJsonG       (smallJsont *self, int64_t index);
+smallIntt* cropElemAtSmallIntSmallJsonG             (smallJsont *self, int64_t index);
+smallJsont* cropElemAtSmallJsonSmallJsonG           (smallJsont *self, int64_t index);
+smallStringt* cropElemAtSmallStringSmallJsonG       (smallJsont *self, int64_t index);
+void* cropElemAtVoidSmallJsonG                      (smallJsont *self, int64_t index);
+smallContainert* cropElemAtSmallContainerSmallJsonG (smallJsont *self, int64_t index);
 baset* cropElemKeySmallJsonG                        (smallJsont *self, const char* key);
 undefinedt* cropElemKeyUndefinedSmallJsonG          (smallJsont *self, const char* key);
 bool cropElemKeyBoolSmallJsonG                      (smallJsont *self, const char* key);
@@ -3978,49 +3978,49 @@ smallJsont* cropElemKeySmallJsonSmallJsonG          (smallJsont *self, const cha
 smallStringt* cropElemKeySmallStringSmallJsonG      (smallJsont *self, const char* key);
 void* cropElemKeyVoidSmallJsonG                     (smallJsont *self, const char* key);
 smallContainert* cropElemKeySmallContainerSmallJsonG(smallJsont *self, const char* key);
-smallJsont* copySmallJsonG (smallJsont *self, intmax_t start, intmax_t end);
-smallJsont* insertSmallJsonG(smallJsont *self, intmax_t index, smallArrayt *toInsert);
-smallJsont* insertNSmashSmallJsonG(smallJsont *self, intmax_t index, smallArrayt *toInsert);
-smallJsont* insertSmallJsonSmallJsonG(smallJsont *self, intmax_t index, smallJsont *toInsert);
-smallJsont* insertNSmashSmallJsonSmallJsonG(smallJsont *self, intmax_t index, smallJsont *toInsert);
-smallJsont* insertStringSmallJsonG     (smallJsont *self, intmax_t index, smallStringt *toInsert);
-smallJsont* insertSSmallJsonG          (smallJsont *self, intmax_t index, const char *toInsert);
-smallJsont* insertNFreeStringSmallJsonG(smallJsont *self, intmax_t index, smallStringt *toInsert); // not used in generics
-smallJsont* insertNFreeSSmallJsonG     (smallJsont *self, intmax_t index, char *toInsert); // not used in generics
-
-smallJsont* injectSmallJsonG         (smallJsont *self, intmax_t index, baset *value);
-smallJsont* injectUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* injectBoolSmallJsonG     (smallJsont *self, intmax_t index, bool value);
-smallJsont* injectDoubleSmallJsonG   (smallJsont *self, intmax_t index, double value);
-smallJsont* injectIntSmallJsonG      (smallJsont *self, intmax_t index, int64_t value);
-smallJsont* injectSSmallJsonG        (smallJsont *self, intmax_t index, const char *string);
-smallJsont* injectCharSmallJsonG(smallJsont *self, intmax_t index, char c);
-smallJsont* injectDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* injectArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* injectArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* injectCArraycSmallJsonG   (smallJsont *self, intmax_t index, const char **array);
-smallJsont* injectVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* injectSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* injectSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* injectSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* injectSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* injectSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* injectSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* injectSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
-smallJsont* injectNFreeSmallJsonG    (smallJsont *self, intmax_t index, baset *value);
-smallJsont* injectNFreeUndefinedSmallJsonG(smallJsont *self, intmax_t index, void *value);
-smallJsont* injectNFreeSSmallJsonG        (smallJsont *self, intmax_t index, char *string);
-smallJsont* injectNFreeDictSmallJsonG     (smallJsont *self, intmax_t index, smallDictt *dict);
-smallJsont* injectNFreeArraySmallJsonG    (smallJsont *self, intmax_t index, smallArrayt *array);
-smallJsont* injectNFreeArraycSmallJsonG   (smallJsont *self, intmax_t index, char **array);
-smallJsont* injectNFreeVoidSmallJsonG     (smallJsont *self, intmax_t index, void *value);
-smallJsont* injectNFreeSmallBoolSmallJsonG     (smallJsont *self, intmax_t index, smallBoolt *value);
-smallJsont* injectNFreeSmallBytesSmallJsonG    (smallJsont *self, intmax_t index, smallBytest *value);
-smallJsont* injectNFreeSmallDoubleSmallJsonG   (smallJsont *self, intmax_t index, smallDoublet *value);
-smallJsont* injectNFreeSmallIntSmallJsonG      (smallJsont *self, intmax_t index, smallIntt *value);
-smallJsont* injectNFreeSmallJsonSmallJsonG     (smallJsont *self, intmax_t index, smallJsont *value);
-smallJsont* injectNFreeSmallStringSmallJsonG   (smallJsont *self, intmax_t index, smallStringt *string);
-smallJsont* injectNFreeSmallContainerSmallJsonG(smallJsont *self, intmax_t index, smallContainert *container);
+smallJsont* copySmallJsonG (smallJsont *self, int64_t start, int64_t end);
+smallJsont* insertSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert);
+smallJsont* insertNSmashSmallJsonG(smallJsont *self, int64_t index, smallArrayt *toInsert);
+smallJsont* insertSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert);
+smallJsont* insertNSmashSmallJsonSmallJsonG(smallJsont *self, int64_t index, smallJsont *toInsert);
+smallJsont* insertStringSmallJsonG     (smallJsont *self, int64_t index, smallStringt *toInsert);
+smallJsont* insertSSmallJsonG          (smallJsont *self, int64_t index, const char *toInsert);
+smallJsont* insertNFreeStringSmallJsonG(smallJsont *self, int64_t index, smallStringt *toInsert); // not used in generics
+smallJsont* insertNFreeSSmallJsonG     (smallJsont *self, int64_t index, char *toInsert); // not used in generics
+
+smallJsont* injectSmallJsonG         (smallJsont *self, int64_t index, baset *value);
+smallJsont* injectUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* injectBoolSmallJsonG     (smallJsont *self, int64_t index, bool value);
+smallJsont* injectDoubleSmallJsonG   (smallJsont *self, int64_t index, double value);
+smallJsont* injectIntSmallJsonG      (smallJsont *self, int64_t index, int64_t value);
+smallJsont* injectSSmallJsonG        (smallJsont *self, int64_t index, const char *string);
+smallJsont* injectCharSmallJsonG(smallJsont *self, int64_t index, char c);
+smallJsont* injectDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* injectArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* injectArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* injectCArraycSmallJsonG   (smallJsont *self, int64_t index, const char **array);
+smallJsont* injectVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* injectSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* injectSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* injectSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* injectSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* injectSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* injectSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* injectSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
+smallJsont* injectNFreeSmallJsonG    (smallJsont *self, int64_t index, baset *value);
+smallJsont* injectNFreeUndefinedSmallJsonG(smallJsont *self, int64_t index, void *value);
+smallJsont* injectNFreeSSmallJsonG        (smallJsont *self, int64_t index, char *string);
+smallJsont* injectNFreeDictSmallJsonG     (smallJsont *self, int64_t index, smallDictt *dict);
+smallJsont* injectNFreeArraySmallJsonG    (smallJsont *self, int64_t index, smallArrayt *array);
+smallJsont* injectNFreeArraycSmallJsonG   (smallJsont *self, int64_t index, char **array);
+smallJsont* injectNFreeVoidSmallJsonG     (smallJsont *self, int64_t index, void *value);
+smallJsont* injectNFreeSmallBoolSmallJsonG     (smallJsont *self, int64_t index, smallBoolt *value);
+smallJsont* injectNFreeSmallBytesSmallJsonG    (smallJsont *self, int64_t index, smallBytest *value);
+smallJsont* injectNFreeSmallDoubleSmallJsonG   (smallJsont *self, int64_t index, smallDoublet *value);
+smallJsont* injectNFreeSmallIntSmallJsonG      (smallJsont *self, int64_t index, smallIntt *value);
+smallJsont* injectNFreeSmallJsonSmallJsonG     (smallJsont *self, int64_t index, smallJsont *value);
+smallJsont* injectNFreeSmallStringSmallJsonG   (smallJsont *self, int64_t index, smallStringt *string);
+smallJsont* injectNFreeSmallContainerSmallJsonG(smallJsont *self, int64_t index, smallContainert *container);
 
 smallJsont* uniqSmallJsonG(smallJsont *self, char c);
 smallJsont* icUniqSmallJsonG(smallJsont *self, char c);
@@ -4202,10 +4202,10 @@ bool icEqualSmallJsonSmallJsonG  (smallJsont* self, smallJsont* p2);
 bool icEqualSmallJsonSmallStringG(smallJsont* self, smallStringt* p2);
 bool icEqualCharSmallJsonG       (smallJsont *self, char c);
 bool icEqualSSmallJsonG          (smallJsont *self, const char *string);
-bool    equalISSmallJsonG                (smallJsont *self, const char *string, intmax_t index);
-bool    equalICharSmallJsonG             (smallJsont *self, char c, intmax_t index);
-bool    equalIJsonSmallJsonG             (smallJsont *self, smallJsont *string, intmax_t index);
-bool    equalISmallStringSmallJsonG      (smallJsont *self, smallStringt *string, intmax_t index);
+bool    equalISSmallJsonG                (smallJsont *self, const char *string, int64_t index);
+bool    equalICharSmallJsonG             (smallJsont *self, char c, int64_t index);
+bool    equalIJsonSmallJsonG             (smallJsont *self, smallJsont *string, int64_t index);
+bool    equalISmallStringSmallJsonG      (smallJsont *self, smallStringt *string, int64_t index);
 bool    startsWithSSmallJsonG            (smallJsont *self, const char *string);
 bool    startsWithCharSmallJsonG         (smallJsont *self, char c);
 bool    startsWithSmallStringSmallJsonG  (smallJsont *self, smallStringt *string);
@@ -4232,9 +4232,9 @@ ssize_t icCountSmallStringSmallJsonG     (smallJsont *self, smallStringt *string
 ssize_t icCountJsonSmallJsonG            (smallJsont *self, smallJsont *string);
 bool    isNumberSmallJsonG               (smallJsont *self);
 bool    isIntSmallJsonG                  (smallJsont *self);
-intmax_t parseIntSmallJsonG      (smallJsont *self);
+int64_t parseIntSmallJsonG      (smallJsont *self);
 double   parseDoubleSmallJsonG   (smallJsont *self);
-smallJsont* intToSmallJsonG      (smallJsont *self, intmax_t n);
+smallJsont* intToSmallJsonG      (smallJsont *self, int64_t n);
 smallJsont* doubleToSmallJsonG   (smallJsont *self, double n);
 size_t      lenSmallJsonG        (smallJsont *self);
 smallJsont* upperSmallJsonG      (smallJsont *self);
diff --git a/src/json/libsheepyCSmallString.c b/src/json/libsheepyCSmallString.c
@@ -28,7 +28,6 @@
 
 #include <ctype.h>
 #include <stdio.h>
-#include <inttypes.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <string.h>
@@ -147,10 +146,10 @@ internal bool icEqualSSmallString(smallStringt *self, const char *string);
 internal bool icEqualCharSmallString(smallStringt *self, char c);
 internal bool icEqualSmallStringBase(smallStringt* self, baset* p2);
 internal bool icEqualSmallStringSmallJson(smallStringt* self, smallJsont* p2);
-internal bool equalISSmallString(smallStringt *self, const char *string, intmax_t index);
-internal bool equalICharSmallString(smallStringt *self, char c, intmax_t index);
-internal bool equalISmallJsonSmallString(smallStringt *self, smallJsont *string, intmax_t index);
-internal bool equalISmallStringSmallString(smallStringt *self, smallStringt *string, intmax_t index);
+internal bool equalISSmallString(smallStringt *self, const char *string, int64_t index);
+internal bool equalICharSmallString(smallStringt *self, char c, int64_t index);
+internal bool equalISmallJsonSmallString(smallStringt *self, smallJsont *string, int64_t index);
+internal bool equalISmallStringSmallString(smallStringt *self, smallStringt *string, int64_t index);
 internal bool startsWithSSmallString(smallStringt *self, const char *string);
 internal bool startsWithCharSmallString(smallStringt *self, char c);
 internal bool startsWithSmallJsonSmallString(smallStringt *self, smallJsont *string);
@@ -177,9 +176,9 @@ internal ssize_t icCountSmallJsonSmallString(smallStringt *self, smallJsont *str
 internal ssize_t icCountSmallStringSmallString(smallStringt *self, smallStringt *string);
 internal bool isNumberSmallString(smallStringt *self);
 internal bool isIntSmallString(smallStringt *self);
-internal intmax_t parseIntSmallString(smallStringt *self);
+internal int64_t parseIntSmallString(smallStringt *self);
 internal double parseDoubleSmallString(smallStringt *self);
-internal smallStringt* intToSmallString(smallStringt *self, intmax_t n);
+internal smallStringt* intToSmallString(smallStringt *self, int64_t n);
 internal smallStringt* doubleToSmallString(smallStringt *self, double n);
 internal size_t lenSmallString(smallStringt *self);
 internal smallStringt* upperSmallString(smallStringt *self);
@@ -189,23 +188,23 @@ internal smallStringt* lTrimSmallString(smallStringt *self);
 internal smallStringt* rTrimSmallString(smallStringt *self);
 internal smallStringt* uniqSmallString(smallStringt *self, char c);
 internal smallStringt* icUniqSmallString(smallStringt *self, char c);
-internal char getAtSmallString(smallStringt *self, intmax_t index);
-internal smallStringt* setAtSmallString(smallStringt *self, intmax_t index, char c);
-internal smallStringt* sliceSmallString(smallStringt *self, intmax_t start, intmax_t end);
-internal smallStringt* cropSmallString(smallStringt *self, intmax_t start, intmax_t end);
-internal char* cropSSmallString(smallStringt *self, intmax_t start, intmax_t end);
-internal smallJsont* cropSmallJsonSmallString(smallStringt *self, intmax_t start, intmax_t end);
-internal char cropElemSmallString(smallStringt *self, intmax_t index);
-internal smallStringt* copySmallString(smallStringt *self, intmax_t start, intmax_t end);
-internal smallStringt* insertSmallString(smallStringt *self, intmax_t index, smallStringt *toInsert);
-internal smallStringt* insertSmallJsonSmallString(smallStringt *self, intmax_t index, smallJsont *toInsert);
-internal smallStringt* insertSSmallString(smallStringt *self, intmax_t index, const char *toInsert);
-internal smallStringt* insertNFreeSmallString(smallStringt *self, intmax_t index, smallStringt *toInsert);
-internal smallStringt* insertNFreeSmallJsonSmallString(smallStringt *self, intmax_t index, smallJsont *toInsert);
-internal smallStringt* insertSNFreeSmallString(smallStringt *self, intmax_t index, char *toInsert);
-internal smallStringt* injectSmallString(smallStringt *self, intmax_t index, char toInject);
-internal smallStringt* delSmallString(smallStringt *self, intmax_t start, intmax_t end);
-internal smallStringt* delElemSmallString(smallStringt *self, intmax_t index);
+internal char getAtSmallString(smallStringt *self, int64_t index);
+internal smallStringt* setAtSmallString(smallStringt *self, int64_t index, char c);
+internal smallStringt* sliceSmallString(smallStringt *self, int64_t start, int64_t end);
+internal smallStringt* cropSmallString(smallStringt *self, int64_t start, int64_t end);
+internal char* cropSSmallString(smallStringt *self, int64_t start, int64_t end);
+internal smallJsont* cropSmallJsonSmallString(smallStringt *self, int64_t start, int64_t end);
+internal char cropElemSmallString(smallStringt *self, int64_t index);
+internal smallStringt* copySmallString(smallStringt *self, int64_t start, int64_t end);
+internal smallStringt* insertSmallString(smallStringt *self, int64_t index, smallStringt *toInsert);
+internal smallStringt* insertSmallJsonSmallString(smallStringt *self, int64_t index, smallJsont *toInsert);
+internal smallStringt* insertSSmallString(smallStringt *self, int64_t index, const char *toInsert);
+internal smallStringt* insertNFreeSmallString(smallStringt *self, int64_t index, smallStringt *toInsert);
+internal smallStringt* insertNFreeSmallJsonSmallString(smallStringt *self, int64_t index, smallJsont *toInsert);
+internal smallStringt* insertSNFreeSmallString(smallStringt *self, int64_t index, char *toInsert);
+internal smallStringt* injectSmallString(smallStringt *self, int64_t index, char toInject);
+internal smallStringt* delSmallString(smallStringt *self, int64_t start, int64_t end);
+internal smallStringt* delElemSmallString(smallStringt *self, int64_t index);
 internal char* hasSmallString(smallStringt *self, const char *needle);
 internal char* hasCharSmallString(smallStringt *self, char c);
 internal char* hasSmallJsonSmallString(smallStringt *self, smallJsont *needle);
@@ -310,8 +309,8 @@ smallStringt* setSmallDoubleSmallStringG(smallStringt* self, smallDoublet* p2);
 smallStringt* setSmallIntSmallStringG(smallStringt* self, smallIntt* p2);
 smallStringt* setSmallJsonSmallStringG(smallStringt* self, smallJsont* p2);
 smallStringt* setSmallStringSmallStringG(smallStringt* self, smallStringt* p2);
-char getAtSmallStringG(smallStringt *self, char retType UNUSED, intmax_t index);
-smallStringt* setAtSmallStringG(smallStringt *self, intmax_t index, char c);
+char getAtSmallStringG(smallStringt *self, char retType UNUSED, int64_t index);
+smallStringt* setAtSmallStringG(smallStringt *self, int64_t index, char c);
 smallStringt* appendSmallStringG      (smallStringt *self, smallStringt *string);
 smallStringt* appendSmallJsonSmallStringG(smallStringt *self, smallJsont *string);
 smallStringt* appendSSmallStringG     (smallStringt *self, const char *string);
@@ -378,10 +377,10 @@ bool icEqualCharSmallStringG(smallStringt *self, char c);
 bool icEqualSSmallStringG       (smallStringt *self, const char *string);
 bool icEqualSmallStringBaseG(smallStringt* self, baset* p2);
 bool icEqualSmallStringSmallJsonG(smallStringt* self, smallJsont* p2);
-bool equalISSmallStringG      (smallStringt *self, const char *string, intmax_t index);
-bool equalICharSmallStringG(smallStringt *self, char c, intmax_t index);
-bool equalISmallJsonSmallStringG(smallStringt *self, smallJsont *string, intmax_t index);
-bool equalISmallStringSmallStringG(smallStringt *self, smallStringt *string, intmax_t index);
+bool equalISSmallStringG      (smallStringt *self, const char *string, int64_t index);
+bool equalICharSmallStringG(smallStringt *self, char c, int64_t index);
+bool equalISmallJsonSmallStringG(smallStringt *self, smallJsont *string, int64_t index);
+bool equalISmallStringSmallStringG(smallStringt *self, smallStringt *string, int64_t index);
 bool startsWithSSmallStringG  (smallStringt *self, const char *string);
 bool startsWithCharSmallStringG(smallStringt *self, char c);
 bool startsWithSmallJsonSmallStringG  (smallStringt *self, smallJsont *string);
@@ -408,8 +407,8 @@ ssize_t icCountSmallJsonSmallStringG  (smallStringt *self, smallJsont *string);
 ssize_t icCountSmallStringSmallStringG(smallStringt *self, smallStringt *string);
 bool isNumberSmallStringG(smallStringt *self);
 bool isIntSmallStringG(smallStringt *self);
-intmax_t parseIntSmallStringG (smallStringt *self);
-smallStringt* intToSmallStringG        (smallStringt *self, intmax_t n);
+int64_t parseIntSmallStringG (smallStringt *self);
+smallStringt* intToSmallStringG        (smallStringt *self, int64_t n);
 double parseDoubleSmallStringG (smallStringt *self);
 smallStringt* doubleToSmallStringG     (smallStringt *self, double n);
 size_t lenSmallStringG        (smallStringt *self);
@@ -420,21 +419,21 @@ smallStringt*    lTrimSmallStringG       (smallStringt *self);
 smallStringt*    rTrimSmallStringG       (smallStringt *self);
 smallStringt*    uniqSmallStringG       (smallStringt *self, char c);
 smallStringt*    icUniqSmallStringG       (smallStringt *self, char c);
-smallStringt*    sliceSmallStringG      (smallStringt *self, intmax_t start, intmax_t end);
-smallStringt* cropSmallStringG       (smallStringt *self, intmax_t start, intmax_t end);
-char* cropSSmallStringG              (smallStringt *self, intmax_t start, intmax_t end);
-smallJsont* cropSmallJsonSmallStringG(smallStringt *self, intmax_t start, intmax_t end);
-char cropElemSmallStringG            (smallStringt *self, intmax_t index);
-smallStringt* copySmallStringG(smallStringt *self, intmax_t start, intmax_t end);
-smallStringt*    insertSmallStringG     (smallStringt *self, intmax_t index, smallStringt *toInsert);
-smallStringt*    insertSmallJsonSmallStringG     (smallStringt *self, intmax_t index, smallJsont *toInsert);
-smallStringt*    insertSSmallStringG    (smallStringt *self, intmax_t index, const char *toInsert);
-smallStringt*    insertNFreeSmallStringG(smallStringt *self, intmax_t index, smallStringt *toInsert);
-smallStringt*    insertNFreeSmallJsonSmallStringG(smallStringt *self, intmax_t index, smallJsont *toInsert);
-smallStringt*    insertSNFreeSmallStringG(smallStringt *self, intmax_t index, char *toInsert);
-smallStringt*    injectSmallStringG     (smallStringt *self, intmax_t index, char toInject);
-smallStringt*  delSmallStringG          (smallStringt *self, intmax_t start, intmax_t end);
-smallStringt*  delElemSmallStringG      (smallStringt *self, intmax_t index);
+smallStringt*    sliceSmallStringG      (smallStringt *self, int64_t start, int64_t end);
+smallStringt* cropSmallStringG       (smallStringt *self, int64_t start, int64_t end);
+char* cropSSmallStringG              (smallStringt *self, int64_t start, int64_t end);
+smallJsont* cropSmallJsonSmallStringG(smallStringt *self, int64_t start, int64_t end);
+char cropElemSmallStringG            (smallStringt *self, int64_t index);
+smallStringt* copySmallStringG(smallStringt *self, int64_t start, int64_t end);
+smallStringt*    insertSmallStringG     (smallStringt *self, int64_t index, smallStringt *toInsert);
+smallStringt*    insertSmallJsonSmallStringG     (smallStringt *self, int64_t index, smallJsont *toInsert);
+smallStringt*    insertSSmallStringG    (smallStringt *self, int64_t index, const char *toInsert);
+smallStringt*    insertNFreeSmallStringG(smallStringt *self, int64_t index, smallStringt *toInsert);
+smallStringt*    insertNFreeSmallJsonSmallStringG(smallStringt *self, int64_t index, smallJsont *toInsert);
+smallStringt*    insertSNFreeSmallStringG(smallStringt *self, int64_t index, char *toInsert);
+smallStringt*    injectSmallStringG     (smallStringt *self, int64_t index, char toInject);
+smallStringt*  delSmallStringG          (smallStringt *self, int64_t start, int64_t end);
+smallStringt*  delElemSmallStringG      (smallStringt *self, int64_t index);
 char*  hasSmallStringG        (smallStringt *self, const char *needle);
 char* hasCharSmallStringG(smallStringt *self, char c);
 char* hasSmallJsonSmallStringG(smallStringt *self, smallJsont *needle);
@@ -2973,23 +2972,23 @@ internal bool icEqualSmallStringSmallJson(smallStringt* self, smallJsont* p2) {
   return(p2->f->icEqualSmallString(p2, self));
 }
 
-internal bool equalISSmallString(smallStringt *self, const char *string, intmax_t index) {
+internal bool equalISSmallString(smallStringt *self, const char *string, int64_t index) {
 
   if (!self->data || !string) {
     return(false);
   }
 
-  if (index >= (intmax_t)self->_len && self->_len) {
+  if (index >= (int64_t)self->_len && self->_len) {
     return(false);
   }
-  if (index < -(intmax_t)self->_len) {
+  if (index < -(int64_t)self->_len) {
     return(false);
   }
   if (index < 0) {
-    index = (intmax_t)self->_len + index;
+    index = (int64_t)self->_len + index;
   }
 
-  if (index > (intmax_t)(self->_len - strlen(string))) {
+  if (index > (int64_t)(self->_len - strlen(string))) {
     return(false);
   }
 
@@ -3004,13 +3003,13 @@ internal bool equalISSmallString(smallStringt *self, const char *string, intmax_
   return(strncmp(sStringGetTiny(self->data) + index, string, strlen(string)) == 0);;
 }
 
-internal bool equalICharSmallString(smallStringt *self, char c, intmax_t index) {
+internal bool equalICharSmallString(smallStringt *self, char c, int64_t index) {
 
   charToS(s, c);
   return(equalISSmallString(self, s, index));
 }
 
-internal bool equalISmallJsonSmallString(smallStringt *self, smallJsont *string, intmax_t index) {
+internal bool equalISmallJsonSmallString(smallStringt *self, smallJsont *string, int64_t index) {
 
   // sanity checks
   if (!string) {
@@ -3030,7 +3029,7 @@ internal bool equalISmallJsonSmallString(smallStringt *self, smallJsont *string,
   return(equalISSmallString(self, getTopSO(string), index));
 }
 
-internal bool equalISmallStringSmallString(smallStringt *self, smallStringt *string, intmax_t index) {
+internal bool equalISmallStringSmallString(smallStringt *self, smallStringt *string, int64_t index) {
 
   if (!string) {
     return(false);
@@ -3465,7 +3464,7 @@ internal bool isIntSmallString(smallStringt *self) {
   return(r);
 }
 
-internal intmax_t parseIntSmallString(smallStringt *self) {
+internal int64_t parseIntSmallString(smallStringt *self) {
 
   if (!self->data || !self->_len) {
     return(0);
@@ -3475,8 +3474,8 @@ internal intmax_t parseIntSmallString(smallStringt *self) {
   while (!isdigit(*string) && *string != '-' && *string != 0) {
     string++;
   }
-  intmax_t r = strtoimax(string, NULL, 10);
-  if (r == INTMAX_MAX || r == INTMAX_MIN) {
+  int64_t r = strtoll(string, NULL, 10);
+  if (r == INT64_MAX || r == INT64_MIN) {
     pStrError("parseInt error");
   }
   return(r);
@@ -3496,7 +3495,7 @@ internal double parseDoubleSmallString(smallStringt *self) {
   return(r);
 }
 
-internal smallStringt* intToSmallString(smallStringt *self, intmax_t n) {
+internal smallStringt* intToSmallString(smallStringt *self, int64_t n) {
   char s[50];
 
   sprintf(s, "%" PRIiMAX, n);
@@ -3703,16 +3702,16 @@ internal smallStringt* icUniqSmallString(smallStringt *self, char c) {
   return(self);
 }
 
-internal char getAtSmallString(smallStringt *self, intmax_t index) {
+internal char getAtSmallString(smallStringt *self, int64_t index) {
 
   if (!self->data || !self->_len) {
     return(0);
   }
 
-  if (index >= (intmax_t)self->_len) {
+  if (index >= (int64_t)self->_len) {
     return(0);
   }
-  if (index < -(intmax_t)self->_len) {
+  if (index < -(int64_t)self->_len) {
     return(0);
   }
   if (index < 0) {
@@ -3722,16 +3721,16 @@ internal char getAtSmallString(smallStringt *self, intmax_t index) {
   return(*(sStringGetTiny(self->data)+index));
 }
 
-internal smallStringt* setAtSmallString(smallStringt *self, intmax_t index, char c) {
+internal smallStringt* setAtSmallString(smallStringt *self, int64_t index, char c) {
 
   if (!self->data || !self->_len) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)self->_len) {
+  if (index >= (int64_t)self->_len) {
     return(NULL);
   }
-  if (index < -(intmax_t)self->_len) {
+  if (index < -(int64_t)self->_len) {
     return(NULL);
   }
   if (index < 0) {
@@ -3742,7 +3741,7 @@ internal smallStringt* setAtSmallString(smallStringt *self, intmax_t index, char
   return(self);
 }
 
-internal smallStringt* sliceSmallString(smallStringt *self, intmax_t start, intmax_t end) {
+internal smallStringt* sliceSmallString(smallStringt *self, int64_t start, int64_t end) {
   char *s = NULL;
 
   // sanity checks
@@ -3750,17 +3749,17 @@ internal smallStringt* sliceSmallString(smallStringt *self, intmax_t start, intm
     return(NULL);
   }
 
-  if (start > (intmax_t)self->_len) {
+  if (start > (int64_t)self->_len) {
     emptySmallString(self);
     return(NULL);
   }
-  if (end > (intmax_t)self->_len) {
+  if (end > (int64_t)self->_len) {
     end = self->_len;
   }
-  if (start <= -(intmax_t)self->_len) {
+  if (start <= -(int64_t)self->_len) {
     start = -self->_len;
   }
-  if (end <= -(intmax_t)self->_len) {
+  if (end <= -(int64_t)self->_len) {
     emptySmallString(self);
     return(NULL);
   }
@@ -3775,7 +3774,7 @@ internal smallStringt* sliceSmallString(smallStringt *self, intmax_t start, intm
     return(NULL);
   }
 
-  intmax_t n;
+  int64_t n;
   if (start == end) {
     emptyS(s);
   }
@@ -3796,7 +3795,7 @@ internal smallStringt* sliceSmallString(smallStringt *self, intmax_t start, intm
   return(self);
 }
 
-internal smallStringt* cropSmallString(smallStringt *self, intmax_t start, intmax_t end) {
+internal smallStringt* cropSmallString(smallStringt *self, int64_t start, int64_t end) {
 
   char *cropped = cropSSmallString(self, start, end);
 
@@ -3812,9 +3811,9 @@ internal smallStringt* cropSmallString(smallStringt *self, intmax_t start, intma
   return(r);
 }
 
-internal char* cropSSmallString(smallStringt *self, intmax_t start, intmax_t end) {
+internal char* cropSSmallString(smallStringt *self, int64_t start, int64_t end) {
   char *l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!self->data) {
@@ -3847,7 +3846,7 @@ internal char* cropSSmallString(smallStringt *self, intmax_t start, intmax_t end
 
   if (start < end) {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = malloc((n+1) * sizeof(char));
     if (!l) {
@@ -3868,7 +3867,7 @@ internal char* cropSSmallString(smallStringt *self, intmax_t start, intmax_t end
 
 
 
-internal smallJsont* cropSmallJsonSmallString(smallStringt *self, intmax_t start, intmax_t end) {
+internal smallJsont* cropSmallJsonSmallString(smallStringt *self, int64_t start, int64_t end) {
 
   char *cropped = cropSSmallString(self, start, end);
 
@@ -3888,8 +3887,8 @@ internal smallJsont* cropSmallJsonSmallString(smallStringt *self, intmax_t start
 
 
 
-internal char cropElemSmallString(smallStringt *self, intmax_t index) {
-  intmax_t len;
+internal char cropElemSmallString(smallStringt *self, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!self->data) {
@@ -3925,7 +3924,7 @@ internal char cropElemSmallString(smallStringt *self, intmax_t index) {
 
 
 
-internal smallStringt* copySmallString(smallStringt *self, intmax_t start, intmax_t end) {
+internal smallStringt* copySmallString(smallStringt *self, int64_t start, int64_t end) {
   char *s = NULL;
 
   // sanity checks
@@ -3933,16 +3932,16 @@ internal smallStringt* copySmallString(smallStringt *self, intmax_t start, intma
     return(NULL);
   }
 
-  if (start >= (intmax_t)self->_len) {
+  if (start >= (int64_t)self->_len) {
     return(NULL);
   }
-  if (end > (intmax_t)self->_len) {
+  if (end > (int64_t)self->_len) {
     end = self->_len;
   }
-  if (start <= -(intmax_t)self->_len) {
+  if (start <= -(int64_t)self->_len) {
     start = -self->_len;
   }
-  if (end <= -(intmax_t)self->_len) {
+  if (end <= -(int64_t)self->_len) {
     return(NULL);
   }
   if (start < 0) {
@@ -3955,7 +3954,7 @@ internal smallStringt* copySmallString(smallStringt *self, intmax_t start, intma
     return(NULL);
   }
 
-  intmax_t n;
+  int64_t n;
   if (start == end) {
     emptyS(s);
   }
@@ -3979,7 +3978,7 @@ internal smallStringt* copySmallString(smallStringt *self, intmax_t start, intma
   return(r);
 }
 
-internal smallStringt* insertSmallString(smallStringt *self, intmax_t index, smallStringt *toInsert) {
+internal smallStringt* insertSmallString(smallStringt *self, int64_t index, smallStringt *toInsert) {
   char *r = NULL;
 
   // sanity checks
@@ -4010,13 +4009,13 @@ internal smallStringt* insertSmallString(smallStringt *self, intmax_t index, sma
     neg = true;
   }
 
-  if (index > (intmax_t)self->_len) {
+  if (index > (int64_t)self->_len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)self->_len) {
+  if (index < -(int64_t)self->_len) {
     return(NULL);
   }
   if (neg) {
@@ -4045,7 +4044,7 @@ internal smallStringt* insertSmallString(smallStringt *self, intmax_t index, sma
   return(self);
 }
 
-internal smallStringt* insertSmallJsonSmallString(smallStringt *self, intmax_t index, smallJsont *toInsert) {
+internal smallStringt* insertSmallJsonSmallString(smallStringt *self, int64_t index, smallJsont *toInsert) {
 
   if (!toInsert) {
     return(NULL);
@@ -4070,7 +4069,7 @@ internal smallStringt* insertSmallJsonSmallString(smallStringt *self, intmax_t i
   return(insertSSmallString(self, index, getTopSO(toInsert)));
 }
 
-internal smallStringt* insertSSmallString(smallStringt *self, intmax_t index, const char *toInsert) {
+internal smallStringt* insertSSmallString(smallStringt *self, int64_t index, const char *toInsert) {
   char *r = NULL;
 
   // sanity checks
@@ -4096,13 +4095,13 @@ internal smallStringt* insertSSmallString(smallStringt *self, intmax_t index, co
     neg = true;
   }
 
-  if (index > (intmax_t)self->_len) {
+  if (index > (int64_t)self->_len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)self->_len) {
+  if (index < -(int64_t)self->_len) {
     return(NULL);
   }
   if (neg) {
@@ -4132,7 +4131,7 @@ internal smallStringt* insertSSmallString(smallStringt *self, intmax_t index, co
   return(self);
 }
 
-internal smallStringt* insertNFreeSmallString(smallStringt *self, intmax_t index, smallStringt *toInsert) {
+internal smallStringt* insertNFreeSmallString(smallStringt *self, int64_t index, smallStringt *toInsert) {
 
   smallStringt *r = insertSmallString(self, index, toInsert);
   if (r) {
@@ -4141,7 +4140,7 @@ internal smallStringt* insertNFreeSmallString(smallStringt *self, intmax_t index
   return(r);
 }
 
-internal smallStringt* insertNFreeSmallJsonSmallString(smallStringt *self, intmax_t index, smallJsont *toInsert) {
+internal smallStringt* insertNFreeSmallJsonSmallString(smallStringt *self, int64_t index, smallJsont *toInsert) {
 
   smallStringt *r = insertSmallJsonSmallString(self, index, toInsert);
   if (r) {
@@ -4150,7 +4149,7 @@ internal smallStringt* insertNFreeSmallJsonSmallString(smallStringt *self, intma
   return(r);
 }
 
-internal smallStringt* insertSNFreeSmallString(smallStringt *self, intmax_t index, char *toInsert) {
+internal smallStringt* insertSNFreeSmallString(smallStringt *self, int64_t index, char *toInsert) {
 
   smallStringt *r = insertSSmallString(self, index, toInsert);
   if (r) {
@@ -4159,7 +4158,7 @@ internal smallStringt* insertSNFreeSmallString(smallStringt *self, intmax_t inde
   return(r);
 }
 
-internal smallStringt* injectSmallString(smallStringt *self, intmax_t index, char toInject) {
+internal smallStringt* injectSmallString(smallStringt *self, int64_t index, char toInject) {
   char *r = NULL;
 
   // sanity checks
@@ -4182,13 +4181,13 @@ internal smallStringt* injectSmallString(smallStringt *self, intmax_t index, cha
     neg = true;
   }
 
-  if (index > (intmax_t)self->_len) {
+  if (index > (int64_t)self->_len) {
     return(NULL);
   }
   if (neg) {
     index++;
   }
-  if (index < -(intmax_t)self->_len) {
+  if (index < -(int64_t)self->_len) {
     return(NULL);
   }
   if (neg) {
@@ -4217,7 +4216,7 @@ internal smallStringt* injectSmallString(smallStringt *self, intmax_t index, cha
   return(self);
 }
 
-internal smallStringt* delSmallString(smallStringt *self, intmax_t start, intmax_t end) {
+internal smallStringt* delSmallString(smallStringt *self, int64_t start, int64_t end) {
   char *s = NULL;
 
   // sanity checks
@@ -4225,16 +4224,16 @@ internal smallStringt* delSmallString(smallStringt *self, intmax_t start, intmax
     return(NULL);
   }
 
-  if (start >= (intmax_t)self->_len) {
+  if (start >= (int64_t)self->_len) {
     start = self->_len;
   }
-  if (end > (intmax_t)self->_len) {
+  if (end > (int64_t)self->_len) {
     end = self->_len;
   }
-  if (start <= -(intmax_t)self->_len) {
+  if (start <= -(int64_t)self->_len) {
     start = -self->_len;
   }
-  if (end <= -(intmax_t)self->_len) {
+  if (end <= -(int64_t)self->_len) {
     end = -self->_len;
   }
   if (start < 0) {
@@ -4253,7 +4252,7 @@ internal smallStringt* delSmallString(smallStringt *self, intmax_t start, intmax
 
   // start < end < self->_len
   // copy range to a new smallString
-  intmax_t n;
+  int64_t n;
   n = end - start;
   // +2 for sType at the beginning
   s = malloc(self->_len - n +2);
@@ -4271,7 +4270,7 @@ internal smallStringt* delSmallString(smallStringt *self, intmax_t start, intmax
   return(self);
 }
 
-internal smallStringt* delElemSmallString(smallStringt *self, intmax_t index) {
+internal smallStringt* delElemSmallString(smallStringt *self, int64_t index) {
   char *s = NULL;
 
   // sanity checks
@@ -4279,10 +4278,10 @@ internal smallStringt* delElemSmallString(smallStringt *self, intmax_t index) {
     return(NULL);
   }
 
-  if (index >= (intmax_t)self->_len) {
+  if (index >= (int64_t)self->_len) {
     return(0);
   }
-  if (index < -(intmax_t)self->_len) {
+  if (index < -(int64_t)self->_len) {
     return(0);
   }
   if (index < 0) {
@@ -5873,12 +5872,12 @@ smallStringt* setSmallStringSmallStringG(smallStringt* self, smallStringt* p2) {
 }
 
 
-char getAtSmallStringG(smallStringt *self, char retType UNUSED, intmax_t index) {
+char getAtSmallStringG(smallStringt *self, char retType UNUSED, int64_t index) {
 
   return(self->f->getAt(self, index));
 }
 
-smallStringt* setAtSmallStringG(smallStringt *self, intmax_t index, char c) {
+smallStringt* setAtSmallStringG(smallStringt *self, int64_t index, char c) {
 
   return(self->f->setAt(self, index, c));
 }
@@ -6215,22 +6214,22 @@ bool icEqualSmallStringSmallJsonG(smallStringt* self, smallJsont* p2) {
   return(self->f->icEqualSmallJson(self, p2));
 }
 
-bool equalISSmallStringG      (smallStringt *self, const char *string, intmax_t index) {
+bool equalISSmallStringG      (smallStringt *self, const char *string, int64_t index) {
 
   return(self->f->equalIS(self, string, index));
 }
 
-bool equalICharSmallStringG(smallStringt *self, char c, intmax_t index) {
+bool equalICharSmallStringG(smallStringt *self, char c, int64_t index) {
 
   return(self->f->equalIChar(self,c,index));
 }
 
-bool equalISmallJsonSmallStringG(smallStringt *self, smallJsont *string, intmax_t index) {
+bool equalISmallJsonSmallStringG(smallStringt *self, smallJsont *string, int64_t index) {
 
   return(self->f->equalISmallJson(self,string,index));
 }
 
-bool equalISmallStringSmallStringG(smallStringt *self, smallStringt *string, intmax_t index) {
+bool equalISmallStringSmallStringG(smallStringt *self, smallStringt *string, int64_t index) {
 
   return(self->f->equalISmallString(self,string,index));
 }
@@ -6365,12 +6364,12 @@ bool isIntSmallStringG(smallStringt *self) {
   return(self->f->isInt(self));
 }
 
-intmax_t parseIntSmallStringG (smallStringt *self) {
+int64_t parseIntSmallStringG (smallStringt *self) {
 
   return(self->f->parseInt(self));
 }
 
-smallStringt* intToSmallStringG        (smallStringt *self, intmax_t n) {
+smallStringt* intToSmallStringG        (smallStringt *self, int64_t n) {
 
   return(self->f->intTo(self, n));
 }
@@ -6425,77 +6424,77 @@ smallStringt*    icUniqSmallStringG       (smallStringt *self, char c) {
   return(self->f->icUniq(self, c));
 }
 
-smallStringt*    sliceSmallStringG      (smallStringt *self, intmax_t start, intmax_t end) {
+smallStringt*    sliceSmallStringG      (smallStringt *self, int64_t start, int64_t end) {
 
   return(self->f->slice(self, start, end));
 }
 
-smallStringt* cropSmallStringG       (smallStringt *self, intmax_t start, intmax_t end) {
+smallStringt* cropSmallStringG       (smallStringt *self, int64_t start, int64_t end) {
 
   return(self->f->crop(self, start, end));
 }
 
-char* cropSSmallStringG              (smallStringt *self, intmax_t start, intmax_t end) {
+char* cropSSmallStringG              (smallStringt *self, int64_t start, int64_t end) {
 
   return(self->f->cropS(self, start, end));
 }
 
-smallJsont* cropSmallJsonSmallStringG(smallStringt *self, intmax_t start, intmax_t end) {
+smallJsont* cropSmallJsonSmallStringG(smallStringt *self, int64_t start, int64_t end) {
 
   return(self->f->cropSmallJson(self, start, end));
 }
 
-char cropElemSmallStringG            (smallStringt *self, intmax_t index) {
+char cropElemSmallStringG            (smallStringt *self, int64_t index) {
 
   return(self->f->cropElem(self, index));
 }
 
-smallStringt* copySmallStringG(smallStringt *self, intmax_t start, intmax_t end) {
+smallStringt* copySmallStringG(smallStringt *self, int64_t start, int64_t end) {
 
   return(self->f->copy(self, start, end));
 }
 
-smallStringt*    insertSmallStringG     (smallStringt *self, intmax_t index, smallStringt *toInsert) {
+smallStringt*    insertSmallStringG     (smallStringt *self, int64_t index, smallStringt *toInsert) {
 
   return(self->f->insert(self, index, toInsert));
 }
 
-smallStringt*    insertSmallJsonSmallStringG     (smallStringt *self, intmax_t index, smallJsont *toInsert) {
+smallStringt*    insertSmallJsonSmallStringG     (smallStringt *self, int64_t index, smallJsont *toInsert) {
 
   return(self->f->insertSmallJson(self, index, toInsert));
 }
 
-smallStringt*    insertSSmallStringG    (smallStringt *self, intmax_t index, const char *toInsert) {
+smallStringt*    insertSSmallStringG    (smallStringt *self, int64_t index, const char *toInsert) {
 
   return(self->f->insertS(self, index, toInsert));
 }
 
-smallStringt*    insertNFreeSmallStringG(smallStringt *self, intmax_t index, smallStringt *toInsert) {
+smallStringt*    insertNFreeSmallStringG(smallStringt *self, int64_t index, smallStringt *toInsert) {
 
   return(self->f->insertNFree(self, index, toInsert));
 }
 
-smallStringt*    insertNFreeSmallJsonSmallStringG(smallStringt *self, intmax_t index, smallJsont *toInsert) {
+smallStringt*    insertNFreeSmallJsonSmallStringG(smallStringt *self, int64_t index, smallJsont *toInsert) {
 
   return(self->f->insertNFreeSmallJson(self, index, toInsert));
 }
 
-smallStringt*    insertSNFreeSmallStringG(smallStringt *self, intmax_t index, char *toInsert) {
+smallStringt*    insertSNFreeSmallStringG(smallStringt *self, int64_t index, char *toInsert) {
 
   return(self->f->insertSNFree(self, index, toInsert));
 }
 
-smallStringt*    injectSmallStringG     (smallStringt *self, intmax_t index, char toInject) {
+smallStringt*    injectSmallStringG     (smallStringt *self, int64_t index, char toInject) {
 
   return(self->f->inject(self, index, toInject));
 }
 
-smallStringt*  delSmallStringG          (smallStringt *self, intmax_t start, intmax_t end) {
+smallStringt*  delSmallStringG          (smallStringt *self, int64_t start, int64_t end) {
 
   return(self->f->del(self, start, end));
 }
 
-smallStringt*  delElemSmallStringG      (smallStringt *self, intmax_t index) {
+smallStringt*  delElemSmallStringG      (smallStringt *self, int64_t index) {
 
   return(self->f->delElem(self, index));
 }
diff --git a/src/json/libsheepyCSmallString.h b/src/json/libsheepyCSmallString.h
@@ -321,10 +321,10 @@ typedef bool     (*icEqualSmallStringSmallJsonFt)(smallStringt* self, smallJsont
  *   true smallString at index is equal to string
  *   false they differ
  */
-typedef bool     (*equalISSmallStringFt)          (smallStringt *self, const char *string, intmax_t index);
-typedef bool     (*equalICharSmallStringFt)       (smallStringt *self, char c, intmax_t index);
-typedef bool     (*equalISmallJsonSmallStringFt)  (smallStringt *self, smallJsont *string, intmax_t index);
-typedef bool     (*equalISmallStringSmallStringFt)(smallStringt *self, smallStringt *string, intmax_t index);
+typedef bool     (*equalISSmallStringFt)          (smallStringt *self, const char *string, int64_t index);
+typedef bool     (*equalICharSmallStringFt)       (smallStringt *self, char c, int64_t index);
+typedef bool     (*equalISmallJsonSmallStringFt)  (smallStringt *self, smallJsont *string, int64_t index);
+typedef bool     (*equalISmallStringSmallStringFt)(smallStringt *self, smallStringt *string, int64_t index);
 
 /**
  * starts With String
@@ -457,9 +457,9 @@ typedef bool (*isIntSmallStringFt) (smallStringt *self);
  * \return
  *   int64_t
  *   0 when smallString represents 0 or doesnt represent a number or the input is NULL
- *   INTMAX_MAX or INTMAX_MIN for strtoimax parse errors.
+ *   INTM64_MAX or INT64_MIN for strtoll parse errors.
  */
-typedef intmax_t (*parseIntSmallStringFt)  (smallStringt *self);
+typedef int64_t (*parseIntSmallStringFt)  (smallStringt *self);
 
 /**
  * convert self to double
@@ -476,9 +476,9 @@ typedef double (*parseDoubleSmallStringFt)  (smallStringt *self);
  * convert int to smallString, assign result to self
  *
  * \param
- *   intmax_t number
+ *   int64_t number
  */
-typedef smallStringt*     (*intToSmallStringFt)     (smallStringt *self, intmax_t n);
+typedef smallStringt*     (*intToSmallStringFt)     (smallStringt *self, int64_t n);
 
 /**
  * double To String
@@ -547,12 +547,12 @@ typedef smallStringt*      (*icUniqSmallStringFt)    (smallStringt *self, char c
 /**
  * get char at python index
  */
-typedef char     (*getAtSmallStringFt)     (smallStringt *self, intmax_t index);
+typedef char     (*getAtSmallStringFt)     (smallStringt *self, int64_t index);
 
 /**
  * set char at python index
  */
-typedef smallStringt*      (*setAtSmallStringFt)     (smallStringt *self, intmax_t index, char c);
+typedef smallStringt*      (*setAtSmallStringFt)     (smallStringt *self, int64_t index, char c);
 
 /**
  * slice self
@@ -568,7 +568,7 @@ typedef smallStringt*      (*setAtSmallStringFt)     (smallStringt *self, intmax
  *      "" when start=end
  *   -1 unchanged smallString when start and end are not set correctly
  */
-typedef smallStringt*      (*sliceSmallStringFt)     (smallStringt *self, intmax_t start, intmax_t end);
+typedef smallStringt*      (*sliceSmallStringFt)     (smallStringt *self, int64_t start, int64_t end);
 
 /**
  * Crop characters from start to end
@@ -587,9 +587,9 @@ typedef smallStringt*      (*sliceSmallStringFt)     (smallStringt *self, intmax
  *   unchanged when string is NULL or when start and end are not set correctly
  *   NULL error
  */
-typedef smallStringt* (*cropSmallStringFt)(smallStringt *self, intmax_t start, intmax_t end);
-typedef char* (*cropSSmallStringFt)(smallStringt *self, intmax_t start, intmax_t end);
-typedef smallJsont* (*cropSmallJsonSmallStringFt)(smallStringt *self, intmax_t start, intmax_t end);
+typedef smallStringt* (*cropSmallStringFt)(smallStringt *self, int64_t start, int64_t end);
+typedef char* (*cropSSmallStringFt)(smallStringt *self, int64_t start, int64_t end);
+typedef smallJsont* (*cropSmallJsonSmallStringFt)(smallStringt *self, int64_t start, int64_t end);
 
 
 /**
@@ -605,7 +605,7 @@ typedef smallJsont* (*cropSmallJsonSmallStringFt)(smallStringt *self, intmax_t s
  *   unchanged when list is empty
  *   0 error
  */
-typedef char (*cropElemSmallStringFt)(smallStringt *self, intmax_t index);
+typedef char (*cropElemSmallStringFt)(smallStringt *self, int64_t index);
 
 
 /**
@@ -622,7 +622,7 @@ typedef char (*cropElemSmallStringFt)(smallStringt *self, intmax_t index);
  *      "" when start=end
  *   NULL when start and end are not set correctly
  */
-typedef smallStringt* (*copySmallStringFt) (smallStringt *self, intmax_t start, intmax_t end);
+typedef smallStringt* (*copySmallStringFt) (smallStringt *self, int64_t start, int64_t end);
 
 /**
  * insert smallString in self at index
@@ -639,12 +639,12 @@ typedef smallStringt* (*copySmallStringFt) (smallStringt *self, intmax_t start, 
  *   self smallString
  *   NULL unchanged smallString when smallString is NULL or invalid index
  */
-typedef smallStringt*      (*insertSmallStringFt)              (smallStringt *self, intmax_t index, smallStringt *toInsert);
-typedef smallStringt*      (*insertSmallJsonSmallStringFt)     (smallStringt *self, intmax_t index, smallJsont *toInsert);
-typedef smallStringt*      (*insertSSmallStringFt)             (smallStringt *self, intmax_t index, const char *toInsert);
-typedef smallStringt*      (*insertNFreeSmallStringFt)         (smallStringt *self, intmax_t index, smallStringt *toInsert);
-typedef smallStringt*      (*insertNFreeSmallJsonSmallStringFt)(smallStringt *self, intmax_t index, smallJsont *toInsert);
-typedef smallStringt*      (*insertSNFreeSmallStringFt)        (smallStringt *self, intmax_t index, char *toInsert);
+typedef smallStringt*      (*insertSmallStringFt)              (smallStringt *self, int64_t index, smallStringt *toInsert);
+typedef smallStringt*      (*insertSmallJsonSmallStringFt)     (smallStringt *self, int64_t index, smallJsont *toInsert);
+typedef smallStringt*      (*insertSSmallStringFt)             (smallStringt *self, int64_t index, const char *toInsert);
+typedef smallStringt*      (*insertNFreeSmallStringFt)         (smallStringt *self, int64_t index, smallStringt *toInsert);
+typedef smallStringt*      (*insertNFreeSmallJsonSmallStringFt)(smallStringt *self, int64_t index, smallJsont *toInsert);
+typedef smallStringt*      (*insertSNFreeSmallStringFt)        (smallStringt *self, int64_t index, char *toInsert);
 
 /**
  * inject a char in self at index
@@ -661,7 +661,7 @@ typedef smallStringt*      (*insertSNFreeSmallStringFt)        (smallStringt *se
  *   self smallString
  *   NULL unchanged smallString when smallString is NULL or invalid index
  */
-typedef smallStringt*      (*injectSmallStringFt)    (smallStringt *self, intmax_t index, char toInject);
+typedef smallStringt*      (*injectSmallStringFt)    (smallStringt *self, int64_t index, char toInject);
 
 /**
  * delete smallString
@@ -679,8 +679,8 @@ typedef smallStringt*      (*injectSmallStringFt)    (smallStringt *self, intmax
  *   -1 when start and end are not set correctly
  *        or when input smallString is NULL or when malloc failed or when end is under start
  */
-typedef smallStringt*      (*delSmallStringFt)       (smallStringt *self, intmax_t start, intmax_t end);
-typedef smallStringt*      (*delElemSmallStringFt)   (smallStringt *self, intmax_t index);
+typedef smallStringt*      (*delSmallStringFt)       (smallStringt *self, int64_t start, int64_t end);
+typedef smallStringt*      (*delElemSmallStringFt)   (smallStringt *self, int64_t index);
 
 /**
  * has SmallString
@@ -1347,8 +1347,8 @@ smallStringt* setSmallIntSmallStringG   (smallStringt* self, smallIntt* p2);
 smallStringt* setSmallJsonSmallStringG  (smallStringt* self, smallJsont* p2);
 smallStringt* setSmallStringSmallStringG(smallStringt* self, smallStringt* p2);
 
-char getAtSmallStringG        (smallStringt *self, char retType UNUSED, intmax_t index);
-smallStringt* setAtSmallStringG         (smallStringt *self, intmax_t index, char c);
+char getAtSmallStringG        (smallStringt *self, char retType UNUSED, int64_t index);
+smallStringt* setAtSmallStringG         (smallStringt *self, int64_t index, char c);
 
 smallStringt* appendSmallStringG               (smallStringt *self, smallStringt *string);
 smallStringt* appendSmallJsonSmallStringG      (smallStringt *self, smallJsont *string);
@@ -1417,10 +1417,10 @@ bool icEqualSmallStringSmallJsonG(smallStringt* self, smallJsont* p2);
 bool icEqualSmallStringFG        (smallStringt* self, smallStringt* p2);
 bool icEqualCharSmallStringG     (smallStringt *self, char c);
 bool icEqualSSmallStringG        (smallStringt *self, const char *string);
-bool equalISSmallStringG      (smallStringt *self, const char *string, intmax_t index);
-bool equalICharSmallStringG   (smallStringt *self, char c, intmax_t index);
-bool equalISmallJsonSmallStringG(smallStringt *self, smallJsont *string, intmax_t index);
-bool equalISmallStringSmallStringG(smallStringt *self, smallStringt *string, intmax_t index);
+bool equalISSmallStringG      (smallStringt *self, const char *string, int64_t index);
+bool equalICharSmallStringG   (smallStringt *self, char c, int64_t index);
+bool equalISmallJsonSmallStringG(smallStringt *self, smallJsont *string, int64_t index);
+bool equalISmallStringSmallStringG(smallStringt *self, smallStringt *string, int64_t index);
 bool startsWithSSmallStringG          (smallStringt *self, const char *string);
 bool startsWithCharSmallStringG       (smallStringt *self, char c);
 bool startsWithSmallJsonSmallStringG  (smallStringt *self, smallJsont *string);
@@ -1447,8 +1447,8 @@ ssize_t icCountSmallJsonSmallStringG  (smallStringt *self, smallJsont *string);
 ssize_t icCountSmallStringSmallStringG(smallStringt *self, smallStringt *string);
 bool isNumberSmallStringG     (smallStringt *self);
 bool isIntSmallStringG        (smallStringt *self);
-intmax_t parseIntSmallStringG (smallStringt *self);
-smallStringt* intToSmallStringG        (smallStringt *self, intmax_t n);
+int64_t parseIntSmallStringG (smallStringt *self);
+smallStringt* intToSmallStringG        (smallStringt *self, int64_t n);
 double   parseDoubleSmallStringG (smallStringt *self);
 smallStringt* doubleToSmallStringG     (smallStringt *self, double n);
 size_t lenSmallStringG        (smallStringt *self);
@@ -1459,21 +1459,21 @@ smallStringt*    lTrimSmallStringG      (smallStringt *self);
 smallStringt*    rTrimSmallStringG      (smallStringt *self);
 smallStringt*    uniqSmallStringG       (smallStringt *self, char c);
 smallStringt*    icUniqSmallStringG     (smallStringt *self, char c);
-smallStringt*    sliceSmallStringG      (smallStringt *self, intmax_t start, intmax_t end);
-smallStringt* cropSmallStringG       (smallStringt *self, intmax_t start, intmax_t end);
-char* cropSSmallStringG              (smallStringt *self, intmax_t start, intmax_t end);
-smallJsont* cropSmallJsonSmallStringG(smallStringt *self, intmax_t start, intmax_t end);
-char cropElemSmallStringG            (smallStringt *self, intmax_t index);
-smallStringt* copySmallStringG(smallStringt *self, intmax_t start, intmax_t end);
-smallStringt*    insertSmallStringG              (smallStringt *self, intmax_t index, smallStringt *toInsert);
-smallStringt*    insertSmallJsonSmallStringG     (smallStringt *self, intmax_t index, smallJsont *toInsert);
-smallStringt*    insertSSmallStringG             (smallStringt *self, intmax_t index, const char *toInsert);
-smallStringt*    insertNFreeSmallStringG         (smallStringt *self, intmax_t index, smallStringt *toInsert);
-smallStringt*    insertNFreeSmallJsonSmallStringG(smallStringt *self, intmax_t index, smallJsont *toInsert);
-smallStringt*    insertSNFreeSmallStringG        (smallStringt *self, intmax_t index, char *toInsert);
-smallStringt*    injectSmallStringG     (smallStringt *self, intmax_t index, char toInject);
-smallStringt*  delSmallStringG          (smallStringt *self, intmax_t start, intmax_t end);
-smallStringt*  delElemSmallStringG      (smallStringt *self, intmax_t index);
+smallStringt*    sliceSmallStringG      (smallStringt *self, int64_t start, int64_t end);
+smallStringt* cropSmallStringG       (smallStringt *self, int64_t start, int64_t end);
+char* cropSSmallStringG              (smallStringt *self, int64_t start, int64_t end);
+smallJsont* cropSmallJsonSmallStringG(smallStringt *self, int64_t start, int64_t end);
+char cropElemSmallStringG            (smallStringt *self, int64_t index);
+smallStringt* copySmallStringG(smallStringt *self, int64_t start, int64_t end);
+smallStringt*    insertSmallStringG              (smallStringt *self, int64_t index, smallStringt *toInsert);
+smallStringt*    insertSmallJsonSmallStringG     (smallStringt *self, int64_t index, smallJsont *toInsert);
+smallStringt*    insertSSmallStringG             (smallStringt *self, int64_t index, const char *toInsert);
+smallStringt*    insertNFreeSmallStringG         (smallStringt *self, int64_t index, smallStringt *toInsert);
+smallStringt*    insertNFreeSmallJsonSmallStringG(smallStringt *self, int64_t index, smallJsont *toInsert);
+smallStringt*    insertSNFreeSmallStringG        (smallStringt *self, int64_t index, char *toInsert);
+smallStringt*    injectSmallStringG     (smallStringt *self, int64_t index, char toInject);
+smallStringt*  delSmallStringG          (smallStringt *self, int64_t start, int64_t end);
+smallStringt*  delElemSmallStringG      (smallStringt *self, int64_t index);
 char* hasSmallStringG           (smallStringt *self, const char *needle);
 char* hasCharSmallStringG       (smallStringt *self, char c);
 char* hasSmallJsonSmallStringG  (smallStringt *self, smallJsont *needle);
diff --git a/src/json/libsheepyObject.c b/src/json/libsheepyObject.c
@@ -264,17 +264,17 @@ smallJsont *readSmallJsonO(void);
 smallStringt *readO(void);
 smallJsont *readLineSmallJsonO(FILE *fp);
 smallStringt *readLineO(FILE *fp);
-char *intToSG(char *retType UNUSED, intmax_t n);
+char *intToSG(char *retType UNUSED, int64_t n);
 char *doubleToSG(char *retType UNUSED, double n);
 char **iListUniqG(char ***list, int dum UNUSED);
 char **iicListUniqG(char ***list, int dum UNUSED);
 char **listFromArrayG(char **retType UNUSED, char **array, size_t size);
 char **listFromCArrayG(char **retType UNUSED, const char **array, size_t size);
-char getSG(const char *string, int retType UNUSED, intmax_t index);
-char *listGetG(char **list, int retType UNUSED, intmax_t index);
-char *listGetCG(const char **list, int retType UNUSED, intmax_t index);
-char *iListGetG(char **list, int retType UNUSED, intmax_t index);
-char *iListGetCG(const char **list, int retType UNUSED, intmax_t index);
+char getSG(const char *string, int retType UNUSED, int64_t index);
+char *listGetG(char **list, int retType UNUSED, int64_t index);
+char *listGetCG(const char **list, int retType UNUSED, int64_t index);
+char *iListGetG(char **list, int retType UNUSED, int64_t index);
+char *iListGetCG(const char **list, int retType UNUSED, int64_t index);
 char *listPopG(char ***list, int retType UNUSED);
 char *listDequeueG(char ***list, int retType UNUSED);
 char **listDupCG(const char **list);
@@ -3356,7 +3356,7 @@ smallStringt *readLineO(FILE *fp) {
   return(r);
 }
 
-char *intToSG(char *retType UNUSED, intmax_t n) {
+char *intToSG(char *retType UNUSED, int64_t n) {
 
   return(intToS(n));
 }
@@ -3386,27 +3386,27 @@ char **listFromCArrayG(char **retType UNUSED, const char **array, size_t size) {
   return(listFromArrayS((char**)array, size));
 }
 
-char getSG(const char *string, int retType UNUSED, intmax_t index) {
+char getSG(const char *string, int retType UNUSED, int64_t index) {
 
   return(getS(string, index));
 }
 
-char *listGetG(char **list, int retType UNUSED, intmax_t index) {
+char *listGetG(char **list, int retType UNUSED, int64_t index) {
 
   return(listGetS(list, index));
 }
 
-char *listGetCG(const char **list, int retType UNUSED, intmax_t index) {
+char *listGetCG(const char **list, int retType UNUSED, int64_t index) {
 
   return(listGetS((char**)list, index));
 }
 
-char *iListGetG(char **list, int retType UNUSED, intmax_t index) {
+char *iListGetG(char **list, int retType UNUSED, int64_t index) {
 
   return(iListGetS(list, index));
 }
 
-char *iListGetCG(const char **list, int retType UNUSED, intmax_t index) {
+char *iListGetCG(const char **list, int retType UNUSED, int64_t index) {
 
   return(iListGetS((char**)list, index));
 }
diff --git a/src/libsheepy.c b/src/libsheepy.c
@@ -51,7 +51,6 @@ typedef enum { LOCALE_NORMAL, LOCALE_TURKIC, LOCALE_LITHUANIAN } localeType;
 #include <ucontext.h>
 #endif
 #include <libgen.h>
-#include <inttypes.h>
 #include <dirent.h>
 #include <stdarg.h>
 #include <errno.h>
@@ -318,8 +317,8 @@ char *bLicReplaceManySF(char *s, size_t sSize, char *paramType, ...);
 bool eqS(const char *string1, const char *string2);
 bool eqCharS(char c, const char *string2);
 bool eqSChar(const char *string1, char c);
-bool eqIS(const char *string1, const char *string2, intmax_t index);
-bool eqICharS(const char *string1, char c, intmax_t index);
+bool eqIS(const char *string1, const char *string2, int64_t index);
+bool eqICharS(const char *string1, char c, int64_t index);
 bool startsWithS(const char *string1, const char *string2);
 bool startsWithCharS(const char *string1, char c);
 bool endsWithS(const char *string1, const char *string2);
@@ -329,8 +328,8 @@ ssize_t countCharS(const char *s, char c);
 bool icEqS(const char *string1, const char *string2);
 bool icEqCharS(char c, const char *string2);
 bool icEqSChar(const char *string1, char c);
-bool icEqIS(const char *string1, const char *string2, intmax_t index);
-bool icEqICharS(const char *string1, char c, intmax_t index);
+bool icEqIS(const char *string1, const char *string2, int64_t index);
+bool icEqICharS(const char *string1, char c, int64_t index);
 bool icStartsWithS(const char *string1, const char *string2);
 bool icStartsWithCharS(const char *string1, char c);
 bool icEndsWithS(const char *string1, const char *string2);
@@ -343,15 +342,15 @@ char *iStripCtrlS(char **string);
 char *bStripCtrlS(char *string);
 bool isNumber(const char *string);
 bool isInt(const char *string);
-intmax_t parseInt(const char *string);
-intmax_t parseIntChar(char c);
+int64_t parseInt(const char *string);
+int64_t parseIntChar(char c);
 int64_t parseI64(const char *string);
 int64_t parseI64Char(char c);
 double parseDouble(const char *string);
 double parseDoubleChar(char c);
 uint64_t parseHex(const char *string);
-char *intToS(intmax_t n);
-char *bIntToS(char *s, intmax_t n);
+char *intToS(int64_t n);
+char *bIntToS(char *s, int64_t n);
 char *doubleToS(double n);
 char *bDoubleToS(char *s, double n);
 size_t lenS(const char *string);
@@ -420,38 +419,38 @@ char *iPadEndCharS(char **string, size_t targetLength, char padChar);
 char *bPadEndCharS(char *dest, const char *string, size_t targetLength, char padChar);
 char *bLPadEndCharS(char *dest, size_t destSize, const char *string, size_t targetLength, char padChar);
 ssize_t padEndLenS(const char *string, size_t targetLength, const char *padString);
-char getS(const char *string, intmax_t index);
-char *setS(char *string, intmax_t index, char c);
-char *swapS(char *string, intmax_t index1, intmax_t index2);
-char *iSwapS(char **string, intmax_t index1, intmax_t index2);
-char *bSwapS(char *string, intmax_t index1, intmax_t index2);
-char *bLSwapS(char *string, size_t size, intmax_t index1, intmax_t index2);
-char *sliceS(const char *string, intmax_t start, intmax_t end);
-char *iSliceS(char **string, intmax_t start, intmax_t end);
-char *bSliceS(char *string, intmax_t start, intmax_t end);
-char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end);
-char *cropS(char *string, intmax_t start, intmax_t end);
-char *iCropS(char **string, intmax_t start, intmax_t end);
-char cropElemS(char *string, intmax_t index);
-char iCropElemS(char **string, intmax_t index);
-char *insertS(const char *string, intmax_t index, const char *toInsert);
-char *insertNFreeS(const char *string, intmax_t index, char *toInsert);
-char *iInsertS(char **string, intmax_t index, const char *toInsert);
-char *iInsertNFreeS(char **string, intmax_t index, char *toInsert);
-char *bInsertS(char *string, intmax_t index, const char *toInsert);
-char *bLInsertS(char *string, size_t stringSize, intmax_t index, const char *toInsert);
-char *injectS(const char *string, intmax_t index, char toInject);
-char *iInjectS(char **string, intmax_t index, char toInject);
-char *bInjectS(char *string, intmax_t index, char toInject);
-char *bLInjectS(char *string, size_t stringSize, intmax_t index, char toInject);
-char *delS(const char *string, intmax_t start, intmax_t end);
-char *iDelS(char **string, intmax_t start, intmax_t end);
-char *bDelS(char *string, intmax_t start, intmax_t end);
-char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end);
-char *delElemS(const char *string, intmax_t index);
-char *iDelElemS(char **string, intmax_t index);
-char *bDelElemS(char *string, intmax_t index);
-char *bLDelElemS(char *string, size_t stringSize, intmax_t index);
+char getS(const char *string, int64_t index);
+char *setS(char *string, int64_t index, char c);
+char *swapS(char *string, int64_t index1, int64_t index2);
+char *iSwapS(char **string, int64_t index1, int64_t index2);
+char *bSwapS(char *string, int64_t index1, int64_t index2);
+char *bLSwapS(char *string, size_t size, int64_t index1, int64_t index2);
+char *sliceS(const char *string, int64_t start, int64_t end);
+char *iSliceS(char **string, int64_t start, int64_t end);
+char *bSliceS(char *string, int64_t start, int64_t end);
+char *bLSliceS(char *string, size_t stringSize, int64_t start, int64_t end);
+char *cropS(char *string, int64_t start, int64_t end);
+char *iCropS(char **string, int64_t start, int64_t end);
+char cropElemS(char *string, int64_t index);
+char iCropElemS(char **string, int64_t index);
+char *insertS(const char *string, int64_t index, const char *toInsert);
+char *insertNFreeS(const char *string, int64_t index, char *toInsert);
+char *iInsertS(char **string, int64_t index, const char *toInsert);
+char *iInsertNFreeS(char **string, int64_t index, char *toInsert);
+char *bInsertS(char *string, int64_t index, const char *toInsert);
+char *bLInsertS(char *string, size_t stringSize, int64_t index, const char *toInsert);
+char *injectS(const char *string, int64_t index, char toInject);
+char *iInjectS(char **string, int64_t index, char toInject);
+char *bInjectS(char *string, int64_t index, char toInject);
+char *bLInjectS(char *string, size_t stringSize, int64_t index, char toInject);
+char *delS(const char *string, int64_t start, int64_t end);
+char *iDelS(char **string, int64_t start, int64_t end);
+char *bDelS(char *string, int64_t start, int64_t end);
+char *bLDelS(char *string, size_t stringSize, int64_t start, int64_t end);
+char *delElemS(const char *string, int64_t index);
+char *iDelElemS(char **string, int64_t index);
+char *bDelElemS(char *string, int64_t index);
+char *bLDelElemS(char *string, size_t stringSize, int64_t index);
 char *findS(const char *string, const char *needle);
 char *findCharS(const char *string, char c);
 ssize_t indexOfS(const char *string, const char *needle);
@@ -477,12 +476,12 @@ char *findNextUTF8(const char *string, size_t utf8Size, const char *utf8);
 char *prevUTF8(const char *utf8);
 char *bPrevUTF8(const char *string, const char *utf8);
 local char *bPrevUTF8Tiny(const char *string, const char *utf8);
-char *idx2PtrUTF8(const char *utf8, intmax_t index);
-char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index);
-intmax_t ptr2IdxUTF8(const char *utf8, const char *pos);
-intmax_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos);
-intmax_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
-intmax_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
+char *idx2PtrUTF8(const char *utf8, int64_t index);
+char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, int64_t index);
+int64_t ptr2IdxUTF8(const char *utf8, const char *pos);
+int64_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos);
+int64_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
+int64_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
 char *makeValidUTF8(const char *utf8);
 char *bMakeValidUTF8(char *utf8);
 char *nMakeValidUTF8(const char *utf8, size_t utf8Len);
@@ -509,13 +508,13 @@ char *icReplaceManyUTF8F(const char *paramType UNUSED, ...);
 char *iicReplaceManyUTF8F(char **s UNUSED, char *paramType UNUSED, ...);
 char *bicReplaceManyUTF8F(char *s UNUSED, char *paramType UNUSED, ...);
 char *bLicReplaceManyUTF8F(char *s UNUSED, size_t sSize UNUSED, char *paramType UNUSED, ...);
-bool eqIUTF8(const char *string1, const char *string2, intmax_t index);
-bool eqICharUTF8(const char *string1, char c, intmax_t index);
+bool eqIUTF8(const char *string1, const char *string2, int64_t index);
+bool eqICharUTF8(const char *string1, char c, int64_t index);
 bool icEqUTF8(const char *string1, const char *string2);
 bool icEqCharUTF8(char c, const char *string2);
 bool icEqUTF8Char(const char *string1, char c);
-bool icEqIUTF8(const char *string1 UNUSED, const char *string2 UNUSED, intmax_t index UNUSED);
-bool icEqICharUTF8(const char *string1 UNUSED, char c UNUSED, intmax_t index UNUSED);
+bool icEqIUTF8(const char *string1 UNUSED, const char *string2 UNUSED, int64_t index UNUSED);
+bool icEqICharUTF8(const char *string1 UNUSED, char c UNUSED, int64_t index UNUSED);
 bool icStartsWithUTF8(const char *string1, const char *string2);
 bool icEndsWithUTF8(const char *string1, const char *string2);
 ssize_t icCountUTF8(const char *s, const char *needle);
@@ -548,22 +547,22 @@ char *bUniqUTF8(char *string, const char *code);
 char *icUniqUTF8(const char *string UNUSED, const char *code UNUSED);
 char *iicUniqUTF8(char **string UNUSED, const char *code UNUSED);
 char *bicUniqUTF8(char *string UNUSED, char c UNUSED);
-rune getUTF8(const char *string, intmax_t index);
-char *setUTF8(char *string, intmax_t index, rune c);
-char *sliceUTF8(const char *string, intmax_t start, intmax_t end);
-char *iSliceUTF8(char **string, intmax_t start, intmax_t end);
-char *bSliceUTF8(char *string, intmax_t start, intmax_t end);
-char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end);
-char *insertUTF8(const char *string, intmax_t index, const char *toInsert);
-char *insertNFreeUTF8(const char *string, intmax_t index, char *toInsert);
-char *iInsertUTF8(char **string, intmax_t index, const char *toInsert);
-char *iInsertNFreeUTF8(char **string, intmax_t index, char *toInsert);
-char *bInsertUTF8(char *string, intmax_t index, const char *toInsert);
-char *bLInsertUTF8(char *string, size_t stringSize, intmax_t index, const char *toInsert);
-char *delUTF8(const char *string, intmax_t start, intmax_t end);
-char *iDelUTF8(char **string, intmax_t start, intmax_t end);
-char *bDelUTF8(char *string, intmax_t start, intmax_t end);
-char *bLDelUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end);
+rune getUTF8(const char *string, int64_t index);
+char *setUTF8(char *string, int64_t index, rune c);
+char *sliceUTF8(const char *string, int64_t start, int64_t end);
+char *iSliceUTF8(char **string, int64_t start, int64_t end);
+char *bSliceUTF8(char *string, int64_t start, int64_t end);
+char *bLSliceUTF8(char *string, size_t stringSize, int64_t start, int64_t end);
+char *insertUTF8(const char *string, int64_t index, const char *toInsert);
+char *insertNFreeUTF8(const char *string, int64_t index, char *toInsert);
+char *iInsertUTF8(char **string, int64_t index, const char *toInsert);
+char *iInsertNFreeUTF8(char **string, int64_t index, char *toInsert);
+char *bInsertUTF8(char *string, int64_t index, const char *toInsert);
+char *bLInsertUTF8(char *string, size_t stringSize, int64_t index, const char *toInsert);
+char *delUTF8(const char *string, int64_t start, int64_t end);
+char *iDelUTF8(char **string, int64_t start, int64_t end);
+char *bDelUTF8(char *string, int64_t start, int64_t end);
+char *bLDelUTF8(char *string, size_t stringSize, int64_t start, int64_t end);
 ssize_t indexOfUTF8(const char *string, const char *needle);
 ssize_t icIndexOfUTF8(const char *string UNUSED, const char *needle UNUSED);
 bool icHasUTF8(const char *string, const char *needle);
@@ -585,7 +584,7 @@ char *emptySF(void);
 char *iEmptySF(char **string);
 bool isEmptyS(const char *string);
 bool isBlankS(const char *string);
-ssize_t intIndex(intmax_t index, intmax_t length);
+ssize_t intIndex(int64_t index, int64_t length);
 char **listEmptySF(void);
 char **iListEmptySF(char ***list);
 bool listIsEmptyS(char **list);
@@ -604,15 +603,15 @@ void listFreeS(char **list);
 void listFreeManySF(char **paramType, ...);
 size_t listLengthS(char **list);
 ssize_t listStrLengthS(char **list);
-ssize_t listIntIndexS(char **list, intmax_t index);
-char **listAddrS(char **list, intmax_t index);
-char *listGetS(char **list, intmax_t index);
-char *iListGetS(char **list, intmax_t index);
-char **listSetS(char **list, intmax_t index, const char *s);
-char **listSetCharS(char **list, intmax_t index, char c);
-char **iListSetS(char **list, intmax_t index, char *s);
-char **listSwapS(char **list, intmax_t index1, intmax_t index2);
-char **iListSwapS(char **list, intmax_t index1, intmax_t index2);
+ssize_t listIntIndexS(char **list, int64_t index);
+char **listAddrS(char **list, int64_t index);
+char *listGetS(char **list, int64_t index);
+char *iListGetS(char **list, int64_t index);
+char **listSetS(char **list, int64_t index, const char *s);
+char **listSetCharS(char **list, int64_t index, char c);
+char **iListSetS(char **list, int64_t index, char *s);
+char **listSwapS(char **list, int64_t index1, int64_t index2);
+char **iListSwapS(char **list, int64_t index1, int64_t index2);
 char **split(const char *string, const char* delim);
 char **splitChar(const char *string, char delim);
 char **icSplit(const char *string, const char* delim);
@@ -644,26 +643,26 @@ char **listShiftS(char ***list1, char **list2);
 char **iListShiftS(char ***list1, char **list2);
 char **iListShiftNSmashS(char ***list1, char **list2);
 char **listAddS(char **list1, char **list2);
-char **listSliceS(char **list, intmax_t start, intmax_t end);
-char **iListCopyS(char **list, intmax_t start, intmax_t end);
-char **iListSliceS(char ***list, intmax_t start, intmax_t end);
-char **listCropS(char **list, intmax_t start, intmax_t end);
-char **iListCropS(char ***list, intmax_t start, intmax_t end);
-char *listCropElemS(char **list, intmax_t index);
-char *iListCropElemS(char ***list, intmax_t index);
-char **listInsertS(char **list, intmax_t index, char **toInsert);
-char **iListInsertS(char ***list, intmax_t index, char **toInsert);
-char **iListInsertNFreeS(char ***list, intmax_t index, char **toInsert);
-char **listInjectS(char **list, intmax_t index, char *toInject);
-char **listInjectCharS(char **list, intmax_t index, char toInject);
-char **iListInjectS(char ***list, intmax_t index, char *toInject);
-char **iListInjectCharS(char ***list, intmax_t index, char toInject);
-char **listDelS(char **list, intmax_t start, intmax_t end);
-char **iListDelS(char ***list, intmax_t start, intmax_t end);
-char **iListRemoveS(char ***list, intmax_t start, intmax_t end);
-char **listDelElemS(char **list, intmax_t index);
-char **iListDelElemS(char ***list, intmax_t index);
-char **iListRemoveElemS(char ***list, intmax_t index);
+char **listSliceS(char **list, int64_t start, int64_t end);
+char **iListCopyS(char **list, int64_t start, int64_t end);
+char **iListSliceS(char ***list, int64_t start, int64_t end);
+char **listCropS(char **list, int64_t start, int64_t end);
+char **iListCropS(char ***list, int64_t start, int64_t end);
+char *listCropElemS(char **list, int64_t index);
+char *iListCropElemS(char ***list, int64_t index);
+char **listInsertS(char **list, int64_t index, char **toInsert);
+char **iListInsertS(char ***list, int64_t index, char **toInsert);
+char **iListInsertNFreeS(char ***list, int64_t index, char **toInsert);
+char **listInjectS(char **list, int64_t index, char *toInject);
+char **listInjectCharS(char **list, int64_t index, char toInject);
+char **iListInjectS(char ***list, int64_t index, char *toInject);
+char **iListInjectCharS(char ***list, int64_t index, char toInject);
+char **listDelS(char **list, int64_t start, int64_t end);
+char **iListDelS(char ***list, int64_t start, int64_t end);
+char **iListRemoveS(char ***list, int64_t start, int64_t end);
+char **listDelElemS(char **list, int64_t index);
+char **iListDelElemS(char ***list, int64_t index);
+char **iListRemoveElemS(char ***list, int64_t index);
 int listPrintS(char **list);
 internal int listSortSCmp(const void * a, const void * b);
 char **listSortS(char **list);
@@ -723,20 +722,20 @@ void *listDequeue(void ***list);
 void listFree(void **list);
 void listFreeManyF(void **paramType, ...);
 size_t listLength(void **list);
-void *listGet(void **list, intmax_t index);
-void **listSet(void **list, intmax_t index, void *s);
+void *listGet(void **list, int64_t index);
+void **listSet(void **list, int64_t index, void *s);
 void **listDup(void **list);
 void **listReverse(void **list);
 void **iListReverse(void ***list);
 void **listCatF(void **paramType, ...);
 void **listAppend(void ***list1, void **list2);
 void **listAdd(void **list1, void **list2);
-void **listSlice(void **list, intmax_t start, intmax_t end);
-void **iListSlice(void ***list, intmax_t start, intmax_t end);
-void **listInsert(void **list, intmax_t index, void **toInsert);
-void **iListInsert(void ***list, intmax_t index, void **toInsert);
-void **listDel(void **list, intmax_t start, intmax_t end);
-void **iListDel(void ***list, intmax_t start, intmax_t end);
+void **listSlice(void **list, int64_t start, int64_t end);
+void **iListSlice(void ***list, int64_t start, int64_t end);
+void **listInsert(void **list, int64_t index, void **toInsert);
+void **iListInsert(void ***list, int64_t index, void **toInsert);
+void **listDel(void **list, int64_t start, int64_t end);
+void **iListDel(void ***list, int64_t start, int64_t end);
 int ringInit(void *ring, int maxCount);
 int ringEmpty(void *ring);
 int ringIsEmpty(void *ring);
@@ -9065,14 +9064,14 @@ bool eqSChar(const char *string1, char c) {
  *   true string1 at index is equal to string2
  *   false they differ
  */
-bool eqIS(const char *string1, const char *string2, intmax_t index) {
+bool eqIS(const char *string1, const char *string2, int64_t index) {
 
   // sanity checks
   if (!string1 || !string2) {
     return(false);
   }
 
-  intmax_t len = strlen(string1);
+  int64_t len = strlen(string1);
   if (index >= len && len) {
     // && len: string1 is empty, check below if string2 is also empty
     // when string1 and string2 are empty and index is 0, the result is true
@@ -9085,7 +9084,7 @@ bool eqIS(const char *string1, const char *string2, intmax_t index) {
     index = len + index;
   }
 
-  intmax_t len2 = (intmax_t)strlen(string2);
+  int64_t len2 = (int64_t)strlen(string2);
   if (!len2 && !len && !index) {
     // string1 and string2 are empty and index is 0
     return(true);
@@ -9100,7 +9099,7 @@ bool eqIS(const char *string1, const char *string2, intmax_t index) {
   return(strncmp(string1 + index, string2, len2) == 0);;
 }
 
-bool eqICharS(const char *string1, char c, intmax_t index) {
+bool eqICharS(const char *string1, char c, int64_t index) {
 
   charToS(s,c);
   return(eqIS(string1, s, index));
@@ -9281,14 +9280,14 @@ bool icEqSChar(const char *string1, char c) {
  *   true string1 at index is equal to string2
  *   false they differ
  */
-bool icEqIS(const char *string1, const char *string2, intmax_t index) {
+bool icEqIS(const char *string1, const char *string2, int64_t index) {
 
   // sanity checks
   if (!string1 || !string2) {
     return(false);
   }
 
-  intmax_t len = strlen(string1);
+  int64_t len = strlen(string1);
   if (index >= len && len) {
     // && len: string1 is empty, check below if string2 is also empty
     // when string1 and string2 are empty and index is 0, the result is true
@@ -9301,7 +9300,7 @@ bool icEqIS(const char *string1, const char *string2, intmax_t index) {
     index = len + index;
   }
 
-  intmax_t len2 = (intmax_t)strlen(string2);
+  int64_t len2 = (int64_t)strlen(string2);
   if (!len2 && !len && !index) {
     // string1 and string2 are empty and index is 0
     return(true);
@@ -9316,7 +9315,7 @@ bool icEqIS(const char *string1, const char *string2, intmax_t index) {
   return(strncasecmp(string1 + index, string2, len2) == 0);;
 }
 
-bool icEqICharS(const char *string1, char c, intmax_t index) {
+bool icEqICharS(const char *string1, char c, int64_t index) {
 
   charToS(s,c);
   return(icEqIS(string1, s, index));
@@ -9664,10 +9663,10 @@ bool isInt(const char *string) {
  * \param
  *   string
  * \return
- *   intmax_t
+ *   int64_t
  *   0 when string represents 0 or doesnt represent a number or the input is NULL
  */
-intmax_t parseInt(const char *string) {
+int64_t parseInt(const char *string) {
 
   // sanity checks
   if (!string) {
@@ -9676,15 +9675,15 @@ intmax_t parseInt(const char *string) {
   while (!isdigit(*string) && *string != '-' && *string != 0) {
     string++;
   }
-  intmax_t r = strtoimax(string, NULL, 10);
-  if (r == INTMAX_MAX || r == INTMAX_MIN) {
+  int64_t r = strtoll(string, NULL, 10);
+  if (r == INT64_MAX || r == INT64_MIN) {
     pFuncError
     shEPrintfS("The string was: \"%s\"\n", string);
   }
   return(r);
 }
 
-intmax_t parseIntChar(char c) {
+int64_t parseIntChar(char c) {
 
   if (!isdigit(c)) {
     return(-1);
@@ -9791,7 +9790,7 @@ uint64_t parseHex(const char *string) {
  * \return
  *   string representing the number (you must free the pointer)
  */
-char *intToS(intmax_t n) {
+char *intToS(int64_t n) {
   char s[50];
   char *r = NULL;
 
@@ -9810,7 +9809,7 @@ char *intToS(intmax_t n) {
  * \return
  *   string representing the number
  */
-char *bIntToS(char *s, intmax_t n) {
+char *bIntToS(char *s, int64_t n) {
 
   if (!s) {
     return(NULL);
@@ -12597,8 +12596,8 @@ ssize_t padEndLenS(const char *string, size_t targetLength, const char *padStrin
  * get char at python index
  *
  */
-char getS(const char *string, intmax_t index) {
-  intmax_t len;
+char getS(const char *string, int64_t index) {
+  int64_t len;
 
   if (!string) {
     return(0);
@@ -12623,8 +12622,8 @@ char getS(const char *string, intmax_t index) {
  *
  * set char at python index
  */
-char *setS(char *string, intmax_t index, char c) {
-  intmax_t len;
+char *setS(char *string, int64_t index, char c) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -12658,8 +12657,8 @@ char *setS(char *string, intmax_t index, char c) {
  * new string with characters swapped at index1 and index2 (you must free this pointer)
  * NULL when string is NULL or when index1 or index2 are outside the string
  */
-char *swapS(char *string, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char *swapS(char *string, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -12708,8 +12707,8 @@ char *swapS(char *string, intmax_t index1, intmax_t index2) {
  * updated string with characters swapped at index1 and index2 (you must free this pointer)
  * NULL when string is NULL or when index1 or index2 are outside the string
  */
-char *iSwapS(char **string, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char *iSwapS(char **string, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!string or !*string) {
     return(NULL);
@@ -12756,8 +12755,8 @@ char *iSwapS(char **string, intmax_t index1, intmax_t index2) {
  * string with characters swapped at index1 and index2
  * NULL when string is NULL or when index1 or index2 are outside the string
  */
-char *bSwapS(char *string, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char *bSwapS(char *string, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -12809,8 +12808,8 @@ char *bSwapS(char *string, intmax_t index1, intmax_t index2) {
  * string with characters swapped at index1 and index2
  * NULL when string is NULL or when index1 or index2 are outside the string
   */
-char *bLSwapS(char *string, size_t size, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char *bLSwapS(char *string, size_t size, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -12870,9 +12869,9 @@ char *bLSwapS(char *string, size_t size, intmax_t index1, intmax_t index2) {
  *   "" when start=end
  *   NULL when start and end are not set correctly
  */
-char *sliceS(const char *string, intmax_t start, intmax_t end) {
+char *sliceS(const char *string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -12908,7 +12907,7 @@ char *sliceS(const char *string, intmax_t start, intmax_t end) {
   else {
     // start < end < len
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = end - start;
     s = MALLOC(n+1);
     if (!s) {
@@ -12935,9 +12934,9 @@ char *sliceS(const char *string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *iSliceS(char **string, intmax_t start, intmax_t end) {
+char *iSliceS(char **string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -12979,7 +12978,7 @@ char *iSliceS(char **string, intmax_t start, intmax_t end) {
   else {
     // start < end < len
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = end - start;
     s = MALLOC(n+1);
     if (!s) {
@@ -13008,8 +13007,8 @@ char *iSliceS(char **string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *bSliceS(char *string, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bSliceS(char *string, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13048,7 +13047,7 @@ char *bSliceS(char *string, intmax_t start, intmax_t end) {
   else {
     // start < end < len
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = end - start;
     if (start) {
       strncpy(string, string+start, n);
@@ -13077,8 +13076,8 @@ char *bSliceS(char *string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bLSliceS(char *string, size_t stringSize, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -13122,7 +13121,7 @@ char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
   else {
     // start < end < len
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = end - start;
     if (start) {
       strncpy(string, string+start, n);
@@ -13152,9 +13151,9 @@ char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char *cropS(char *string, intmax_t start, intmax_t end) {
+char *cropS(char *string, int64_t start, int64_t end) {
   char *l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13187,7 +13186,7 @@ char *cropS(char *string, intmax_t start, intmax_t end) {
 
   if (start < end) {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char));
     if (!l) {
@@ -13223,9 +13222,9 @@ char *cropS(char *string, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char *iCropS(char **string, intmax_t start, intmax_t end) {
+char *iCropS(char **string, int64_t start, int64_t end) {
   char *l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -13258,7 +13257,7 @@ char *iCropS(char **string, intmax_t start, intmax_t end) {
 
   if (start < end) {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char));
     if (!l) {
@@ -13275,8 +13274,8 @@ char *iCropS(char **string, intmax_t start, intmax_t end) {
   return(l);
 }
 
-char cropElemS(char *string, intmax_t index) {
-  intmax_t len;
+char cropElemS(char *string, int64_t index) {
+  int64_t len;
 
   if (!string) {
     return(0);
@@ -13305,7 +13304,7 @@ char cropElemS(char *string, intmax_t index) {
   return(r);
 }
 
-char iCropElemS(char **string, intmax_t index) {
+char iCropElemS(char **string, int64_t index) {
 
   if (!string) {
     return(0);
@@ -13331,9 +13330,9 @@ char iCropElemS(char **string, intmax_t index) {
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *insertS(const char *string, intmax_t index, const char *toInsert) {
+char *insertS(const char *string, int64_t index, const char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13400,9 +13399,9 @@ char *insertS(const char *string, intmax_t index, const char *toInsert) {
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *insertNFreeS(const char *string, intmax_t index, char *toInsert) {
+char *insertNFreeS(const char *string, int64_t index, char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13478,9 +13477,9 @@ char *insertNFreeS(const char *string, intmax_t index, char *toInsert) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInsertS(char **string, intmax_t index, const char *toInsert) {
+char *iInsertS(char **string, int64_t index, const char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13557,9 +13556,9 @@ char *iInsertS(char **string, intmax_t index, const char *toInsert) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInsertNFreeS(char **string, intmax_t index, char *toInsert) {
+char *iInsertNFreeS(char **string, int64_t index, char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13639,8 +13638,8 @@ char *iInsertNFreeS(char **string, intmax_t index, char *toInsert) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bInsertS(char *string, intmax_t index, const char *toInsert) {
-  intmax_t len;
+char *bInsertS(char *string, int64_t index, const char *toInsert) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13708,8 +13707,8 @@ char *bInsertS(char *string, intmax_t index, const char *toInsert) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bLInsertS(char *string, size_t stringSize, intmax_t index, const char *toInsert) {
-  intmax_t len;
+char *bLInsertS(char *string, size_t stringSize, int64_t index, const char *toInsert) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13783,9 +13782,9 @@ char *bLInsertS(char *string, size_t stringSize, intmax_t index, const char *toI
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *injectS(const char *string, intmax_t index, char toInject) {
+char *injectS(const char *string, int64_t index, char toInject) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13853,9 +13852,9 @@ char *injectS(const char *string, intmax_t index, char toInject) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInjectS(char **string, intmax_t index, char toInject) {
+char *iInjectS(char **string, int64_t index, char toInject) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13930,8 +13929,8 @@ char *iInjectS(char **string, intmax_t index, char toInject) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bInjectS(char *string, intmax_t index, char toInject) {
-  intmax_t len;
+char *bInjectS(char *string, int64_t index, char toInject) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -13996,8 +13995,8 @@ char *bInjectS(char *string, intmax_t index, char toInject) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bLInjectS(char *string, size_t stringSize, intmax_t index, char toInject) {
-  intmax_t len;
+char *bLInjectS(char *string, size_t stringSize, int64_t index, char toInject) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -14067,9 +14066,9 @@ char *bLInjectS(char *string, size_t stringSize, intmax_t index, char toInject) 
  *   new identical string when start=end or when start and end are not set correctly
  *   NULL when input string is NULL or when malloc failed or when end is under start
  */
-char *delS(const char *string, intmax_t start, intmax_t end) {
+char *delS(const char *string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -14106,7 +14105,7 @@ char *delS(const char *string, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = end - start;
   s = MALLOC(len-n+1);
   if (!s) {
@@ -14137,9 +14136,9 @@ char *delS(const char *string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *iDelS(char **string, intmax_t start, intmax_t end) {
+char *iDelS(char **string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -14176,7 +14175,7 @@ char *iDelS(char **string, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = end - start;
   s = MALLOC(len-n+1);
   if (!s) {
@@ -14209,8 +14208,8 @@ char *iDelS(char **string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *bDelS(char *string, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bDelS(char *string, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -14247,7 +14246,7 @@ char *bDelS(char *string, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = end - start;
   strncpy(string+start, string+start+n, len-n-start);
   string[len-n] = 0;
@@ -14275,8 +14274,8 @@ char *bDelS(char *string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bLDelS(char *string, size_t stringSize, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -14289,16 +14288,16 @@ char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
   }
 
   // compute string length without NUL
-  if (start >= (intmax_t)len) {
+  if (start >= (int64_t)len) {
     start = len;
   }
-  if (end > (intmax_t)len) {
+  if (end > (int64_t)len) {
     end = len;
   }
-  if (start <= -(intmax_t)len) {
+  if (start <= -(int64_t)len) {
     start = -len;
   }
-  if (end <= -(intmax_t)len) {
+  if (end <= -(int64_t)len) {
     end = -len;
   }
   if (start < 0) {
@@ -14317,7 +14316,7 @@ char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = end - start;
   strncpy(string+start, string+start+n, len-n-start);
   string[len-n] = 0;
@@ -14339,9 +14338,9 @@ char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end) {
  *   new string (you must free the pointer)
  *   NULL when input string is NULL or when malloc failed
  */
-char *delElemS(const char *string, intmax_t index) {
+char *delElemS(const char *string, int64_t index) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -14382,9 +14381,9 @@ char *delElemS(const char *string, intmax_t index) {
  *   new string (you must free the pointer)
  *   NULL when input string is NULL or when malloc failed
  */
-char *iDelElemS(char **string, intmax_t index) {
+char *iDelElemS(char **string, int64_t index) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -14429,8 +14428,8 @@ char *iDelElemS(char **string, intmax_t index) {
  *   string with one less character
  *   NULL when input string is NULL or when malloc failed
  */
-char *bDelElemS(char *string, intmax_t index) {
-  intmax_t len;
+char *bDelElemS(char *string, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -14470,8 +14469,8 @@ char *bDelElemS(char *string, intmax_t index) {
  *   string with one less character
  *   NULL when input string is NULL or when malloc failed
  */
-char *bLDelElemS(char *string, size_t stringSize, intmax_t index) {
-  intmax_t len;
+char *bLDelElemS(char *string, size_t stringSize, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -14484,14 +14483,14 @@ char *bLDelElemS(char *string, size_t stringSize, intmax_t index) {
   }
 
   // compute string length without NUL
-  if (index >= (intmax_t)len) {
+  if (index >= (int64_t)len) {
     return(NULL);
   }
-  if (index < -(intmax_t)len) {
+  if (index < -(int64_t)len) {
     return(NULL);
   }
   if (index < 0) {
-    index = (intmax_t)len + index;
+    index = (int64_t)len + index;
   }
 
   strncpy(string+index, string+index+1, len-1-index);
@@ -44921,13 +44920,13 @@ local char *bPrevUTF8Tiny(const char *string, const char *utf8) {
  *   pointer to character at index
  *   NULL when index is outside the string
  */
-char *idx2PtrUTF8(const char *utf8, intmax_t index) {
+char *idx2PtrUTF8(const char *utf8, int64_t index) {
 
   if (!utf8 || !*utf8 || !index) {
     return((char *)utf8);
   }
 
-  intmax_t len = strlen(utf8);
+  int64_t len = strlen(utf8);
 
   if (index > 0) {
     if (index > len) {
@@ -44937,7 +44936,7 @@ char *idx2PtrUTF8(const char *utf8, intmax_t index) {
 
     // go forward
     char *end = (char *)utf8 + len;;
-    intmax_t i = 0;;
+    int64_t i = 0;;
     while (i != index) {
       nxCodeUTF8(utf8);
       if (utf8 > end) {
@@ -44955,7 +44954,7 @@ char *idx2PtrUTF8(const char *utf8, intmax_t index) {
     // go from the end
     char *start = (char *)utf8;;
     utf8 += len;;
-    intmax_t i = 0;;
+    int64_t i = 0;;
     while (i != index) {
       utf8 = bPrevUTF8Tiny(start, utf8);;
       i--;
@@ -44964,7 +44963,7 @@ char *idx2PtrUTF8(const char *utf8, intmax_t index) {
   return((char *)utf8);
 }
 
-char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
+char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, int64_t index) {
 
   if (!utf8 || !*utf8 || !utf8Size || !index) {
     return((char *)utf8);
@@ -44978,7 +44977,7 @@ char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
 
     // go forward
     char *end = (char *)utf8 + utf8Size;;
-    intmax_t i = 0;;
+    int64_t i = 0;;
     while (i != index) {
       nxCodeUTF8(utf8);
       if (utf8 >= end) {
@@ -44988,7 +44987,7 @@ char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
   }
     }
   else {
-    if (index < -(intmax_t)utf8Size) {
+    if (index < -(int64_t)utf8Size) {
       // index is outside the string
       return(NULL);
     }
@@ -45003,7 +45002,7 @@ char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
     // go from the end
     char *start = (char *)utf8;;
     utf8 += len;;
-    intmax_t i = 0;;
+    int64_t i = 0;;
     while (i != index) {
       utf8 = bPrevUTF8Tiny(start, utf8);;
       i--;
@@ -45029,13 +45028,13 @@ char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index) {
  *   When pos < utf8, the result is negative
  *   0 failed or index 0
  */
-intmax_t ptr2IdxUTF8(const char *utf8, const char *pos) {
+int64_t ptr2IdxUTF8(const char *utf8, const char *pos) {
 
   if (!utf8 || !pos || utf8 == pos) {
     return(0);
   }
 
-  intmax_t r = 0;
+  int64_t r = 0;
 
   if (pos > utf8) {
     // there is at least one code point
@@ -45102,13 +45101,13 @@ intmax_t ptr2IdxUTF8(const char *utf8, const char *pos) {
  *   When pos < utf8, the result is negative
  *   0 failed or index 0
  */
-intmax_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos) {
+int64_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos) {
 
   if (!utf8 || !pos || utf8 == pos || !start || pos < start) {
     return(0);
   }
 
-  intmax_t r = 0;
+  int64_t r = 0;
 
   if (pos > utf8) {
     // there is at least one code point
@@ -45163,13 +45162,13 @@ intmax_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos) {
  *   Number of code points from utf8 to pos, positive
  *   -1 failed
  */
-intmax_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
+int64_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
 
   if (!utf8 || !utf8Size || !pos || (pos < utf8) || (pos >= (utf8+utf8Size))) {
     return(-1);
   }
 
-  intmax_t r = 0;
+  int64_t r = 0;
 
   // return 0 if utf8 = pos
   if (pos > utf8) {
@@ -45214,13 +45213,13 @@ intmax_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
  *   Number of code points from utf8 end to pos, negative
  *   0 failed
  */
-intmax_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
+int64_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos) {
 
   if (!utf8 || !utf8Size || !pos || (pos < utf8) || (pos >= (utf8+utf8Size))) {
     return(0);
   }
 
-  intmax_t r = 0;
+  int64_t r = 0;
 
   char *end = (char *)(utf8+utf8Size-1);
 
@@ -45970,24 +45969,24 @@ char *bLicReplaceManyUTF8F(char *s UNUSED, size_t sSize UNUSED, char *paramType 
  *   true string1 at index is equal to string2
  *   false they differ
  */
-bool eqIUTF8(const char *string1, const char *string2, intmax_t index) {
+bool eqIUTF8(const char *string1, const char *string2, int64_t index) {
 
   if (!string1) {
     return(false);
   }
 
   char *i = idx2PtrUTF8(string1, index);
-  return(eqIS(string1, string2, (intmax_t)(i-string1)));
+  return(eqIS(string1, string2, (int64_t)(i-string1)));
 }
 
-bool eqICharUTF8(const char *string1, char c, intmax_t index) {
+bool eqICharUTF8(const char *string1, char c, int64_t index) {
 
   if (!string1) {
     return(false);
   }
 
   char *i = idx2PtrUTF8(string1, index);
-  return(eqICharS(string1, c, (intmax_t)(i-string1)));
+  return(eqICharS(string1, c, (int64_t)(i-string1)));
 }
 
 
@@ -46054,13 +46053,13 @@ bool icEqUTF8Char(const char *string1, char c) {
  *   true string1 at index is equal to string2
  *   false they differ
  */
-bool icEqIUTF8(const char *string1 UNUSED, const char *string2 UNUSED, intmax_t index UNUSED) {
+bool icEqIUTF8(const char *string1 UNUSED, const char *string2 UNUSED, int64_t index UNUSED) {
 
   // TODO casefold changes the number of character, index might change
   return(false);
 }
 
-bool icEqICharUTF8(const char *string1 UNUSED, char c UNUSED, intmax_t index UNUSED) {
+bool icEqICharUTF8(const char *string1 UNUSED, char c UNUSED, int64_t index UNUSED) {
 
   // TODO casefold changes the number of character, index might change
   return(false);
@@ -47218,8 +47217,8 @@ char *bicUniqUTF8(char *string UNUSED, char c UNUSED) {
  * get char at python index
  *
  */
-rune getUTF8(const char *string, intmax_t index) {
-  intmax_t len;
+rune getUTF8(const char *string, int64_t index) {
+  int64_t len;
 
   if (!string) {
     return(0);
@@ -47249,8 +47248,8 @@ rune getUTF8(const char *string, intmax_t index) {
  * TODO this function might make the string invalid UTF8
  *      check codeSizeUTF8 and adjust the buffer
  */
-char *setUTF8(char *string, intmax_t index, rune c) {
-  intmax_t len;
+char *setUTF8(char *string, int64_t index, rune c) {
+  int64_t len;
 
   if (!string) {
     return(NULL);
@@ -47292,9 +47291,9 @@ char *setUTF8(char *string, intmax_t index, rune c) {
  *   "" when start=end
  *   NULL when start and end are not set correctly
  */
-char *sliceUTF8(const char *string, intmax_t start, intmax_t end) {
+char *sliceUTF8(const char *string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47333,7 +47332,7 @@ char *sliceUTF8(const char *string, intmax_t start, intmax_t end) {
     // copy range to a new string
     const char *startp = idx2PtrUTF8(string, start);
     const char *endp   = idx2PtrUTF8(string, end);
-    intmax_t n;
+    int64_t n;
     n = endp - startp;
     s = MALLOC(n+1);
     if (!s) {
@@ -47363,9 +47362,9 @@ char *sliceUTF8(const char *string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *iSliceUTF8(char **string, intmax_t start, intmax_t end) {
+char *iSliceUTF8(char **string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -47410,7 +47409,7 @@ char *iSliceUTF8(char **string, intmax_t start, intmax_t end) {
     // copy range to a new string
     char *startp = idx2PtrUTF8(*string, start);
     char *endp   = idx2PtrUTF8(*string, end);
-    intmax_t n;
+    int64_t n;
     n = endp - startp;
     s = MALLOC(n+1);
     if (!s) {
@@ -47442,8 +47441,8 @@ char *iSliceUTF8(char **string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *bSliceUTF8(char *string, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bSliceUTF8(char *string, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47485,7 +47484,7 @@ char *bSliceUTF8(char *string, intmax_t start, intmax_t end) {
     // copy range to a new string
     char *startp = idx2PtrUTF8(string, start);
     char *endp   = idx2PtrUTF8(string, end);
-    intmax_t n;
+    int64_t n;
     n = endp - startp;
     strncpy(string, string+(size_t)(startp-string), n);
     string[n] = 0;
@@ -47513,8 +47512,8 @@ char *bSliceUTF8(char *string, intmax_t start, intmax_t end) {
  *   "" when start=end
  *   NULL unchanged string when start and end are not set correctly
  */
-char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bLSliceUTF8(char *string, size_t stringSize, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -47580,7 +47579,7 @@ char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end)
   else {
     // start < end < stringSize
     // copy range to a new string
-    intmax_t n;
+    int64_t n;
     n = endp - startp;
     strncpy(string, string+starto, n);
     string[n] = 0;
@@ -47607,9 +47606,9 @@ char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end)
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *insertUTF8(const char *string, intmax_t index, const char *toInsert) {
+char *insertUTF8(const char *string, int64_t index, const char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47680,9 +47679,9 @@ char *insertUTF8(const char *string, intmax_t index, const char *toInsert) {
  *   new string (you must free the pointer)
  *   NULL when string is NULL or invalid index
  */
-char *insertNFreeUTF8(const char *string, intmax_t index, char *toInsert) {
+char *insertNFreeUTF8(const char *string, int64_t index, char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47761,9 +47760,9 @@ char *insertNFreeUTF8(const char *string, intmax_t index, char *toInsert) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInsertUTF8(char **string, intmax_t index, const char *toInsert) {
+char *iInsertUTF8(char **string, int64_t index, const char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47842,9 +47841,9 @@ char *iInsertUTF8(char **string, intmax_t index, const char *toInsert) {
  *   modified string (you must free the pointer)
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *iInsertNFreeUTF8(char **string, intmax_t index, char *toInsert) {
+char *iInsertNFreeUTF8(char **string, int64_t index, char *toInsert) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47926,8 +47925,8 @@ char *iInsertNFreeUTF8(char **string, intmax_t index, char *toInsert) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bInsertUTF8(char *string, intmax_t index, const char *toInsert) {
-  intmax_t len;
+char *bInsertUTF8(char *string, int64_t index, const char *toInsert) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -47998,8 +47997,8 @@ char *bInsertUTF8(char *string, intmax_t index, const char *toInsert) {
  *   modified string
  *   NULL unchanged string when string is NULL or invalid index
  */
-char *bLInsertUTF8(char *string, size_t stringSize, intmax_t index, const char *toInsert) {
-  intmax_t len;
+char *bLInsertUTF8(char *string, size_t stringSize, int64_t index, const char *toInsert) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -48075,9 +48074,9 @@ char *bLInsertUTF8(char *string, size_t stringSize, intmax_t index, const char *
  *   new identical string when start=end or when start and end are not set correctly
  *   NULL when input string is NULL or when malloc failed or when end is under start
  */
-char *delUTF8(const char *string, intmax_t start, intmax_t end) {
+char *delUTF8(const char *string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -48118,7 +48117,7 @@ char *delUTF8(const char *string, intmax_t start, intmax_t end) {
   const char *startp = idx2PtrUTF8(string, start);
   const char *endp   = idx2PtrUTF8(string, end);
   size_t starto      = (size_t)(startp-string);
-  intmax_t n;
+  int64_t n;
   n = endp - startp;
   s = MALLOC(len-n+1);
   if (!s) {
@@ -48150,9 +48149,9 @@ char *delUTF8(const char *string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *iDelUTF8(char **string, intmax_t start, intmax_t end) {
+char *iDelUTF8(char **string, int64_t start, int64_t end) {
   char *s = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!string || !*string) {
@@ -48193,7 +48192,7 @@ char *iDelUTF8(char **string, intmax_t start, intmax_t end) {
   char *startp  = idx2PtrUTF8(*string, start);
   char *endp    = idx2PtrUTF8(*string, end);
   size_t starto = (size_t)(startp-*string);
-  intmax_t n;
+  int64_t n;
   n = endp - startp;
   s = MALLOC(len-n+1);
   if (!s) {
@@ -48227,8 +48226,8 @@ char *iDelUTF8(char **string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *bDelUTF8(char *string, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bDelUTF8(char *string, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string) {
@@ -48269,7 +48268,7 @@ char *bDelUTF8(char *string, intmax_t start, intmax_t end) {
   const char *startp = idx2PtrUTF8(string, start);
   const char *endp   = idx2PtrUTF8(string, end);
   size_t starto      = (size_t)(startp-string);
-  intmax_t n;
+  int64_t n;
   n = endp - startp;
   strncpy(string+starto, string+starto+n, len-n-starto);
   string[len-n] = 0;
@@ -48298,8 +48297,8 @@ char *bDelUTF8(char *string, intmax_t start, intmax_t end) {
  *   NULL when start and end are not set correctly
  *        or when input string is NULL or when malloc failed or when end is under start
  */
-char *bLDelUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end) {
-  intmax_t len;
+char *bLDelUTF8(char *string, size_t stringSize, int64_t start, int64_t end) {
+  int64_t len;
 
   // sanity checks
   if (!string || !stringSize) {
@@ -48359,7 +48358,7 @@ char *bLDelUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end) {
 
   // start < end < len
   // copy range to a new string
-  intmax_t n;
+  int64_t n;
   n = endp - startp;
   strncpy(string+starto, string+starto+n, len-n-starto);
   string[len-n] = 0;
@@ -48930,7 +48929,7 @@ bool isBlankS(const char *string) {
  *   positive index
  *   -1 when length is 0 or index is not set correctly
  */
-ssize_t intIndex(intmax_t index, intmax_t length) {
+ssize_t intIndex(int64_t index, int64_t length) {
   ssize_t  r;
 
   // sanity checks
@@ -49474,9 +49473,9 @@ ssize_t listStrLengthS(char **list) {
  *   positive index
  *   -1 when list is NULL or index is not set correctly
  */
-ssize_t listIntIndexS(char **list, intmax_t index) {
+ssize_t listIntIndexS(char **list, int64_t index) {
   ssize_t  r;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -49511,9 +49510,9 @@ ssize_t listIntIndexS(char **list, intmax_t index) {
  *   pointer to char* at index
  *   NULL when list is NULL or index is not set correctly
  */
-char **listAddrS(char **list, intmax_t index) {
+char **listAddrS(char **list, int64_t index) {
   size_t  r;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -49549,8 +49548,8 @@ char **listAddrS(char **list, intmax_t index) {
  *   duplicated string (you must free the pointer)
  *   NULL when list is NULL or index is not set correctly
  */
-char *listGetS(char **list, intmax_t index) {
-  intmax_t len;
+char *listGetS(char **list, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -49583,8 +49582,8 @@ char *listGetS(char **list, intmax_t index) {
  *   string
  *   NULL when list is NULL or index is not set correctly
  */
-char *iListGetS(char **list, intmax_t index) {
-  intmax_t len;
+char *iListGetS(char **list, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -49623,8 +49622,8 @@ char *iListGetS(char **list, intmax_t index) {
  * Does nothing when:
  * when list is NULL, index is not set correctly or s is NULL
  */
-char **listSetS(char **list, intmax_t index, const char *s) {
-  intmax_t len;
+char **listSetS(char **list, int64_t index, const char *s) {
+  int64_t len;
 
   // sanity checks
   if (!list || !s) {
@@ -49647,7 +49646,7 @@ char **listSetS(char **list, intmax_t index, const char *s) {
   return(list);
 }
 
-char **listSetCharS(char **list, intmax_t index, char c) {
+char **listSetCharS(char **list, int64_t index, char c) {
 
   charToS(s, c);
   return(listSetS(list, index, s));
@@ -49671,8 +49670,8 @@ char **listSetCharS(char **list, intmax_t index, char c) {
  * Does nothing when:
  * when list is NULL, index is not set correctly or s is NULL
  */
-char **iListSetS(char **list, intmax_t index, char *s) {
-  intmax_t len;
+char **iListSetS(char **list, int64_t index, char *s) {
+  int64_t len;
 
   // sanity checks
   if (!list || !s) {
@@ -49708,8 +49707,8 @@ char **iListSetS(char **list, intmax_t index, char *s) {
  * new list with elements swapped at index1 and index2 (you must free this pointer)
  * NULL when list is NULL or when index1 or index2 are outside the list
  */
-char **listSwapS(char **list, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char **listSwapS(char **list, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!list) {
     return(NULL);
@@ -49758,8 +49757,8 @@ char **listSwapS(char **list, intmax_t index1, intmax_t index2) {
  * updated list with characters swapped at index1 and index2 (you must free this pointer)
  * NULL when list is NULL or when index1 or index2 are outside the list
  */
-char **iListSwapS(char **list, intmax_t index1, intmax_t index2) {
-  intmax_t len;
+char **iListSwapS(char **list, int64_t index1, int64_t index2) {
+  int64_t len;
 
   if (!list) {
     return(NULL);
@@ -50726,9 +50725,9 @@ char **listAddS(char **list1, char **list2) {
  *   NULL when list is empty
  *   NULL when list is NULL or when start and end are not set correctly
  */
-char **listSliceS(char **list, intmax_t start, intmax_t end) {
+char **listSliceS(char **list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -50766,13 +50765,13 @@ char **listSliceS(char **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((n+1) * sizeof(char *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < n;i++) {
+  for (int64_t i=0;i < n;i++) {
     l[i] = strdup(*(list+start+i));
   }
   l[n] = NULL;
@@ -50799,9 +50798,9 @@ char **listSliceS(char **list, intmax_t start, intmax_t end) {
  *   NULL when list is empty
  *   NULL when list is NULL or when start and end are not set correctly
  */
-char **iListCopyS(char **list, intmax_t start, intmax_t end) {
+char **iListCopyS(char **list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -50839,13 +50838,13 @@ char **iListCopyS(char **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((n+1) * sizeof(char *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < n;i++) {
+  for (int64_t i=0;i < n;i++) {
     l[i] = *(list+start+i);
   }
   l[n] = NULL;
@@ -50870,9 +50869,9 @@ char **iListCopyS(char **list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char **iListSliceS(char ***list, intmax_t start, intmax_t end) {
+char **iListSliceS(char ***list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -50917,22 +50916,22 @@ char **iListSliceS(char ***list, intmax_t start, intmax_t end) {
   }
   else {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char *));
     if (!l) {
       return(NULL);
     }
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       l[i] = *((*list)+start+i);
     }
     l[n] = NULL;
     // free 0 < start
-    for (intmax_t i=0;i < start;i++) {
+    for (int64_t i=0;i < start;i++) {
       free((*list)[i]);
     }
     // free end < len
-    for (intmax_t i=end;i < len;i++) {
+    for (int64_t i=end;i < len;i++) {
       free((*list)[i]);
     }
     free(*list);
@@ -50964,9 +50963,9 @@ char **iListSliceS(char ***list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char **listCropS(char **list, intmax_t start, intmax_t end) {
+char **listCropS(char **list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -51004,18 +51003,18 @@ char **listCropS(char **list, intmax_t start, intmax_t end) {
   }
   else {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char *));
     if (!l) {
       return(NULL);
     }
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       l[i] = *(list+start+i);
     }
     l[n] = NULL;
     // free end < len
-    for (intmax_t i=0;i < (len - end);i++) {
+    for (int64_t i=0;i < (len - end);i++) {
       list[i+start] = *(list+i+end);
     }
     list[len-n] = NULL;
@@ -51046,9 +51045,9 @@ char **listCropS(char **list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char **iListCropS(char ***list, intmax_t start, intmax_t end) {
+char **iListCropS(char ***list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -51086,18 +51085,18 @@ char **iListCropS(char ***list, intmax_t start, intmax_t end) {
   }
   else {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(char *));
     if (!l) {
       return(NULL);
     }
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       l[i] = *((*list)+start+i);
     }
     l[n] = NULL;
     // free end < len
-    for (intmax_t i=0;i < (len - end);i++) {
+    for (int64_t i=0;i < (len - end);i++) {
       (*list)[i+start] = *((*list)+i+end);
     }
     (*list)[len-n] = NULL;
@@ -51126,9 +51125,9 @@ char **iListCropS(char ***list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char *listCropElemS(char **list, intmax_t index) {
+char *listCropElemS(char **list, int64_t index) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -51152,7 +51151,7 @@ char *listCropElemS(char **list, intmax_t index) {
   }
 
   r = *(list+index);
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     list[i] = *(list+1+i);
   }
   list[len-1] = NULL;
@@ -51180,9 +51179,9 @@ char *listCropElemS(char **list, intmax_t index) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-char *iListCropElemS(char ***list, intmax_t index) {
+char *iListCropElemS(char ***list, int64_t index) {
   char *r = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -51206,7 +51205,7 @@ char *iListCropElemS(char ***list, intmax_t index) {
   }
 
   r = *((*list)+index);
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     (*list)[i] = *((*list)+1+i);
   }
   (*list)[len-1] = NULL;
@@ -51233,9 +51232,9 @@ char *iListCropElemS(char ***list, intmax_t index) {
  *   new list (you must free the pointer with listFreeS)
  *   NULL when list is NULL or invalid index
  */
-char **listInsertS(char **list, intmax_t index, char **toInsert) {
+char **listInsertS(char **list, int64_t index, char **toInsert) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list) {
@@ -51307,9 +51306,9 @@ char **listInsertS(char **list, intmax_t index, char **toInsert) {
  *   unchanged list when list is NULL or invalid index
  *   NULL error
  */
-char **iListInsertS(char ***list, intmax_t index, char **toInsert) {
+char **iListInsertS(char ***list, int64_t index, char **toInsert) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list || !toInsert) {
@@ -51408,9 +51407,9 @@ char **iListInsertS(char ***list, intmax_t index, char **toInsert) {
  *   unchanged list when list is NULL or invalid index
  *   NULL error
  */
-char **iListInsertNFreeS(char ***list, intmax_t index, char **toInsert) {
+char **iListInsertNFreeS(char ***list, int64_t index, char **toInsert) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list || !toInsert) {
@@ -51501,9 +51500,9 @@ char **iListInsertNFreeS(char ***list, intmax_t index, char **toInsert) {
  *   new list (you must free the pointer with listFreeS)
  *   NULL when list is NULL or invalid index
  */
-char **listInjectS(char **list, intmax_t index, char *toInject) {
+char **listInjectS(char **list, int64_t index, char *toInject) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list) {
@@ -51560,7 +51559,7 @@ char **listInjectS(char **list, intmax_t index, char *toInject) {
   return(r);
 }
 
-char **listInjectCharS(char **list, intmax_t index, char toInject) {
+char **listInjectCharS(char **list, int64_t index, char toInject) {
 
   charToS(s, toInject);
   return(listInjectS(list, index, s));
@@ -51586,9 +51585,9 @@ char **listInjectCharS(char **list, intmax_t index, char toInject) {
  *   unchanged list when list is NULL or invalid index
  *   NULL error
  */
-char **iListInjectS(char ***list, intmax_t index, char *toInject) {
+char **iListInjectS(char ***list, int64_t index, char *toInject) {
   char **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list || !toInject) {
@@ -51650,7 +51649,7 @@ char **iListInjectS(char ***list, intmax_t index, char *toInject) {
   return(r);
 }
 
-char **iListInjectCharS(char ***list, intmax_t index, char toInject) {
+char **iListInjectCharS(char ***list, int64_t index, char toInject) {
 
   if (!list) {
     return(NULL);
@@ -51682,9 +51681,9 @@ char **iListInjectCharS(char ***list, intmax_t index, char toInject) {
  *   NULL when list is empty
  *   NULL when list is NULL or when end is under start
  */
-char **listDelS(char **list, intmax_t start, intmax_t end) {
+char **listDelS(char **list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -51724,16 +51723,16 @@ char **listDelS(char **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(char *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = strdup(*(list+i));
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = strdup(*(list+n+i));
   }
   l[len-n] = NULL;
@@ -51759,9 +51758,9 @@ char **listDelS(char **list, intmax_t start, intmax_t end) {
  *   NULL when list is NULL or when end is under start
  *   NULL error
  */
-char **iListDelS(char ***list, intmax_t start, intmax_t end) {
+char **iListDelS(char ***list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -51801,19 +51800,19 @@ char **iListDelS(char ***list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(char *));
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = *((*list)+i);
   }
-  for (intmax_t i=0;i < n;i++) {
+  for (int64_t i=0;i < n;i++) {
     free(*((*list)+start+i));
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = *((*list)+n+i);
   }
   l[len-n] = NULL;
@@ -51842,9 +51841,9 @@ char **iListDelS(char ***list, intmax_t start, intmax_t end) {
  *   NULL when list is NULL or when end is under start
  *   NULL error
  */
-char **iListRemoveS(char ***list, intmax_t start, intmax_t end) {
+char **iListRemoveS(char ***list, int64_t start, int64_t end) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -51884,16 +51883,16 @@ char **iListRemoveS(char ***list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(char *));
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = *((*list)+i);
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = *((*list)+n+i);
   }
   l[len-n] = NULL;
@@ -51917,9 +51916,9 @@ char **iListRemoveS(char ***list, intmax_t start, intmax_t end) {
  *   NULL when list is empty
  *   NULL when list is NULL
  */
-char **listDelElemS(char **list, intmax_t index) {
+char **listDelElemS(char **list, int64_t index) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -51946,10 +51945,10 @@ char **listDelElemS(char **list, intmax_t index) {
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < index;i++) {
+  for (int64_t i=0;i < index;i++) {
     l[i] = strdup(*(list+i));
   }
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     l[i] = strdup(*(list+1+i));
   }
   l[len-1] = NULL;
@@ -51972,9 +51971,9 @@ char **listDelElemS(char **list, intmax_t index) {
  *   NULL when list is NULL
  *   NULL error
  */
-char **iListDelElemS(char ***list, intmax_t index) {
+char **iListDelElemS(char ***list, int64_t index) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -52001,11 +52000,11 @@ char **iListDelElemS(char ***list, intmax_t index) {
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < index;i++) {
+  for (int64_t i=0;i < index;i++) {
     l[i] = *((*list)+i);
   }
   free(*((*list)+index));
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     l[i] = *((*list)+1+i);
   }
   l[len-1] = NULL;
@@ -52032,9 +52031,9 @@ char **iListDelElemS(char ***list, intmax_t index) {
  *   NULL when list is NULL
  *   NULL error
  */
-char **iListRemoveElemS(char ***list, intmax_t index) {
+char **iListRemoveElemS(char ***list, int64_t index) {
   char **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -52061,10 +52060,10 @@ char **iListRemoveElemS(char ***list, intmax_t index) {
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < index;i++) {
+  for (int64_t i=0;i < index;i++) {
     l[i] = *((*list)+i);
   }
-  for (intmax_t i=index ; i < len-1 ; i++) {
+  for (int64_t i=index ; i < len-1 ; i++) {
     l[i] = *((*list)+1+i);
   }
   l[len-1] = NULL;
@@ -53820,8 +53819,8 @@ size_t listLength(void **list) {
  *   element
  *   NULL when list is NULL or index is not set correctly
  */
-void *listGet(void **list, intmax_t index) {
-  intmax_t len;
+void *listGet(void **list, int64_t index) {
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -53864,8 +53863,8 @@ void *listGet(void **list, intmax_t index) {
  * Does nothing when:
  * when list is NULL, index is not set correctly or s is NULL
  */
-void **listSet(void **list, intmax_t index, void *s) {
-  intmax_t len;
+void **listSet(void **list, int64_t index, void *s) {
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -54165,9 +54164,9 @@ void **listAdd(void **list1, void **list2) {
  *   NULL when list is empty
  *   NULL when list is NULL or when start and end are not set correctly
  */
-void **listSlice(void **list, intmax_t start, intmax_t end) {
+void **listSlice(void **list, int64_t start, int64_t end) {
   void **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -54205,13 +54204,13 @@ void **listSlice(void **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((n+1) * sizeof(void *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < n;i++) {
+  for (int64_t i=0;i < n;i++) {
     l[i] = *(list+start+i);
   }
   l[n] = NULL;
@@ -54236,9 +54235,9 @@ void **listSlice(void **list, intmax_t start, intmax_t end) {
  *   unchanged when list is NULL or when start and end are not set correctly
  *   NULL error
  */
-void **iListSlice(void ***list, intmax_t start, intmax_t end) {
+void **iListSlice(void ***list, int64_t start, int64_t end) {
   void **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -54281,13 +54280,13 @@ void **iListSlice(void ***list, intmax_t start, intmax_t end) {
   }
   else {
     // start < end < len
-    intmax_t n;
+    int64_t n;
     n = end - start;
     l = MALLOC((n+1) * sizeof(void *));
     if (!l) {
       return(NULL);
     }
-    for (intmax_t i=0;i < n;i++) {
+    for (int64_t i=0;i < n;i++) {
       l[i] = *((*list)+start+i);
     }
     l[n] = NULL;
@@ -54317,9 +54316,9 @@ void **iListSlice(void ***list, intmax_t start, intmax_t end) {
  *   new list (you must free the pointer)
  *   NULL when list is NULL or invalid index
  */
-void **listInsert(void **list, intmax_t index, void **toInsert) {
+void **listInsert(void **list, int64_t index, void **toInsert) {
   void **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list) {
@@ -54397,9 +54396,9 @@ void **listInsert(void **list, intmax_t index, void **toInsert) {
  *   unchanged list when list is NULL or invalid index
  *   NULL error
  */
-void **iListInsert(void ***list, intmax_t index, void **toInsert) {
+void **iListInsert(void ***list, int64_t index, void **toInsert) {
   void **r = NULL;
-  intmax_t len;
+  int64_t len;
 
   //sanity checks
   if (!list || !toInsert) {
@@ -54479,9 +54478,9 @@ void **iListInsert(void ***list, intmax_t index, void **toInsert) {
  *   NULL when list is empty
  *   NULL when list is NULL or when end is under start
  */
-void **listDel(void **list, intmax_t start, intmax_t end) {
+void **listDel(void **list, int64_t start, int64_t end) {
   void **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list) {
@@ -54521,16 +54520,16 @@ void **listDel(void **list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(void *));
   if (!l) {
     return(NULL);//LCOV_EXCL_LINE
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = *(list+i);
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = *(list+n+i);
   }
   l[len-n] = NULL;
@@ -54556,9 +54555,9 @@ void **listDel(void **list, intmax_t start, intmax_t end) {
  *   NULL when list is NULL or when end is under start
  *   NULL error
  */
-void **iListDel(void ***list, intmax_t start, intmax_t end) {
+void **iListDel(void ***list, int64_t start, int64_t end) {
   void **l = NULL;
-  intmax_t len;
+  int64_t len;
 
   // sanity checks
   if (!list || !*list) {
@@ -54598,16 +54597,16 @@ void **iListDel(void ***list, intmax_t start, intmax_t end) {
   }
 
   // start < end < len
-  intmax_t n;
+  int64_t n;
   n = end - start;
   l = MALLOC((len-n+1) * sizeof(void *));
   if (!l) {
     return(NULL);
   }
-  for (intmax_t i=0;i < start;i++) {
+  for (int64_t i=0;i < start;i++) {
     l[i] = *((*list)+i);
   }
-  for (intmax_t i=start ; i < len-n ; i++) {
+  for (int64_t i=start ; i < len-n ; i++) {
     l[i] = *((*list)+n+i);
   }
   l[len-n] = NULL;
diff --git a/src/libsheepy.h b/src/libsheepy.h
@@ -98,7 +98,7 @@
 
 // version accoring to the version package: Release.Major.minor.patch
 // https://noulin.net/version/file/README.md.html
-#define LIBSHEEPY_VERSION "1.2.5"
+#define LIBSHEEPY_VERSION "2.2.5.1"
 
 #ifndef SH_PREFIX
 #define SH_PREFIX(NAME) NAME
@@ -691,7 +691,7 @@ extern jmp_buf tryJumpBuffers[maxTryThrowCount];
  *   AT;
  *   libsheepy.c, main:9149
  */
-#define AT pLog(LOG_INFO, __FILE__", %s:"stringifyExpr(__LINE__)"\n",__func__);
+#define AT pLog(LOG_DEBUG, __FILE__", %s:"stringifyExpr(__LINE__)"\n",__func__);
 
 /**
  * print a todo message in log
@@ -1945,9 +1945,9 @@ bool eqCharS(char c, const char *string2);
 bool eqSChar(const char *string1, char c);
 
 // string equal at index (compare content)
-bool eqIS(const char *string1, const char *string2, intmax_t index);
+bool eqIS(const char *string1, const char *string2, int64_t index);
 #define strIEq eqIS
-bool eqICharS(const char *string1, char c, intmax_t index);
+bool eqICharS(const char *string1, char c, int64_t index);
 
 // look for string2 at string1 start
 bool startsWithS(const char *string1, const char *string2);
@@ -1967,8 +1967,8 @@ bool icEqCharS(char c, const char *string2);
 bool icEqSChar(const char *string1, char c);
 
 // ignore case string equal at index (compare content)
-bool icEqIS(const char *string1, const char *string2, intmax_t index);
-bool icEqICharS(const char *string1, char c, intmax_t index);
+bool icEqIS(const char *string1, const char *string2, int64_t index);
+bool icEqICharS(const char *string1, char c, int64_t index);
 
 // ignore case and look for string2 at string1 start
 bool icStartsWithS(const char *string1, const char *string2);
@@ -1997,8 +1997,8 @@ bool isNumber(const char *string);
 bool isInt(const char *string);
 
 // parseInt
-intmax_t parseInt(const char *string);
-intmax_t parseIntChar(char c);
+int64_t parseInt(const char *string);
+int64_t parseIntChar(char c);
 int64_t parseI64(const char *string);
 int64_t parseI64Char(char c);
 
@@ -2011,8 +2011,8 @@ uint64_t parseHex(const char *string);
 // TODO parseHexChar
 
 // convert int to string
-char *intToS(intmax_t n);
-char *bIntToS(char *s, intmax_t n);
+char *intToS(int64_t n);
+char *bIntToS(char *s, int64_t n);
 
 // convert double to string
 char *doubleToS(double n);
@@ -2129,56 +2129,56 @@ char *bLPadEndCharS(char *dest, size_t destSize, const char *string, size_t targ
 ssize_t padEndLenS(const char *string, size_t targetLength, const char *padString);
 
 // get char at python index
-char getS(const char *string, intmax_t index);
+char getS(const char *string, int64_t index);
 
 // set char at python index
-char *setS(char *string, intmax_t index, char c);
+char *setS(char *string, int64_t index, char c);
 
 // swap characters in a string
-char *swapS(char *string, intmax_t index1, intmax_t index2);
-char *iSwapS(char **string, intmax_t index1, intmax_t index2);
-char *bSwapS(char *string, intmax_t index1, intmax_t index2);
-char *bLSwapS(char *string, size_t size, intmax_t index1, intmax_t index2);
+char *swapS(char *string, int64_t index1, int64_t index2);
+char *iSwapS(char **string, int64_t index1, int64_t index2);
+char *bSwapS(char *string, int64_t index1, int64_t index2);
+char *bLSwapS(char *string, size_t size, int64_t index1, int64_t index2);
 
 // slice string
 // function to slice parts of a string [1:10] - python style indexes 0..len-1 -1..-len+1
-char *sliceS(const char *string, intmax_t start, intmax_t end);
-char *iSliceS(char **string, intmax_t start, intmax_t end);
-char *bSliceS(char *string, intmax_t start, intmax_t end);
-char *bLSliceS(char *string, size_t stringSize, intmax_t start, intmax_t end);
+char *sliceS(const char *string, int64_t start, int64_t end);
+char *iSliceS(char **string, int64_t start, int64_t end);
+char *bSliceS(char *string, int64_t start, int64_t end);
+char *bLSliceS(char *string, size_t stringSize, int64_t start, int64_t end);
 
 // crop string (slice+del)
-char *cropS(char *string, intmax_t start, intmax_t end);
-char *iCropS(char **string, intmax_t start, intmax_t end);
-char cropElemS(char *string, intmax_t index);
-char iCropElemS(char **string, intmax_t index);
+char *cropS(char *string, int64_t start, int64_t end);
+char *iCropS(char **string, int64_t start, int64_t end);
+char cropElemS(char *string, int64_t index);
+char iCropElemS(char **string, int64_t index);
 
 // insert string in string
-char *insertS(const char *string, intmax_t index, const char *toInsert);
-char *insertNFreeS(const char *string, intmax_t index, char *toInsert);
-char *iInsertS(char **string, intmax_t index, const char *toInsert);
-char *iInsertNFreeS(char **string, intmax_t index, char *toInsert);
-char *bInsertS(char *string, intmax_t index, const char *toInsert);
-char *bLInsertS(char *string, size_t stringSize, intmax_t index, const char *toInsert);
+char *insertS(const char *string, int64_t index, const char *toInsert);
+char *insertNFreeS(const char *string, int64_t index, char *toInsert);
+char *iInsertS(char **string, int64_t index, const char *toInsert);
+char *iInsertNFreeS(char **string, int64_t index, char *toInsert);
+char *bInsertS(char *string, int64_t index, const char *toInsert);
+char *bLInsertS(char *string, size_t stringSize, int64_t index, const char *toInsert);
 
 // inject a char in string
-char *injectS(const char *string, intmax_t index, char toInject);
-char *iInjectS(char **string, intmax_t index, char toInject);
-char *bInjectS(char *string, intmax_t index, char toInject);
-char *bLInjectS(char *string, size_t stringSize, intmax_t index, char toInject);
+char *injectS(const char *string, int64_t index, char toInject);
+char *iInjectS(char **string, int64_t index, char toInject);
+char *bInjectS(char *string, int64_t index, char toInject);
+char *bLInjectS(char *string, size_t stringSize, int64_t index, char toInject);
 
 // del string
 // function to delete parts of a string [1:10] - python style indexes 0..len-1 -1..-len+1
-char *delS(const char *string, intmax_t start, intmax_t end);
-char *iDelS(char **string, intmax_t start, intmax_t end);
-char *bDelS(char *string, intmax_t start, intmax_t end);
-char *bLDelS(char *string, size_t stringSize, intmax_t start, intmax_t end);
+char *delS(const char *string, int64_t start, int64_t end);
+char *iDelS(char **string, int64_t start, int64_t end);
+char *bDelS(char *string, int64_t start, int64_t end);
+char *bLDelS(char *string, size_t stringSize, int64_t start, int64_t end);
 
 // del a character in string
-char *delElemS(const char *string, intmax_t index);
-char *iDelElemS(char **string, intmax_t index);
-char *bDelElemS(char *string, intmax_t index);
-char *bLDelElemS(char *string, size_t stringSize, intmax_t index);
+char *delElemS(const char *string, int64_t index);
+char *iDelElemS(char **string, int64_t index);
+char *bDelElemS(char *string, int64_t index);
+char *bLDelElemS(char *string, size_t stringSize, int64_t index);
 
 // find substring
 char *findS(const char *string, const char *needle);
@@ -2250,14 +2250,14 @@ char *prevUTF8(const char *utf8);
 char *bPrevUTF8(const char *string, const char *utf8);
 
 // character index to pointer
-char *idx2PtrUTF8(const char *utf8, intmax_t index);
-char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, intmax_t index);
+char *idx2PtrUTF8(const char *utf8, int64_t index);
+char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, int64_t index);
 
 // pointer to character index
-intmax_t ptr2IdxUTF8(const char *utf8, const char *pos);
-intmax_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos);
-intmax_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
-intmax_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
+int64_t ptr2IdxUTF8(const char *utf8, const char *pos);
+int64_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos);
+int64_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
+int64_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos);
 
 // make new valid UTF-8 encoded string
 char *makeValidUTF8(const char *utf8);
@@ -2309,10 +2309,10 @@ char *bicReplaceManyUTF8F(char *s, char *paramType, ...);
 char *bLicReplaceManyUTF8F(char *s, size_t sSize, char *paramType, ...);
 
 // UTF8 encoded string Index Equal
-bool eqIUTF8(const char *string1, const char *string2, intmax_t index);
+bool eqIUTF8(const char *string1, const char *string2, int64_t index);
 
 // UTF8 encoded string Index Equal
-bool eqICharUTF8(const char *string1, char c, intmax_t index);
+bool eqICharUTF8(const char *string1, char c, int64_t index);
 
 // ignore case UTF8 encoded string Equal
 bool icEqUTF8(const char *string1, const char *string2);
@@ -2320,9 +2320,9 @@ bool icEqCharUTF8(char c, const char *string2);
 bool icEqUTF8Char(const char *string1, char c);
 
 // TODO
-bool icEqIUTF8(const char *string1, const char *string2, intmax_t index);
+bool icEqIUTF8(const char *string1, const char *string2, int64_t index);
 // TODO
-bool icEqICharUTF8(const char *string1, char c, intmax_t index);
+bool icEqICharUTF8(const char *string1, char c, int64_t index);
 
 // starts with for UTF-8 encoded string
 bool icStartsWithUTF8(const char *string1, const char *string2);
@@ -2376,30 +2376,30 @@ char *iicUniqUTF8(char **string, const char *code);
 char *bicUniqUTF8(char *string, char c);
 
 // get rune in UTF8 encoded string
-rune getUTF8(const char *string, intmax_t index);
+rune getUTF8(const char *string, int64_t index);
 
 // TODO
-char *setUTF8(char *string, intmax_t index, rune c);
+char *setUTF8(char *string, int64_t index, rune c);
 
 // slice UTF8 encoded String
-char *sliceUTF8(const char *string, intmax_t start, intmax_t end);
-char *iSliceUTF8(char **string, intmax_t start, intmax_t end);
-char *bSliceUTF8(char *string, intmax_t start, intmax_t end);
-char *bLSliceUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end);
+char *sliceUTF8(const char *string, int64_t start, int64_t end);
+char *iSliceUTF8(char **string, int64_t start, int64_t end);
+char *bSliceUTF8(char *string, int64_t start, int64_t end);
+char *bLSliceUTF8(char *string, size_t stringSize, int64_t start, int64_t end);
 
 // insert string in UTF8 encoded string at index
-char *insertUTF8(const char *string, intmax_t index, const char *toInsert);
-char *insertNFreeUTF8(const char *string, intmax_t index, char *toInsert);
-char *iInsertUTF8(char **string, intmax_t index, const char *toInsert);
-char *iInsertNFreeUTF8(char **string, intmax_t index, char *toInsert);
-char *bInsertUTF8(char *string, intmax_t index, const char *toInsert);
-char *bLInsertUTF8(char *string, size_t stringSize, intmax_t index, const char *toInsert);
+char *insertUTF8(const char *string, int64_t index, const char *toInsert);
+char *insertNFreeUTF8(const char *string, int64_t index, char *toInsert);
+char *iInsertUTF8(char **string, int64_t index, const char *toInsert);
+char *iInsertNFreeUTF8(char **string, int64_t index, char *toInsert);
+char *bInsertUTF8(char *string, int64_t index, const char *toInsert);
+char *bLInsertUTF8(char *string, size_t stringSize, int64_t index, const char *toInsert);
 
 // delete UTF8 encoded string
-char *delUTF8(const char *string, intmax_t start, intmax_t end);
-char *iDelUTF8(char **string, intmax_t start, intmax_t end);
-char *bDelUTF8(char *string, intmax_t start, intmax_t end);
-char *bLDelUTF8(char *string, size_t stringSize, intmax_t start, intmax_t end);
+char *delUTF8(const char *string, int64_t start, int64_t end);
+char *iDelUTF8(char **string, int64_t start, int64_t end);
+char *bDelUTF8(char *string, int64_t start, int64_t end);
+char *bLDelUTF8(char *string, size_t stringSize, int64_t start, int64_t end);
 
 // indexOf UTF8 encoded String
 ssize_t indexOfUTF8(const char *string, const char *needle);
@@ -2477,7 +2477,7 @@ bool isBlankS(const char *string);
 
 
 // convert python index (int, positive and negative) to always positive index (uint), this function is more generic than listIntIndexS
-ssize_t intIndex(intmax_t index, intmax_t length);
+ssize_t intIndex(int64_t index, int64_t length);
 
 // create empty list
 #define listEmptyS(list) \
@@ -2535,23 +2535,23 @@ size_t listLengthS(char **list);
 ssize_t listStrLengthS(char **list);
 
 // convert python index (int) to always positive index (uint)
-ssize_t listIntIndexS(char **list, intmax_t index);
+ssize_t listIntIndexS(char **list, int64_t index);
 
 // pointer to the char* at python index
-char **listAddrS(char **list, intmax_t index);
+char **listAddrS(char **list, int64_t index);
 
 // list get - get a string at python index
-char *listGetS(char **list, intmax_t index);
-char *iListGetS(char **list, intmax_t index);
+char *listGetS(char **list, int64_t index);
+char *iListGetS(char **list, int64_t index);
 
 // list set - replace a string at python index
-char **listSetS(char **list, intmax_t index, const char *s);
-char **listSetCharS(char **list, intmax_t index, char c);
-char **iListSetS(char **list, intmax_t index, char *s);
+char **listSetS(char **list, int64_t index, const char *s);
+char **listSetCharS(char **list, int64_t index, char c);
+char **iListSetS(char **list, int64_t index, char *s);
 
 // swap elements in a list
-char **listSwapS(char **list, intmax_t index1, intmax_t index2);
-char **iListSwapS(char **list, intmax_t index1, intmax_t index2);
+char **listSwapS(char **list, int64_t index1, int64_t index2);
+char **iListSwapS(char **list, int64_t index1, int64_t index2);
 
 // split
 char **split(const char *string, const char* delim);
@@ -2610,36 +2610,36 @@ char **iListShiftNSmashS(char ***list1, char **list2);
 char **listAddS(char **list1, char **list2);
 
 // slice - python style indexes 0..len-1 -1..-len+1
-char **listSliceS(char **list, intmax_t start, intmax_t end);
-char **iListCopyS(char **list, intmax_t start, intmax_t end);
-char **iListSliceS(char ***list, intmax_t start, intmax_t end);
+char **listSliceS(char **list, int64_t start, int64_t end);
+char **iListCopyS(char **list, int64_t start, int64_t end);
+char **iListSliceS(char ***list, int64_t start, int64_t end);
 
 // crop list (slice+del)
-char **listCropS(char **list, intmax_t start, intmax_t end);
-char **iListCropS(char ***list, intmax_t start, intmax_t end);
-char *listCropElemS(char **list, intmax_t index);
-char *iListCropElemS(char ***list, intmax_t index);
+char **listCropS(char **list, int64_t start, int64_t end);
+char **iListCropS(char ***list, int64_t start, int64_t end);
+char *listCropElemS(char **list, int64_t index);
+char *iListCropElemS(char ***list, int64_t index);
 
 // insert list in list
-char **listInsertS(char **list, intmax_t index, char **toInsert);
-char **iListInsertS(char ***list, intmax_t index, char **toInsert);
-char **iListInsertNFreeS(char ***list, intmax_t index, char **toInsert);
+char **listInsertS(char **list, int64_t index, char **toInsert);
+char **iListInsertS(char ***list, int64_t index, char **toInsert);
+char **iListInsertNFreeS(char ***list, int64_t index, char **toInsert);
 
 // inject string in list
-char **listInjectS(char **list, intmax_t index, char *toInject);
-char **listInjectCharS(char **list, intmax_t index, char toInject);
-char **iListInjectS(char ***list, intmax_t index, char *toInject);
-char **iListInjectCharS(char ***list, intmax_t index, char toInject);
+char **listInjectS(char **list, int64_t index, char *toInject);
+char **listInjectCharS(char **list, int64_t index, char toInject);
+char **iListInjectS(char ***list, int64_t index, char *toInject);
+char **iListInjectCharS(char ***list, int64_t index, char toInject);
 
 // del - python style indexes 0..len-1 -1..-len+1
-char **listDelS(char **list, intmax_t start, intmax_t end);
-char **iListDelS(char ***list, intmax_t start, intmax_t end);
-char **iListRemoveS(char ***list, intmax_t start, intmax_t end);
+char **listDelS(char **list, int64_t start, int64_t end);
+char **iListDelS(char ***list, int64_t start, int64_t end);
+char **iListRemoveS(char ***list, int64_t start, int64_t end);
 
 // del element in list
-char **listDelElemS(char **list, intmax_t index);
-char **iListDelElemS(char ***list, intmax_t index);
-char **iListRemoveElemS(char ***list, intmax_t index);
+char **listDelElemS(char **list, int64_t index);
+char **iListDelElemS(char ***list, int64_t index);
+char **iListRemoveElemS(char ***list, int64_t index);
 
 // print list
 int listPrintS(char **list);
@@ -3139,10 +3139,10 @@ void listFreeManyF(void **paramType, ...);
 size_t listLength(void **list);
 
 // list get - get an element at python index
-void *listGet(void **list, intmax_t index);
+void *listGet(void **list, int64_t index);
 
 // list set - replace a string at python index
-void **listSet(void **list, intmax_t index, void *s);
+void **listSet(void **list, int64_t index, void *s);
 
 // duplicate list
 void **listDup(void **list);
@@ -3162,17 +3162,17 @@ void **listAppend(void ***list1, void **list2);
 void **listAdd(void **list1, void **list2);
 
 // slice - python style indexes 0..len-1 -1..-len+1
-void **listSlice(void **list, intmax_t start, intmax_t end);
-void **iListSlice(void ***list, intmax_t start, intmax_t end);
+void **listSlice(void **list, int64_t start, int64_t end);
+void **iListSlice(void ***list, int64_t start, int64_t end);
 
 // insert list in list
-void **listInsert(void **list, intmax_t index, void **toInsert);
-void **iListInsert(void ***list, intmax_t index, void **toInsert);
+void **listInsert(void **list, int64_t index, void **toInsert);
+void **iListInsert(void ***list, int64_t index, void **toInsert);
 
 // del - python style indexes 0..len-1 -1..-len+1
-void **listDel(void **list, intmax_t start, intmax_t end);
-void **iListDel(void ***list, intmax_t start, intmax_t end);
-//NOT NEEDED same as iListDel - void **iListRemove(void ***list, intmax_t start, intmax_t end);
+void **listDel(void **list, int64_t start, int64_t end);
+void **iListDel(void ***list, int64_t start, int64_t end);
+//NOT NEEDED same as iListDel - void **iListRemove(void ***list, int64_t start, int64_t end);
 
 // duplicate and sort
 //TODO void **listSort(void **list);
@@ -5568,8 +5568,8 @@ void **iListDel(void ***list, intmax_t start, intmax_t end);
  */
 #define dVectorT(typeName, elementType)\
   typedef struct {\
-    intmax_t    count;\
-    intmax_t    maxCount;\
+    int64_t    count;\
+    int64_t    maxCount;\
     void**      buffers;\
     elementType element;\
   } typeName
@@ -6798,9 +6798,9 @@ bool fiberPrepend(void *ctx, int thisSlot, fiberFT func);
  */
 #define dArrayT(typeName, elementType)\
   typedef struct {\
-    intmax_t    last;\
-    intmax_t    head;\
-    intmax_t    maxCount;\
+    int64_t    last;\
+    int64_t    head;\
+    int64_t    maxCount;\
     void**      buffers;\
     elementType element;\
   } typeName
@@ -7279,9 +7279,9 @@ bool fiberPrepend(void *ctx, int thisSlot, fiberFT func);
  */
 #define slabT(typeName, elementType)\
   typedef struct {\
-    intmax_t    last;\
-    intmax_t    head;\
-    intmax_t    maxCount;\
+    int64_t      last;\
+    int64_t      head;\
+    int64_t      maxCount;\
     elementType *array;\
   } typeName
 
diff --git a/src/libsheepyCuTest.c b/src/libsheepyCuTest.c
@@ -9730,7 +9730,7 @@ void bLIdx2PtrUTF8T(CuTest *tc UNUSED) {
 void ptr2IdxUTF8T(CuTest *tc UNUSED) {
 
   char b[20] = init0Var;
-  intmax_t r;
+  int64_t r;
   strcpy(b, "£sheepy");
 
   // pointer to index
@@ -9765,7 +9765,7 @@ void ptr2IdxUTF8T(CuTest *tc UNUSED) {
 void bPtr2IdxUTF8T(CuTest *tc UNUSED) {
 
   char b[20] = init0Var;
-  intmax_t r;
+  int64_t r;
   strcpy(b, "£sheepy");
 
   // pointer to index
@@ -9801,7 +9801,7 @@ void bPtr2IdxUTF8T(CuTest *tc UNUSED) {
 void bLPtr2IdxUTF8T(CuTest *tc UNUSED) {
 
   char b[20] = init0Var;
-  intmax_t r;
+  int64_t r;
   strcpy(b, "£sheepy");
 
   // pointer to index
@@ -9836,7 +9836,7 @@ void bLPtr2IdxUTF8T(CuTest *tc UNUSED) {
 void bLPtr2NegIdxUTF8T(CuTest *tc UNUSED) {
 
   char b[20] = init0Var;
-  intmax_t r;
+  int64_t r;
   strcpy(b, "£sheepy");
 
   // negative index
diff --git a/src/libsheepyGenericsTest.c b/src/libsheepyGenericsTest.c
@@ -935,7 +935,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self2;
-  intmax_t key6;
+  int64_t key6;
   bool value0;
   setG(self2, key6, value0);
   double value1;
@@ -1533,19 +1533,19 @@ int main(int c, char **a) {
 }
 {
   smallStringt* self4;
-  intmax_t key18;
+  int64_t key18;
   char value0;
   setG(self4, key18, value0);
 }
 {
   char * self5;
-  intmax_t key19;
+  int64_t key19;
   char value0;
   setG(self5, key19, value0);
 }
 {
   char ** self6;
-  intmax_t key20;
+  int64_t key20;
   char value0;
   setG(self6, key20, value0);
   int value1;
@@ -1737,7 +1737,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self2;
-  intmax_t key6;
+  int64_t key6;
   bool value0;
   setNFreeG(self2, key6, value0);
   double value1;
@@ -2263,19 +2263,19 @@ int main(int c, char **a) {
 }
 {
   smallStringt* self4;
-  intmax_t key18;
+  int64_t key18;
   char value0;
   setNFreeG(self4, key18, value0);
 }
 {
   char * self5;
-  intmax_t key19;
+  int64_t key19;
   char value0;
   setNFreeG(self5, key19, value0);
 }
 {
   char ** self6;
-  intmax_t key20;
+  int64_t key20;
   char value0;
   setNFreeG(self6, key20, value0);
   int value1;
@@ -2347,7 +2347,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self2;
-  intmax_t key6;
+  int64_t key6;
   smallArrayt* value0;
   setPG(self2, key6, value0);
   smallJsont* value1;
@@ -2505,7 +2505,7 @@ int main(int c, char **a) {
 }
 {
   char ** self4;
-  intmax_t key18;
+  int64_t key18;
   char value0;
   setPG(self4, key18, value0);
   int value1;
@@ -2577,7 +2577,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self2;
-  intmax_t key6;
+  int64_t key6;
   smallArrayt* value0;
   setNFreePG(self2, key6, value0);
   smallJsont* value1;
@@ -2735,7 +2735,7 @@ int main(int c, char **a) {
 }
 {
   char ** self4;
-  intmax_t key18;
+  int64_t key18;
   char value0;
   setNFreePG(self4, key18, value0);
   int value1;
@@ -2975,7 +2975,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self2;
-  intmax_t key6;
+  int64_t key6;
   baset* returnType0;
   getG(self2, returnType0, key6);
   undefinedt* returnType1;
@@ -3603,13 +3603,13 @@ int main(int c, char **a) {
 }
 {
   smallStringt* self5;
-  intmax_t key19;
+  int64_t key19;
   char returnType0;
   getG(self5, returnType0, key19);
 }
 {
   smallBoolt* self6;
-  intmax_t key20;
+  int64_t key20;
   bool returnType0;
   getG(self6, returnType0, key20);
   bool* returnType1;
@@ -3619,13 +3619,13 @@ int main(int c, char **a) {
 }
 {
   smallContainert* self7;
-  intmax_t key21;
+  int64_t key21;
   void* returnType0;
   getG(self7, returnType0, key21);
 }
 {
   smallDoublet* self8;
-  intmax_t key22;
+  int64_t key22;
   double returnType0;
   getG(self8, returnType0, key22);
   double* returnType1;
@@ -3635,7 +3635,7 @@ int main(int c, char **a) {
 }
 {
   smallIntt* self9;
-  intmax_t key23;
+  int64_t key23;
   int64_t returnType0;
   getG(self9, returnType0, key23);
   int64_t* returnType1;
@@ -3657,25 +3657,25 @@ int main(int c, char **a) {
 }
 {
   char * self10;
-  intmax_t key24;
+  int64_t key24;
   int returnType0;
   getG(self10, returnType0, key24);
 }
 {
   const char * self11;
-  intmax_t key25;
+  int64_t key25;
   int returnType0;
   getG(self11, returnType0, key25);
 }
 {
   char ** self12;
-  intmax_t key26;
+  int64_t key26;
   int returnType0;
   getG(self12, returnType0, key26);
 }
 {
   const char ** self13;
-  intmax_t key27;
+  int64_t key27;
   int returnType0;
   getG(self13, returnType0, key27);
 }
@@ -3863,7 +3863,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self2;
-  intmax_t key6;
+  int64_t key6;
   baset* returnType0;
   getNDupG(self2, returnType0, key6);
   undefinedt* returnType1;
@@ -4359,31 +4359,31 @@ int main(int c, char **a) {
 }
 {
   smallStringt* self5;
-  intmax_t key19;
+  int64_t key19;
   char returnType0;
   getNDupG(self5, returnType0, key19);
 }
 {
   smallBoolt* self6;
-  intmax_t key20;
+  int64_t key20;
   bool returnType0;
   getNDupG(self6, returnType0, key20);
 }
 {
   smallContainert* self7;
-  intmax_t key21;
+  int64_t key21;
   void* returnType0;
   getNDupG(self7, returnType0, key21);
 }
 {
   smallDoublet* self8;
-  intmax_t key22;
+  int64_t key22;
   double returnType0;
   getNDupG(self8, returnType0, key22);
 }
 {
   smallIntt* self9;
-  intmax_t key23;
+  int64_t key23;
   int64_t returnType0;
   getNDupG(self9, returnType0, key23);
   int32_t returnType1;
@@ -4397,25 +4397,25 @@ int main(int c, char **a) {
 }
 {
   char * self10;
-  intmax_t key24;
+  int64_t key24;
   int returnType0;
   getNDupG(self10, returnType0, key24);
 }
 {
   const char * self11;
-  intmax_t key25;
+  int64_t key25;
   int returnType0;
   getNDupG(self11, returnType0, key25);
 }
 {
   char ** self12;
-  intmax_t key26;
+  int64_t key26;
   int returnType0;
   getNDupG(self12, returnType0, key26);
 }
 {
   const char ** self13;
-  intmax_t key27;
+  int64_t key27;
   int returnType0;
   getNDupG(self13, returnType0, key27);
 }
@@ -4426,7 +4426,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self2;
-  intmax_t key0;
+  int64_t key0;
   getNumG(self2, key0);
 }
 {
@@ -5120,32 +5120,32 @@ int main(int c, char **a) {
   delG(self2, start8, end1);
   uint8_t start9;
   delG(self2, start9, end1);
-  intmax_t start16;
+  int64_t start16;
   int end0;
   delG(self2, start16, end0);
 }
 {
   smallArrayt* self3;
-  intmax_t start17;
-  intmax_t end0;
+  int64_t start17;
+  int64_t end0;
   delG(self3, start17, end0);
 }
 {
   smallStringt* self4;
-  intmax_t start18;
-  intmax_t end0;
+  int64_t start18;
+  int64_t end0;
   delG(self4, start18, end0);
 }
 {
   char ** self5;
-  intmax_t start19;
-  intmax_t end0;
+  int64_t start19;
+  int64_t end0;
   delG(self5, start19, end0);
 }
 {
   char *** self6;
-  intmax_t start20;
-  intmax_t end0;
+  int64_t start20;
+  int64_t end0;
   delG(self6, start20, end0);
 }
 {
@@ -5188,22 +5188,22 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self3;
-  intmax_t index0;
+  int64_t index0;
   delElemG(self3, index0);
 }
 {
   smallStringt* self4;
-  intmax_t index0;
+  int64_t index0;
   delElemG(self4, index0);
 }
 {
   char ** self5;
-  intmax_t index0;
+  int64_t index0;
   delElemG(self5, index0);
 }
 {
   char *** self6;
-  intmax_t index0;
+  int64_t index0;
   delElemG(self6, index0);
 }
 {
@@ -8734,7 +8734,7 @@ int main(int c, char **a) {
 {
   char * self1;
   char * obj0;
-  intmax_t index1;
+  int64_t index1;
   eqIG(self1, obj0, index1);
   const char * obj1;
   eqIG(self1, obj1, index1);
@@ -8743,13 +8743,13 @@ int main(int c, char **a) {
   int obj3;
   eqIG(self1, obj3, index1);
   const char * obj5;
-  intmax_t index0;
+  int64_t index0;
   eqIG(self1, obj5, index0);
 }
 {
   const char * self2;
   char * obj0;
-  intmax_t index1;
+  int64_t index1;
   eqIG(self2, obj0, index1);
   const char * obj1;
   eqIG(self2, obj1, index1);
@@ -8758,13 +8758,13 @@ int main(int c, char **a) {
   int obj3;
   eqIG(self2, obj3, index1);
   const char * obj10;
-  intmax_t index0;
+  int64_t index0;
   eqIG(self2, obj10, index0);
 }
 {
   smallJsont * self3;
   char * obj0;
-  intmax_t index1;
+  int64_t index1;
   eqIG(self3, obj0, index1);
   const char * obj1;
   eqIG(self3, obj1, index1);
@@ -8777,13 +8777,13 @@ int main(int c, char **a) {
   smallStringt * obj5;
   eqIG(self3, obj5, index1);
   const char * obj17;
-  intmax_t index0;
+  int64_t index0;
   eqIG(self3, obj17, index0);
 }
 {
   smallStringt * self4;
   char * obj0;
-  intmax_t index1;
+  int64_t index1;
   eqIG(self4, obj0, index1);
   const char * obj1;
   eqIG(self4, obj1, index1);
@@ -8796,7 +8796,7 @@ int main(int c, char **a) {
   smallStringt * obj5;
   eqIG(self4, obj5, index1);
   const char * obj24;
-  intmax_t index0;
+  int64_t index0;
   eqIG(self4, obj24, index0);
 }
 {
@@ -9171,17 +9171,17 @@ int main(int c, char **a) {
 }
 {
   char * self1;
-  intmax_t n0;
+  int64_t n0;
   intToG(self1, n0);
 }
 {
   smallJsont * self2;
-  intmax_t n0;
+  int64_t n0;
   intToG(self2, n0);
 }
 {
   smallStringt * self3;
-  intmax_t n0;
+  int64_t n0;
   intToG(self3, n0);
 }
 {
@@ -9369,80 +9369,80 @@ int main(int c, char **a) {
 }
 {
   char * self1;
-  intmax_t start1;
-  intmax_t end0;
+  int64_t start1;
+  int64_t end0;
   sliceG(self1, start1, end0);
 }
 {
   const char * self2;
-  intmax_t start2;
-  intmax_t end0;
+  int64_t start2;
+  int64_t end0;
   sliceG(self2, start2, end0);
 }
 {
   char ** self3;
-  intmax_t start3;
-  intmax_t end0;
+  int64_t start3;
+  int64_t end0;
   sliceG(self3, start3, end0);
 }
 {
   char *** self4;
-  intmax_t start4;
-  intmax_t end0;
+  int64_t start4;
+  int64_t end0;
   sliceG(self4, start4, end0);
 }
 {
   smallArrayt * self5;
-  intmax_t start5;
-  intmax_t end0;
+  int64_t start5;
+  int64_t end0;
   sliceG(self5, start5, end0);
 }
 {
   smallJsont * self6;
-  intmax_t start6;
-  intmax_t end0;
+  int64_t start6;
+  int64_t end0;
   sliceG(self6, start6, end0);
 }
 {
   smallStringt * self7;
-  intmax_t start7;
-  intmax_t end0;
+  int64_t start7;
+  int64_t end0;
   sliceG(self7, start7, end0);
 }
 {
   char * self1;
-  intmax_t start1;
-  intmax_t end0;
+  int64_t start1;
+  int64_t end0;
   cropG(self1, start1, end0);
 }
 {
   char ** self2;
-  intmax_t start2;
-  intmax_t end0;
+  int64_t start2;
+  int64_t end0;
   cropG(self2, start2, end0);
 }
 {
   char *** self3;
-  intmax_t start3;
-  intmax_t end0;
+  int64_t start3;
+  int64_t end0;
   cropG(self3, start3, end0);
 }
 {
   smallArrayt * self4;
-  intmax_t start4;
-  intmax_t end0;
+  int64_t start4;
+  int64_t end0;
   cropG(self4, start4, end0);
 }
 {
   smallJsont * self5;
-  intmax_t start5;
-  intmax_t end0;
+  int64_t start5;
+  int64_t end0;
   cropG(self5, start5, end0);
 }
 {
   smallStringt * self6;
-  intmax_t start6;
-  intmax_t end0;
+  int64_t start6;
+  int64_t end0;
   cropG(self6, start6, end0);
 }
 {
@@ -9987,7 +9987,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self3;
-  intmax_t index15;
+  int64_t index15;
   baset* returnType0;
   cropElemG(self3, returnType0, index15);
   undefinedt* returnType1;
@@ -10031,67 +10031,67 @@ int main(int c, char **a) {
 }
 {
   smallStringt* self4;
-  intmax_t index15;
+  int64_t index15;
   smallStringt * returnType0;
   cropElemG(self4, returnType0, index15);
 }
 {
   char * self5;
-  intmax_t index15;
+  int64_t index15;
   char * returnType0;
   cropElemG(self5, returnType0, index15);
 }
 {
   char ** self6;
-  intmax_t index15;
+  int64_t index15;
   char ** returnType0;
   cropElemG(self6, returnType0, index15);
 }
 {
   char *** self7;
-  intmax_t index15;
+  int64_t index15;
   char *** returnType0;
   cropElemG(self7, returnType0, index15);
 }
 {
   char * self1;
-  intmax_t start1;
-  intmax_t end0;
+  int64_t start1;
+  int64_t end0;
   copyRngG(self1, start1, end0);
 }
 {
   const char * self2;
-  intmax_t start2;
-  intmax_t end0;
+  int64_t start2;
+  int64_t end0;
   copyRngG(self2, start2, end0);
 }
 {
   char ** self3;
-  intmax_t start3;
-  intmax_t end0;
+  int64_t start3;
+  int64_t end0;
   copyRngG(self3, start3, end0);
 }
 {
   smallArrayt * self4;
-  intmax_t start4;
-  intmax_t end0;
+  int64_t start4;
+  int64_t end0;
   copyRngG(self4, start4, end0);
 }
 {
   smallJsont * self5;
-  intmax_t start5;
-  intmax_t end0;
+  int64_t start5;
+  int64_t end0;
   copyRngG(self5, start5, end0);
 }
 {
   smallStringt * self6;
-  intmax_t start6;
-  intmax_t end0;
+  int64_t start6;
+  int64_t end0;
   copyRngG(self6, start6, end0);
 }
 {
   char * self1;
-  intmax_t index1;
+  int64_t index1;
   char toInsert0;
   insertG(self1, index1, toInsert0);
   int toInsert1;
@@ -10101,7 +10101,7 @@ int main(int c, char **a) {
 }
 {
   const char * self2;
-  intmax_t index2;
+  int64_t index2;
   char toInsert0;
   insertG(self2, index2, toInsert0);
   int toInsert1;
@@ -10111,7 +10111,7 @@ int main(int c, char **a) {
 }
 {
   char ** self3;
-  intmax_t index3;
+  int64_t index3;
   char toInsert0;
   insertG(self3, index3, toInsert0);
   int toInsert1;
@@ -10121,7 +10121,7 @@ int main(int c, char **a) {
 }
 {
   char *** self4;
-  intmax_t index4;
+  int64_t index4;
   char * toInsert0;
   insertG(self4, index4, toInsert0);
   char toInsert1;
@@ -10133,7 +10133,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self5;
-  intmax_t index5;
+  int64_t index5;
   bool toInsert0;
   insertG(self5, index5, toInsert0);
   double toInsert1;
@@ -10181,7 +10181,7 @@ int main(int c, char **a) {
 }
 {
   smallJsont* self6;
-  intmax_t index6;
+  int64_t index6;
   bool toInsert0;
   insertG(self6, index6, toInsert0);
   double toInsert1;
@@ -10229,7 +10229,7 @@ int main(int c, char **a) {
 }
 {
   smallStringt * self7;
-  intmax_t index7;
+  int64_t index7;
   const char * toInsert0;
   insertG(self7, index7, toInsert0);
   char toInsert1;
@@ -10245,7 +10245,7 @@ int main(int c, char **a) {
 }
 {
   char * self1;
-  intmax_t index1;
+  int64_t index1;
   char toInsert0;
   insertNSmashG(self1, index1, toInsert0);
   int toInsert1;
@@ -10255,7 +10255,7 @@ int main(int c, char **a) {
 }
 {
   const char * self2;
-  intmax_t index2;
+  int64_t index2;
   char toInsert0;
   insertNSmashG(self2, index2, toInsert0);
   int toInsert1;
@@ -10265,7 +10265,7 @@ int main(int c, char **a) {
 }
 {
   char ** self3;
-  intmax_t index3;
+  int64_t index3;
   char toInsert0;
   insertNSmashG(self3, index3, toInsert0);
   int toInsert1;
@@ -10275,7 +10275,7 @@ int main(int c, char **a) {
 }
 {
   char *** self4;
-  intmax_t index4;
+  int64_t index4;
   char * toInsert0;
   insertNSmashG(self4, index4, toInsert0);
   char toInsert1;
@@ -10287,7 +10287,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self5;
-  intmax_t index5;
+  int64_t index5;
   bool toInsert0;
   insertNSmashG(self5, index5, toInsert0);
   double toInsert1;
@@ -10331,7 +10331,7 @@ int main(int c, char **a) {
 }
 {
   smallJsont* self6;
-  intmax_t index6;
+  int64_t index6;
   bool toInsert0;
   insertNSmashG(self6, index6, toInsert0);
   double toInsert1;
@@ -10375,7 +10375,7 @@ int main(int c, char **a) {
 }
 {
   smallStringt * self7;
-  intmax_t index7;
+  int64_t index7;
   char toInsert0;
   insertNSmashG(self7, index7, toInsert0);
   int toInsert1;
@@ -10389,25 +10389,25 @@ int main(int c, char **a) {
 }
 {
   char * self1;
-  intmax_t index1;
+  int64_t index1;
   char value0;
   injectG(self1, index1, value0);
 }
 {
   const char * self2;
-  intmax_t index2;
+  int64_t index2;
   char value0;
   injectG(self2, index2, value0);
 }
 {
   char ** self3;
-  intmax_t index3;
+  int64_t index3;
   char value0;
   injectG(self3, index3, value0);
 }
 {
   char *** self4;
-  intmax_t index4;
+  int64_t index4;
   char value0;
   injectG(self4, index4, value0);
   int value1;
@@ -10417,7 +10417,7 @@ int main(int c, char **a) {
 }
 {
   smallArrayt* self5;
-  intmax_t index5;
+  int64_t index5;
   bool value0;
   injectG(self5, index5, value0);
   double value1;
@@ -10465,7 +10465,7 @@ int main(int c, char **a) {
 }
 {
   smallJsont* self6;
-  intmax_t index6;
+  int64_t index6;
   bool value0;
   injectG(self6, index6, value0);
   double value1;
@@ -10513,37 +10513,37 @@ int main(int c, char **a) {
 }
 {
   smallStringt * self7;
-  intmax_t index7;
+  int64_t index7;
   char value0;
   injectG(self7, index7, value0);
 }
 {
   char * self1;
-  intmax_t index1;
+  int64_t index1;
   char value0;
   injectNFreeG(self1, index1, value0);
 }
 {
   const char * self2;
-  intmax_t index2;
+  int64_t index2;
   char value0;
   injectNFreeG(self2, index2, value0);
 }
 {
   char ** self3;
-  intmax_t index3;
+  int64_t index3;
   char value0;
   injectNFreeG(self3, index3, value0);
 }
 {
   char *** self4;
-  intmax_t index4;
+  int64_t index4;
   char * value0;
   injectNFreeG(self4, index4, value0);
 }
 {
   smallArrayt* self5;
-  intmax_t index5;
+  int64_t index5;
   bool value0;
   injectNFreeG(self5, index5, value0);
   double value1;
@@ -10587,7 +10587,7 @@ int main(int c, char **a) {
 }
 {
   smallJsont* self6;
-  intmax_t index6;
+  int64_t index6;
   bool value0;
   injectNFreeG(self6, index6, value0);
   double value1;
@@ -10631,7 +10631,7 @@ int main(int c, char **a) {
 }
 {
   smallStringt * self7;
-  intmax_t index7;
+  int64_t index7;
   char value0;
   injectNFreeG(self7, index7, value0);
 }
diff --git a/src/libsheepyObject.h b/src/libsheepyObject.h
@@ -10366,7 +10366,7 @@ smallStringt *readLineO(FILE *fp);
 /**
  * call intToS for intToG
  */
-char *intToSG(char *retType UNUSED, intmax_t n);
+char *intToSG(char *retType UNUSED, int64_t n);
 
 /**
  * call doubleToS for doubleToG
@@ -10392,19 +10392,19 @@ char **listFromCArrayG(char **retType UNUSED, const char **array, size_t size);
 /**
  * call getS for getG
  */
-char getSG(const char *string, int retType UNUSED, intmax_t index);
+char getSG(const char *string, int retType UNUSED, int64_t index);
 
 /**
  * call listGetS for getG
  */
-char *listGetG(char **list, int retType UNUSED, intmax_t index);
-char *listGetCG(const char **list, int retType UNUSED, intmax_t index);
+char *listGetG(char **list, int retType UNUSED, int64_t index);
+char *listGetCG(const char **list, int retType UNUSED, int64_t index);
 
 /**
  * call iListGetS for getG
  */
-char *iListGetG(char **list, int retType UNUSED, intmax_t index);
-char *iListGetCG(const char **list, int retType UNUSED, intmax_t index);
+char *iListGetG(char **list, int retType UNUSED, int64_t index);
+char *iListGetCG(const char **list, int retType UNUSED, int64_t index);
 
 /**
  * call listPopS for popG
diff --git a/src/libsheepySmall.h b/src/libsheepySmall.h
@@ -253,19 +253,19 @@ sBytest* sArrayTypesTiny(sArrayt* obj);
 // forEach - loop macro on elements
 #define forEachSDict(dict, element) \
   sDictElemt *element = &((dict)->elements); \
-  for (size_t libsheepyInternalIndex = 0; libsheepyInternalIndex < (dict)->count ; libsheepyInternalIndex++, element = &((dict)->elements) + libsheepyInternalIndex)
+  for (size_t libsheepyInternalIndex = 0; libsheepyInternalIndex < (dict)->count ; libsheepyInternalIndex++, element = libsheepyInternalIndex < (dict)->count ? &((dict)->elements) + libsheepyInternalIndex : NULL)
 
 #define enumerateSDict(dict, element, index) \
   sDictElemt *element = &((dict)->elements); \
-  for (size_t index = 0; index < (dict)->count ; index++, element = &((dict)->elements) + index)
+  for (size_t index = 0; index < (dict)->count ; index++, index < (dict)->count ? element = &((dict)->elements) + index : NULL)
 
 #define forEachSArray(array, element) \
   smallt *element = ((smallt **) &((array)->data))[0]; \
-  for (size_t libsheepyInternalIndex = 0; libsheepyInternalIndex < (array)->count ; libsheepyInternalIndex++, element = ((smallt **) &((array)->data))[libsheepyInternalIndex])
+  for (size_t libsheepyInternalIndex = 0; libsheepyInternalIndex < (array)->count ; libsheepyInternalIndex++, element = libsheepyInternalIndex < (array)->count ? ((smallt **) &((array)->data))[libsheepyInternalIndex] : NULL)
 
 #define enumerateSArray(array, element, index) \
   smallt *element = ((smallt **) &((array)->data))[0]; \
-  for (size_t index = 0; index < (array)->count ; index++, element = ((smallt **) &((array)->data))[index])
+  for (size_t index = 0; index < (array)->count ; index++, element = index < (array)->count ? ((smallt **) &((array)->data))[index] : NULL)
 
 // TODO forEachSBytes
 
diff --git a/src/libsheepyTest.c b/src/libsheepyTest.c
@@ -9719,7 +9719,7 @@ END_TEST
 START_TEST(ptr2IdxUTF8T)
 
   char b[20] = init0Var;
-  intmax_t r;
+  int64_t r;
   strcpy(b, "£sheepy");
 
   // pointer to index
@@ -9754,7 +9754,7 @@ END_TEST
 START_TEST(bPtr2IdxUTF8T)
 
   char b[20] = init0Var;
-  intmax_t r;
+  int64_t r;
   strcpy(b, "£sheepy");
 
   // pointer to index
@@ -9790,7 +9790,7 @@ END_TEST
 START_TEST(bLPtr2IdxUTF8T)
 
   char b[20] = init0Var;
-  intmax_t r;
+  int64_t r;
   strcpy(b, "£sheepy");
 
   // pointer to index
@@ -9825,7 +9825,7 @@ END_TEST
 START_TEST(bLPtr2NegIdxUTF8T)
 
   char b[20] = init0Var;
-  intmax_t r;
+  int64_t r;
   strcpy(b, "£sheepy");
 
   // negative index