libsheepy

libsheepy.h (240569B)

---

 // MIT License
 //
 // Copyright (c) 2026 Remy Noulin
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 #ifndef _libsheepyH
 #define _libsheepyH
 // libsheepy
 // can't use #pragma once for some reason (gcc 4.9), compilation fails
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif // _GNU_SOURCE
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <ctype.h>
 #ifdef __GNUC__
 #if !defined(__arm__) && !defined(__aarch64__) && !defined(__riscv)
 #include <immintrin.h>
 #endif // #if !defined(__arm__) && !defined(__aarch64__) && !defined(__riscv)
 #endif // __GNUC__
 #include <time.h>
 #include <setjmp.h>
 #ifdef __TINYC__
 #define and &&
 #define or ||
 #define not !
 #else
 #include <iso646.h> /* and or not defines */
 #endif
 #include <inttypes.h> /* for PRIu64 in stopwatchLog */
 #include <unistd.h> /* for sleep,... */
 #include <string.h> /* for strerror */
 #include <errno.h>
 
 /** \file
  * This file has basic file, random, string, list functions
  *
  * There are 2 types of lists: char** and void**
  *
  * The *S (not i*S) functions duplicate the parameters and results.
  * You must free the result if result is non-NULL and free the parameters
  *
  * The functions starting with i*S are in place functions.
  *
  * In Place functions: iList*S and i*S
  * The iList*S and i*S functions modify the input buffers
  * The input buffers must be allocated with malloc/calloc
  * Returns are pointers to original buffers
  *
  * buffer functions: b*, bL*
  * In these functions, the destination buffer is allocated by the caller
  * In the bL* functions, the destination size is the size of the buffer (strlen+1)
  *
  * Ignore case functions: ic*
  *
  * UTF-8 functions: *UTF8
  * Rune is defined as single UTF-8 code point.
  *
  * libsheepy.h also has:
  * - loops: range*, forEach*, linked list forEach (lForEach)
  * - arrays: slice, vector, staticArray, indexer, ring, dArray, slab
  *
  * It is advised to use the C11 generics from libsheepyObject.h instead of the libsheepy.h functions directly because there are many functions.
  *
  * If you want to add a prefix for libsheepy functions, define a macro
  * like this:
  * #define SH_PREFIX(NAME) MY_PREFIX ## NAME
  *
  * Error from any function returning a status have 0, false or NULL for value
  * (or specifed otherwise in the function description).
  * Errors are reported when the parameters are NULL or invalid, when it happens no parameters and no data stuctures are freed or changed.
  * Errors are detected with if (!func)
  *
  * For more information, the documentation is located at http://spartatek.se/libsheepy/
  */
 
 // version accoring to the version package: Release.Major.minor.patch
 // https://noulin.net/version/file/README.md.html
 #define LIBSHEEPY_VERSION "2.2.20"
 
 #ifndef SH_PREFIX
 #define SH_PREFIX(NAME) NAME
 #endif
 
 // libsheepy API Header file _libsheepyH
 
 /** file internal declarations */
 #define internal static
 
 /** file local declarations (same as internal, shorter word) */
 #define local static
 
 /** declare variable type automaticaly: var a = ARGC; */
 #define var __auto_type
 
 /** type bool true (glibc true is not bool), for use in generics */
 #undef TRUE /* avoid conflict with ncurses */
 extern const bool TRUE;
 /** type bool false (glibc true is not bool), for use in generics */
 #undef FALSE /* avoid conflict with ncurses */
 extern const bool FALSE;
 
 /** convenience defines */
 #define null NULL
 #define yes true
 #define on true
 #define no false
 #define off false
 
 /** bool to const string: printf("%s\n", boolS(boolValue)); */
 #define boolS(x) x ? "TRUE" : "FALSE"
 
 /**
  * success
  */
 #define XSUCCESS exit(EXIT_SUCCESS);
 #define XSuccess XSUCCESS
 
 /**
  * failure
  */
 #define XFAILURE exit(EXIT_FAILURE);
 #define XFailure XFAILURE
 
 /**
  * log string with logP and exit with success
  *
  * This is useful to know at which line a program exits
  */
 #define logXSuccess(string) MACRO(\
     logP("Success: %s", string);\
     XSuccess;\
   )
 
 /**
  * log formated string with logP and exit with success
  *
  * This is useful to know at which line a program exits
  * The format string is printed as given, "Success" is not added unlike
  * logXSuccess
  */
 #define logXSuccessf(format, ...) MACRO(\
     logP(format, __VA_ARGS__);\
     XSuccess;\
   )
 
  /**
 - * log string with logC and exit with failure
   *
   * This is useful to know at which line a program exits
   */
 #define logXFailure(string) MACRO(\
     logC("Failed: %s", string);\
      XFailure;\
    )
 
 /**
  * log formated string with logC and exit with failure
  *
  * This is useful to know at which line a program exits
  * The format string is printed as given, "Failed" is not added unlike
  * logXFailure
  */
 #define logXFailuref(format, ...) MACRO(\
     logC(format, __VA_ARGS__);\
     XFailure;\
   )
 
 /**
  * log string with logI and exit with exitCode
  *
  * This is useful to know at which line a program exits
  */
 #define logExit(exitCode, string) MACRO (\
     logI("Exit: %s", string);\
     exit(exitCode);\
   )
 
 /**
  * exit failure
  *
  * Exits when cond is false
  */
 #define exitFailure(cond) \
   if (!cond) \
     exit(EXIT_FAILURE);
 
 
 /**
  * defines for macro begin and end
  *
  * Macros not returning values are usually written as do while loops:
  * #define macro(value) do{
  *    puts(value);
  *   } while(0)
  *
  * Using the defines below:
  * #define macro(value) procbegin\
  *    puts(value);\
  *   procend
  *
  * procbegin and procend are for macros not returning a value (like procedure in pascal)
  * funcbegin and funcend are for macros returning a value like functions
  *
  * Macro returning a value (GNU extension):
  * #define macro(value) funcbegin\
  *   int returnResult = value + 2;\
  *   returnResult;\
  *   funcend
  */
 #define procbegin do{
 #define procend   }while(0)
 #define funcbegin ({
 #define funcend  })
 
 /**
  * do while(0) alternative macro definition
  *
  * #define macro(param) MACRO( logVarG(param) )
  */
 #define MACRO( STATEMENTS ) do { STATEMENTS } while(0)
 
 /**
  * Macro returning a value (GNU extension):
  * #define macro(value) FUNC(\
  *   int returnResult = value + 2;\
  *   returnResult;\
  *   )
  *
  */
 #define FUNC( STATEMENTS) ({ STATEMENTS })
 
 /** additions to iso646
  * int a is 0;
  * if (a equals 1 or a equals 2) a shl = 2;
  * else a inc;
  * return ptr_to a;
  *
  * int *b is &a;
  * val_of b is a;
  * val_of b dec;
  */
 #define is =
 #define equals ==
 #define nequal !=
 #define shr >>
 #define shl <<
 #define inc ++
 #define dec --
 #define ptr_to &
 #define val_of *
 
 /**
  * stringify Expression - Turn expression into a string literal
  *
  * Example:
  *   #define PRINT_COND_IF_FALSE(cond) \
  *     ((cond) || printf("%s is false!", stringifyExpr(cond)))
  */
 #define stringifyExpr(expr) stringifyExpr1(expr)
 /* Double-indirection required to stringify expansions */
 #define stringifyExpr1(expr) #expr
 
 // libsheepy uses bit 63 in logMask
 // to disable log prints from libsheepy, add:
 // logMask &= (~libsheepyErrorMask);
 // or
 // disableLibsheepyErrorLogs;
 #define libsheepyErrorMask 0x8000000000000000UL
 
 #define disableLibsheepyErrorLogs do{logMask &= (~libsheepyErrorMask);}while(0)
 
 #define shperror(string) procbegin\
     char *errstr = strerror(errno);\
     logE("%s: %s", string, errstr);\
   procend
 
 /**
  * print function name and system error
  *
  * to print error, use either pFuncError and shEPrintfS
  * or shPrintError and shEPrintfS
  */
 #define pFuncError do{ if ((libsheepyErrorMask) & logMask) { shperror(__func__);logEBtrace;} }while(0);
 
 /**
  * print string and system error
  */
 #define pStrError(str) do{ if ((libsheepyErrorMask) & logMask) { shperror(str);logEBtrace;} }while(0);
 
 /**
  * print error with line number, function name and file name to stderr
  *
  * to print error, use either pFuncError and shEPrintfS
  * or shPrintError and shEPrintfS
  */
 #define shPrintError do{ if ((libsheepyErrorMask) & logMask) { logE("Error line "stringifyExpr(__LINE__)", function %s, file "__FILE__"\n", __func__); logEBtrace;} }while(0);
 
 /**
  * print error when function failed. The error code must be -1
  */
 #define pError(func) if (func == -1) shPrintError
 
 /**
  * print error when function failed. The error code must be 0
  */
 #define pError0(func) if (func == 0) shPrintError
 
 /**
  * print error when function failed. The error code must be not 0
  */
 #define pErrorNot0(func) if (func != 0) shPrintError
 
 /**
  * print error when function failed. The error code must be NULL
  */
 #define pErrorNULL(func) if (func == NULL) shPrintError
 
 /**
  * print error when function failed. The error code must be -1
  */
 #define pErrorValue(func, errorValue) if (func == errorValue) shPrintError
 
 /**
  * print error when test is true
  */
 #define pTestError(test) if (test) shPrintError
 
 /**
  * print error and run command when test is true
  */
 #define pTestErrorCmd(test, cmd) if (test) { shPrintError cmd; }
 
 /**
  * print error and run cmd when test is true
  */
 #define pErrorCmd(func, test, cmd) if (func test) { shPrintError cmd; }
 
 /**
  * print error when test is true and return func result in result
  *
  * Example:
  *   pErrorResult(k, randomWordF(), == 0)
  */
 #define pErrorResult(result, func, test) if ((result = func) test) shPrintError
 
 /**
  * print error and run cmd when test is true and return func result in result
  *
  * Example:
  *   pErrorResultCmd(k, randomWordF(), == 0, XFAILURE)
   */
 #define pErrorResultCmd(result, func, test, cmd) if ((result = func) test) { shPrintError cmd; }
 
 /**
  * is Assigment Error
  * catch error when `assigned` is false, 0 or NULL after being assigned with `left`
  *
  * Example:
  * isError(r, malloc(16384)) {
  *   return 0;
  * }
  */
 #define isError(assigned, left) if (!(assigned = left))
 
 /**
  * setjmp buffers for try/throw,throwV macros
  */
 #define maxTryThrowCount 16
 extern jmp_buf tryJumpBuffers[maxTryThrowCount];
 
 /**
  * run setjmp using slot in tryJumpBuffers
  */
 #define setJump(slot) setjmp(tryJumpBuffers[slot])
 
 /**
  * try throw else
  * try(slot) saves the environment in slot
  * throw(slot) executes the else associated with try(slot)
  *
  * there are 16 slots
  *
  * Example:
  * try(0) {
  *   throw(0);
  * }
  * else
  *   puts("except");
  *
  */
 #define try(slot) if (!setjmp(tryJumpBuffers[slot]))
 
 /**
  * throw goes to else associated with try(slot)
  */
 #define throw(slot) longjmp(tryJumpBuffers[slot], 1)
 
 /**
  * tryV stores the value from setjmp in result
  *
  * it is valid to try with throwV and tryV with throw (returns 1)
  *
  * Example:
  */
 #define tryV(result, slot) if (!(result = setjmp(tryJumpBuffers[slot])))
 
 /**
  * throwV returns value and goes to else associated with tryV(slot)
  */
 #define throwV(slot, value) longjmp(tryJumpBuffers[slot], value)
 
 // limited use macro - for test only
 #define goNLabel(go, label) goto go; label:
 
 /**
  * types
  */
 #define i8  int8_t
 #define i16 int16_t
 #define i32 int32_t
 #define i64 int64_t
 #define u8  uint8_t
 #define u16 uint16_t
 #define u32 uint32_t
 #define u64 uint64_t
 #define f32 float
 #define f64 double
 
 /**
  * type cast
  */
 #define I8(value)  (i8)(value)
 #define I16(value) (i16)(value)
 #define I32(value) (i32)(value)
 #define I64(value) (i64)(value)
 #define U8(value)  (u8)(value)
 #define U16(value) (u16)(value)
 #define U32(value) (u32)(value)
 #define U64(value) (u64)(value)
 #define F32(value) (f32)(value)
 #define F64(value) (f64)(value)
 
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #define MIN3(a, b, c) MIN((typeof(a))MIN(a, b), c)
 #define MAX3(a, b, c) MAX((typeof(a))MAX(a, b), c)
 #define ABS(a) (((a) < 0) ? -(a) : (a))
 #define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
 #define COUNT_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0]))
 #define ARRAY_SIZE COUNT_ELEMENTS
 
 /**
  * get a bitfield in an integer (opposite of FIELD_SET)
  */
 #define EXTRACT(x, msb, lsb) ((~(0xFFFFFFFFFFFFFFFEUL << (msb)) & (x)) >> (lsb))
 
 /**
  * compare a to b
  * a and b have to numbers
  *
  * \return
  *  0  when a equals b
  *  -1 when a is less than b
  *  1  when a is more than b
  */
 #define CMP(a, b) ({\
     var UNIQVAR(_a) = a;\
     var UNIQVAR(_b) = b;\
     UNIQVAR(_a) > UNIQVAR(_b) ? 1 : UNIQVAR(_a) < UNIQVAR(_b) ? -1 : 0;\
     })
 
 /**
  * initialize array or struct to zero
  *
  * int a[10]   = init0Var;
  * struct {} s = init0Var;
  */
 #define init0Var {0}
 
 /**
  * memset array or struct to zero
  */
 #define ZEROVAR(name) zeroBuf(&(name), sizeof(name))
 
 /**
  * divide count by divider and add one when remainder is not zero
  * this is used in segmented arrays to count the number of buckets from the element count
  *
  * For example, bucket have 64 elements and there are 66 elements in the array
  * 66/64 = 1
  * and there are 2 buckets, so BUCKETS returns 2
  *
  * could be:
  * (((count) + (1UL<<(divider) -1))/ (divider))
  */
 #define BUCKETS(count, divider) ((count)/(divider) + (((count) % (divider)) ? 1 : 0))
 
 /**
  * swap a and b, a and b should have the same type
  */
 #define swapV(a, b) do{\
     var UNIQVAR(swaptmp) = a;\
     a = b;\
     b = UNIQVAR(swaptmp);\
   } while(0)
 
 /** max a,b and store result in result, a and b are evaluated only once */
 #define setMax(result, a, b) do{\
     var UNIQVAR(_a) = a;\
     var UNIQVAR(_b) = b;\
     result = MAX(UNIQVAR(_a), UNIQVAR(_b));\
   } while(0)
 
 /** min a,b and store result in result, a and b are evaluated only once */
 #define setMin(result, a, b) do{\
     var UNIQVAR(_a) = a;\
     var UNIQVAR(_b) = b;\
     result = MIN(UNIQVAR(_a), UNIQVAR(_b));\
   } while(0)
 
 /** max a,b and return result, a and b are evaluated only once */
 #define maxV(a, b) ({\
     var UNIQVAR(_a) = a;\
     var UNIQVAR(_b) = b;\
     MAX(UNIQVAR(_a), UNIQVAR(_b));\
   })
 
 /** min a,b and return result, a and b are evaluated only once */
 #define minV(a, b) ({\
     var UNIQVAR(_a) = a;\
     var UNIQVAR(_b) = b;\
     MIN(UNIQVAR(_a), UNIQVAR(_b));\
   })
 
 /** absV return absolute value for a, a is evaluated only once*/
 #define absV(a) ({var UNIQVAR(_a) = a; ((UNIQVAR(_a)) < 0) ? -(UNIQVAR(_a)) : (UNIQVAR(_a));})
 
 /**
  * FIELD_SIZEOF - get the size of a struct's field
  * @t: the target struct
  * @f: the target struct's field
  * Return: the size of @f in the struct definition without having a
  * declared instance of @t.
  */
 #define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
 
 /** true when value is odd integer */
 #define isIntOdd(value) (value&1)
 
 /** true when value is even integer */
 #define isIntEven(value) (!(value&1))
 
 /**
  * typ definition as alternative to typedef
  */
 #define typ typedef
 
 /**
  * ret definition as alternative to return
  */
 #define ret return
 
 /**
  * elif definition as alternative to else if
  */
 #define elif else if
 
 /**
  * unless executes the statement unless the condition is true (that is, if the condition is false).
  *
  * Example:
  * unless(isPath("/void")) {
  *   put("the '/void' directory doesn't exist.");
  * }
  */
 #define unless(cond) if(not(cond))
 
 /**
  * until repeats the statement until the condition is true (or while the condition is false)
  *
  * Example:
  * i16 i = 0;
  * do {
  *   i++;
  *   logVarG(i);
  * } until(i == 3);
  */
 #define until(cond) while(not(cond))
 
 
 /**
  * define variable and cast pointer
  */
 #define cast(type, casted, toCast) type casted = (type) (toCast);
 
 /**
  * free pointer and set it to NULL
  */
 #define freen(ptr) do {\
     free(ptr);\
     (ptr) = NULL;\
   } while(0)
 
 /**
  * Evaluate and assign
  * Evaluate, assign result from func and return result using the comma operator
  *
  * Example:
  *  save pointer returned by a function in a function parameter:
  *  void *p;
  *  func2( EVA(p,func1()) );
  *  free(p);
  *
  *  Using libsheepy functions:
  *  char *s;
  *  puts( EVA(s, normalizePath("/wef/./../")) );
  *  free(s);
  */
 #define EVA(var, func) (var = func, var)
 
 /**
  * initialize the loop breaker
  * declares loop breaker variables
  *
  * Example:
  *
  * loopBreakerInit;
  * forever {
  *   loopBreaker(20);
  * }
  * if (didBreak) logE("infinite loop detected");
  * loopBreakerReset;
  * forever {
  *   loopBreaker(100);
  * }
  * if (didBreak) logE("infinite loop detected");
  */
 #define loopBreakerInit\
   uint32_t libsheepyLoopCounter = 0;\
   bool didBreak = false;
 
 /**
  * reset the loop breaker variables
  */
 #define loopBreakerReset\
   libsheepyLoopCounter = 0;\
   didBreak = false;
 
 /**
  * break the loop when the counter exceed breakCount
  */
 #define loopBreaker(breakCount)\
   libsheepyLoopCounter++;\
   if(libsheepyLoopCounter>breakCount){didBreak=true;break;}
 
 /** generate a string FILE:LINE number
  *
  * Example:
  *   puts(FILE_LINE);
  */
 #define FILE_LINE __FILE__":"stringifyExpr(__LINE__)
 #define PFILE_LINE puts(FILE_LINE)
 
 /**
  * print file, function name and line
  *
  * Example:
  *   AT;
  *   libsheepy.c, main:9149
  */
 #define AT pLog(LOG_DEBUG, __FILE__", %s:"stringifyExpr(__LINE__)"\n",__func__);
 
 /**
  * print a todo message in log
  */
 #define TODO(message) logD(BLD MGT BGBLK"TODO"RST BLD MGT": "message RST)
 
 // macros for token paste for automatically creating unique variable names
 // used in forEachCharP
 #define TOKENPASTE2(a, b) a ## b
 #define TOKENPASTE(a, b) TOKENPASTE2(a, b)
 #define UNIQVAR(name) TOKENPASTE(name, __LINE__)
 
 
 // free val when it is out of scope
 void cleanUpCharFree(char **val);
 
 /**
  * declare pointer name with type char* and free name when it is out of scope
  */
 #define cleanCharP(name) char *name CLEANUP(cleanUpCharFree)
 
 // free val when it is out of scope
 void cleanUpListFree(char*** val);
 
 /**
  * declare pointer name with type char* and free name when it is out of scope
  */
 #define cleanListP(name) char **name CLEANUP(cleanUpListFree)
 
 // free val when it is out of scope
 void cleanUpVoidFree(void **val);
 
 /**
  * declare pointer name with type void* and free name when it is out of scope
  */
 #define cleanVoidP(name) void *name CLEANUP(cleanUpVoidFree)
 
 // free val when it is out of scope
 void cleanUpFileFree(FILE **val);
 
 /**
  * declare pointer name with type FILE and free (close) name when it is out of scope
  */
 #define cleanFileP(name) FILE *name CLEANUP(cleanUpFileFree)
 
 // close val when it is out of scope
 void cleanUpFd(int *val);
 
 /**
  * declare a file descriptor name and close name when it is out of scope
  */
 #define cleanFd(name) int name CLEANUP(cleanUpFd)
 #define cleanFdInit(name) int name CLEANUP(cleanUpFd) = -1
 
 /**
  * log variable and its value
  *
  * Example:
  *   logVar(k, PRIu64)
  *   k=14
  */
 #define logVar(var, format) logD("%s=%" format, stringifyExpr(var), var);
 #define logMVar(mask, var, format) logMD(mask, "%s=%" format, stringifyExpr(var), var);
 
 /** log bool variable */
 #define logBoolVar(var) logVar(var, "b");
 #define logMBoolVar(mask, var) logMVar(mask, var, "b");
 
 /**
  * log pointer
  */
 #define logPtr(pointer) logD("%s=%p", stringifyExpr(pointer), pointer);
 #define logMPtr(mask, pointer) logMD(mask, "%s=%p", stringifyExpr(pointer), pointer);
 
 // colors and effects
 /** reset for color function */
 #define RST "\x1B[0m"
 /** bold for color function */
 #define BLD "\x1B[1m"
 /** faint */
 #define FNT "\x1B[2m"
 /** italic */
 #define ITL "\x1B[3m"
 /** underline for color function */
 #define UDL "\x1B[4m"
 /** blink */
 #define BLI "\x1B[5m"
 /** inverse for color function */
 #define INV "\x1B[7m"
 /** conceal/hidden for color function */
 #define COC "\x1B[8m"
 /** crossed for color function */
 #define CRD "\x1B[9m"
 
 // foreground
 /** black for color function */
 #define BLK "\x1B[30m"
 /** red for color function */
 #define RED "\x1B[31m"
 /** green for color function */
 #define GRN "\x1B[32m"
 /** yellow for color function */
 #define YLW "\x1B[33m"
 /** blue for color function */
 #define BLU "\x1B[34m"
 /** magenta for color function */
 #define MGT "\x1B[35m"
 /** cyan for color function */
 #define CYN "\x1B[36m"
 /** white for color function */
 #define WHT "\x1B[37m"
 
 // background
 /** bg black for color function */
 #define BGBLK "\x1B[40m"
 /** bg red for color function */
 #define BGRED "\x1B[41m"
 /** bg green for color function */
 #define BGGRN "\x1B[42m"
 /** bg yellow for color function */
 #define BGYLW "\x1B[43m"
 /** bg blue for color function */
 #define BGBLU "\x1B[44m"
 /** bg magenta for color function */
 #define BGMGT "\x1B[45m"
 /** bg cyan for color function */
 #define BGCYN "\x1B[46m"
 /** bg white for color function */
 #define BGWHT "\x1B[47m"
 
 // bug in cg_c.py
 #define sheepyRGBFP len = fprintf(stream, "%*s", (int)(info->left ? -info->width : info->width), b)
 #define sheepyBOOLFP len = fprintf(stream, "%*s", (int)(info->left ? -info->width : info->width), boolS(value))
 
 /**
  * time a function in nanoseconds
  *
  * Example:
  * timeNs(func(anInt));
  */
 #define timeNs(func) do{\
   u64 UNIQVAR(endTime);\
   u64 UNIQVAR(startTime) = getMonotonicTime();\
   func;\
   UNIQVAR(endTime) = getMonotonicTime();\
   printf(BLD GRN "time" RST ": %" PRIu64 "ns " BLD UDL YLW "%s" RST "\n", UNIQVAR(endTime)-UNIQVAR(startTime), stringifyExpr(func));\
 }while(0)
 
 #define TIMEUNITUS "us"
 #define TIMEUNITMS "ms"
 #define TIMEUNITSC "s"
 
 /**
  * time a function with div
  *
  * Example:
  * timeDivs(func(anInt), 1E3);
  */
 #define timeDivs(func, div, timeunit) do{\
   u64 UNIQVAR(endTime);\
   u64 UNIQVAR(startTime) = getMonotonicTime();\
   func;\
   UNIQVAR(endTime) = getMonotonicTime();\
   printf(BLD GRN "time:" RST " %f"timeunit" " BLD UDL YLW "%s" RST "\n", (f32)(UNIQVAR(endTime)-UNIQVAR(startTime))/div, stringifyExpr(func));\
 }while(0)
 
 /**
  * time a function in microseconds
  *
  * Example:
  * timeUs(func(anInt));
  */
 #define timeUs(func) timeDivs(func,1E3, TIMEUNITUS)
 
 /**
  * time a function in miliseconds
  *
  * Example:
  * timeMs(func(anInt));
  */
 #define timeMs(func) timeDivs(func,1E6, TIMEUNITMS)
 
 /**
  * time a function in seconds
  *
  * Example:
  * timeSec(func(anInt));
  */
 #define timeSec(func) timeDivs(func,1E9, TIMEUNITSC)
 
 // nanosecond stopwatch, the returned value is in ns. op parameter: 0 to start, 1 to get the stopwatch value
 uint64_t shStopwatch(uint8_t op);
 
 #define stopwatchStart shStopwatch(0)
 
 /**
  * print stopwatch value in ns since last start
  */
 #define stopwatchLog printf(BLD GRN "time" RST ": %" PRIu64 "ns\n", shStopwatch(1))
 
 /**
  * print stopwatch value in provided unit since last start
  */
 #define stopwatchLogDivs(div, timeunit) printf(BLD GRN "time" RST ": %f"timeunit"\n", ((float)shStopwatch(1))/div)
 
 /**
  * print stopwatch value in microseconds since last start
  */
 #define stopwatchLogUs stopwatchLogDivs(1E3, TIMEUNITUS)
 
 /**
  * print stopwatch value in milliseconds since last start
  */
 #define stopwatchLogMs stopwatchLogDivs(1E6, TIMEUNITMS)
 
 /**
  * print stopwatch value in seconds since last start
  */
 #define stopwatchLogSec stopwatchLogDivs(1E9, TIMEUNITSC)
 
 /**
  * LOG LEVELS
  * Note: When adding log levels or modes, the log_tags array in libsheepy.c
  *       must be updated.
  */
 #define LOG_EMERGENCY 0
 #define LOG_ALERT     1
 #define LOG_CRITICAL  2
 #define LOG_ERROR     3
 #ifdef LOG_WARNING
 #undef LOG_WARNING // conflict with syslog.h
 #endif
 #define LOG_WARNING   4
 #define LOG_NOTICE    5
 #define LOG_PASS      6
 #ifdef LOG_INFO
 #undef LOG_INFO // conflict with syslog.h
 #endif
 #define LOG_INFO      7
 #define LOG_DEBUG     8
 #define LOG_INVALID   9
 #define LOG_MAX_LEVEL LOG_INVALID
 
 /** getMaxLogLevel and setMaxLogLevel value disabling all logs */
 #define LOG_DISABLE -1
 
 /**
  * LOG MODES
  * when a new mode is added, add symbols in log_tags in libsheepy.c
  */
 
 /**
  * log symbol, program name, filename, function, line, date
  */
 #define LOG_VERBOSE       0
 
 /**
  * log symbol
  */
 #define LOG_CONCISE       1
 
 /**
  * log symbol and date
  */
 #define LOG_DATE          2 // default
 
 /**
  * log symbol and function
  */
 #define LOG_FUNC          3
 
 /**
  * log symbol and program name
  */
 #define LOG_PROG          4
 
 /**
  * log symbol, program name and date
  */
 #define LOG_PROGNDATE     5
 
 /**
  * log message only
  */
 #define LOG_VOID          6
 
 /**
  * UTF8 symbols and concise
  */
 #define LOG_UTF8          7
 
 /**
  * log symbol, program name and function
  */
 #define LOG_PROGNFUNC     8
 
 /**
  * invalid
  */
 #define LOG_INVALID_MODE  9
 
 // add a log file, maximum 15 files
 FILE *SH_PREFIX(setLogFile)(char *filename);
 #define openLogFile setLogFile
 
 #ifdef __GNUC__
 /** force function callers to check return value
  * The warning is disabled with -Wno-unused-result (default in sheepy config ~/.sheepy/config.yml
  * Enable this warning to make all errors caught as early as possible and handled correctly.
  */
 #define MUST_CHECK    __attribute__ ((warn_unused_result))
 #else
 #define MUST_CHECK
 #endif
 
 // current log symbols
 int getLogSymbols(void) MUST_CHECK;
 
 // set log symbols, LOG_VERBOSE for words, LOG_UTF8 for emojis, LOG_VOID for no symbols, LOG_INVALID_MODE (reset log symbols) for default log mode symbols, anything else (LOG_CONCISE,...) for symbols (!*+->~)
 void setLogSymbols(int mode);
 
 // current max log level
 int getMaxLogLevel(void) MUST_CHECK;
 
 // set max log level, logs above logMaxLevel are skipped
 void setMaxLogLevel(int logLevel);
 
 // close logfiles opened with setLogFile
 void closeLogFiles(void);
 
 // get current log mode (LOG_VERBOSE, LOG_CONCISE, ...)
 int getLogMode(void) MUST_CHECK;
 
 // set log mode LOG_VERBOSE, LOG_CONCISE, ...
 void setLogMode(int mode);
 
 // get current log long/short path value, default is TRUE (short paths)
 bool getLogShortPath(void) MUST_CHECK;
 
 // set log long/short file path value for VERBOSE mode
 void setLogShortPath(bool shortPath);
 
 // get stdout state, when TRUE (default) all logs are printed to stdout
 bool getLogStdout(void) MUST_CHECK;
 
 // enable/disable printing logs to stdout
 void setLogStdout(bool state);
 
 // log to a file named progName.log
 bool openProgLogFile(void) MUST_CHECK;
 
 // keep ansi colors in logs
 void keepAnsiColorsInLog(bool state);
 
 /**
  * print logging levels
  *
  * to disable logging, empty pLog define:
  * #undef pLog
  * #define pLog
  *
  * \param
  *   level LOG_CRITICAL, LOG_ERROR, LOG_WARNING or LOG_INFO, anything else has log level LOG_INVALID
  * \param
  *   message like printf
  */
 #define pLog(level, ...) _pLog(level, __FILE__, __func__, __LINE__, __VA_ARGS__);
 
 void _pLog(int, const char *, const char *, int, const char *, ...);
 
 #define logY(...) pLog(LOG_EMERGENCY, __VA_ARGS__)
 #define logA(...) pLog(LOG_ALERT, __VA_ARGS__)
 #define logC(...) pLog(LOG_CRITICAL, __VA_ARGS__)
 #define logE(...) pLog(LOG_ERROR, __VA_ARGS__)
 #define logW(...) pLog(LOG_WARNING, __VA_ARGS__)
 #define logN(...) pLog(LOG_NOTICE, __VA_ARGS__)
 #define logP(...) pLog(LOG_PASS, __VA_ARGS__)
 #define logI(...) pLog(LOG_INFO, __VA_ARGS__)
 #define logD(...) pLog(LOG_DEBUG, __VA_ARGS__)
 
 /**
  * log string and free
  * Example:
  * logSY("The list: %s", catS("1", "2"));
  */
 #define logSY(format, string) do {\
     char *libsheepyInternalString = string;\
     logY(format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log string and free
  * Example:
  * logSA("The list: %s", catS("1", "2"));
  */
 #define logSA(format, string) do {\
     char *libsheepyInternalString = string;\
     logA(format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log string and free
  * Example:
  * logSC("The list: %s", catS("1", "2"));
  */
 #define logSC(format, string) do {\
     char *libsheepyInternalString = string;\
     logC(format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log string and free
  * Example:
  * logSE("The list: %s", catS("1", "2"));
  */
 #define logSE(format, string) do {\
     char *libsheepyInternalString = string;\
     logE(format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log string and free
  * Example:
  * logSW("The list: %s", catS("1", "2"));
  */
 #define logSW(format, string) do {\
     char *libsheepyInternalString = string;\
     logW(format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log string and free
  * Example:
  * logSN("The list: %s", catS("1", "2"));
  */
 #define logSN(format, string) do {\
     char *libsheepyInternalString = string;\
     logN(format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log string and free
  * Example:
  * logSP("The list: %s", catS("1", "2"));
  */
 #define logSP(format, string) do {\
     char *libsheepyInternalString = string;\
     logP(format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log string and free
  * Example:
  * logSI("The list: %s", catS("1", "2"));
  */
 #define logSI(format, string) do {\
     char *libsheepyInternalString = string;\
     logI(format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log string and free
  * Example:
  * logSD("The list: %s", catS("1", "2"));
  */
 #define  logSD(format, string) do {\
     char *libsheepyInternalString = string;\
     logD(format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 
 /** variable to control which group logs to show, all logs are enabled by default (0xFFFFFFFFFFFFFFFF) */
 extern uint64_t logMask;
 
 /**
  * print mask logging levels
  *
  * print logs with a mask in logMask
  * normally, mask is 1 bit wide.
  *
  * pLogMask allows enabling/disabling groups of logs
  *
  * to disable logging, empty pLogMask define:
  * #undef pLogMask
  * #define pLogMask
  *
  * Example:
  *
  * #define group1 0x03
  * #define group11 0x01
  * #define group12 0x02
  * #define group2 0x04
  *
  * logMask = group11;
  * logMI(group1, "is shown when logMask has bit 0 or 1 set");
  * logMI(group11, "is shown when logMask has bit 0 set");
  * logMI(group12, "is shown when logMask has bit 1 set");
  * logMI(group2, "is shown when logMask has bit 2 set");
  *
  * \param
  *   level LOG_CRITICAL, LOG_ERROR, LOG_WARNING or LOG_INFO, anything else has log level LOG_INVALID
  * \param
  *   message like printf
  */
 #define pLogMask(mask, level, ...) if ((mask) & logMask) pLog(level, __VA_ARGS__)
 
 #define logMY(mask, ...) pLogMask(mask, LOG_EMERGENCY, __VA_ARGS__)
 #define logMA(mask, ...) pLogMask(mask, LOG_ALERT, __VA_ARGS__)
 #define logMC(mask, ...) pLogMask(mask, LOG_CRITICAL, __VA_ARGS__)
 #define logME(mask, ...) pLogMask(mask, LOG_ERROR, __VA_ARGS__)
 #define logMW(mask, ...) pLogMask(mask, LOG_WARNING, __VA_ARGS__)
 #define logMN(mask, ...) pLogMask(mask, LOG_NOTICE, __VA_ARGS__)
 #define logMP(mask, ...) pLogMask(mask, LOG_PASS, __VA_ARGS__)
 #define logMI(mask, ...) pLogMask(mask, LOG_INFO, __VA_ARGS__)
 #define logMD(mask, ...) pLogMask(mask, LOG_DEBUG, __VA_ARGS__)
 
 // show log messages in mask
 #define showLogsInMask(mask) logMask |= mask
 
 // hide log messages in mask
 #define hideLogsInMask(mask) logMask &= ~(mask)
 
 /**
  * log and mask string and then free
  * Example:
  * logSMY("The list: %s", catS("1", "2"));
  */
 #define logSMY(mask, format, string) do {\
     char *libsheepyInternalString = string;\
     logMY(mask, format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log and mask string and then free
  * Example:
  * logSMA("The list: %s", catS("1", "2"));
  */
 #define logSMA(mask, format, string) do {\
     char *libsheepyInternalString = string;\
     logMA(mask, format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log and mask string and then free
  * Example:
  * logSMI("The list: %s", catS("1", "2"));
  */
 #define logSMC(mask, format, string) do {\
     char *libsheepyInternalString = string;\
     logMC(mask, format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log and mask string and then free
  * Example:
  * logSME("The list: %s", catS("1", "2"));
  */
 #define logSME(mask, format, string) do {\
     char *libsheepyInternalString = string;\
     logME(mask, format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log and mask string and then free
  * Example:
  * logSMW("The list: %s", catS("1", "2"));
  */
 #define logSMW(mask, format, string) do {\
     char *libsheepyInternalString = string;\
     logMW(mask, format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log and mask string and then free
  * Example:
  * logSMN("The list: %s", catS("1", "2"));
  */
 #define logSMN(mask, format, string) do {\
     char *libsheepyInternalString = string;\
     logMN(mask, format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log and mask string and then free
  * Example:
  * logSMP("The list: %s", catS("1", "2"));
  */
 #define logSMP(mask, format, string) do {\
     char *libsheepyInternalString = string;\
     logMP(mask, format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log and mask string and then free
  * Example:
  * logSMI("The list: %s", catS("1", "2"));
  */
 #define logSMI(mask, format, string) do {\
     char *libsheepyInternalString = string;\
     logMI(mask, format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 /**
  * log and mask string and then free
  * Example:
  * logSMD("The list: %s", catS("1", "2"));
  */
 #define logSMD(mask, format, string) do {\
     char *libsheepyInternalString = string;\
     logMD(mask, format, libsheepyInternalString);\
     free(libsheepyInternalString);\
   } while(0)
 
 // QSORT
 
 /*
  * Copyright (c) 2013, 2017 Alexey Tourbin
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
 
 /*
  * https://github.com/svpv/qsort.git
  * commit 21f056356e901467b7362240dac70edeedfa2b89
  */
 
 /*
  * This is a traditional Quicksort implementation which mostly follows
  * [Sedgewick 1978].  Sorting is performed entirely on array indices,
  * while actual access to the array elements is abstracted out with the
  * user-defined `LESS` and `SWAP` primitives.
  *
  * Synopsis:
  *	QSORT(N, LESS, SWAP);
  * where
  *	N - the number of elements in A[];
  *	LESS(i, j) - compares A[i] to A[j];
  *	SWAP(i, j) - exchanges A[i] with A[j].
  *
  * Examples:
  * - int array:
  * int A[] = {3,2,1};
  * int tmp;
  *
  * #define LESS(i, j) A[i] < A[j]
  * #define SWAP(i, j) tmp = A[i], A[i] = A[j], A[j] = tmp
  *
  * QSORT(3, LESS, SWAP);
  * #undef LESS
  * #undef SWAP
  *
  *
  * - string array/list:
  * char **strs = listCreateS("fsd", "sdf", "ffds","asd");
  * char *tmp;
  *
  * #define LESS(i,j) (strcmp(strs[i], strs[j]) < 0)
  * #define SWAP(i,j) tmp = strs[i], strs[i] = strs[j], strs[j] = tmp
  *
  * QSORT(listLengthS(strs), LESS, SWAP);
  * #undef LESS
  * #undef SWAP
  *
  */
 
 /* Sort 3 elements. */
 #define Q_SORT3(q_a1, q_a2, q_a3, Q_LESS, Q_SWAP) do {\
     if (Q_LESS(q_a2, q_a1)) {\
       if (Q_LESS(q_a3, q_a2))\
         Q_SWAP(q_a1, q_a3);\
       else {\
         Q_SWAP(q_a1, q_a2);\
         if (Q_LESS(q_a3, q_a2))\
           Q_SWAP(q_a2, q_a3);\
       }\
     }\
     else if (Q_LESS(q_a3, q_a2)) {\
       Q_SWAP(q_a2, q_a3);\
       if (Q_LESS(q_a2, q_a1))\
         Q_SWAP(q_a1, q_a2);	\
     }\
   } while (0)
 
 /* Partition [q_l,q_r] around a pivot.  After partitioning,
  * [q_l,q_j] are the elements that are less than or equal to the pivot,
  * while [q_i,q_r] are the elements greater than or equal to the pivot. */
 #define Q_PARTITION(q_l, q_r, q_i, q_j, Q_UINT, Q_LESS, Q_SWAP)	do {\
     /* The middle element, not to be confused with the median. */\
     Q_UINT UNIQVAR(q_m) = q_l + ((q_r - q_l) >> 1);\
     /* Reorder the second, the middle, and the last items.\
      * As [Edelkamp Weiss 2016] explain, using the second element\
      * instead of the first one helps avoid bad behaviour for\
      * decreasingly sorted arrays.  This method is used in recent\
      * versions of gcc's std::sort, see gcc bug 58437#c13, although\
      * the details are somewhat different (cf. #c14). */\
     Q_SORT3(q_l + 1, UNIQVAR(q_m), q_r, Q_LESS, Q_SWAP);\
     /* Place the median at the beginning. */\
     Q_SWAP(q_l, UNIQVAR(q_m));\
     /* Partition [q_l+2, q_r-1] around the median which is in q_l.\
      * q_i and q_j are initially off by one, they get decremented\
      * in the do-while loops. */\
     q_i = q_l + 1; q_j = q_r;\
     while (1) {\
       do q_i++; while (Q_LESS(q_i, q_l));\
       do q_j--; while (Q_LESS(q_l, q_j));\
       if (q_i >= q_j) break; /* Sedgewick says "until j < i" */\
       Q_SWAP(q_i, q_j);\
     }\
     /* Compensate for the i==j case. */\
     q_i = q_j + 1;\
     /* Put the median to its final place. */\
     Q_SWAP(q_l, q_j);\
     /* The median is not part of the left subfile. */\
     q_j--;\
   } while (0)
 
 /* Insertion sort is applied to small subfiles - this is contrary to
  * Sedgewick's suggestion to run a separate insertion sort pass after
  * the partitioning is done.  The reason I don't like a separate pass
  * is that it triggers extra comparisons, because it can't see that the
  * medians are already in their final positions and need not be rechecked.
  * Since I do not assume that comparisons are cheap, I also do not try
  * to eliminate the (q_j > q_l) boundary check. */
 #define Q_INSERTION_SORT(q_l, q_r, Q_UINT, Q_LESS, Q_SWAP) do {\
     Q_UINT UNIQVAR(q_i), UNIQVAR(q_j);\
     /* For each item starting with the second... */\
     for (UNIQVAR(q_i) = q_l + 1; UNIQVAR(q_i) <= q_r; UNIQVAR(q_i)++)\
     /* move it down the array so that the first part is sorted. */\
     for (UNIQVAR(q_j) = UNIQVAR(q_i); UNIQVAR(q_j) > q_l && (Q_LESS(UNIQVAR(q_j), UNIQVAR(q_j) - 1)); UNIQVAR(q_j)--)\
       Q_SWAP(UNIQVAR(q_j), UNIQVAR(q_j) - 1);\
   } while (0)
 
 /* When the size of [q_l,q_r], i.e. q_r-q_l+1, is greater than or equal to
  * Q_THRESH, the algorithm performs recursive partitioning.  When the size
  * drops below Q_THRESH, the algorithm switches to insertion sort.
  * The minimum valid value is probably 5 (with 5 items, the second and
  * the middle items, the middle itself being rounded down, are distinct). */
 #define Q_THRESH 16
 
 /* The main loop. */
 #define Q_LOOP(Q_UINT, Q_N, Q_LESS, Q_SWAP) do {\
     Q_UINT UNIQVAR(q_l) = 0;\
     Q_UINT UNIQVAR(q_r) = (Q_N) - 1;\
     Q_UINT UNIQVAR(q_sp) = 0; /* the number of frames pushed to the stack */\
     struct { Q_UINT q_l, q_r; }\
     /* On 32-bit platforms, to sort a "char[3GB+]" array,\
      * it may take full 32 stack frames.  On 64-bit CPUs,\
      * though, the address space is limited to 48 bits.\
      * The usage is further reduced if Q_N has a 32-bit type. */\
     UNIQVAR(q_st)[sizeof(Q_UINT) > 4 && sizeof(Q_N) > 4 ? 48 : 32];\
     while (1) {\
       if (UNIQVAR(q_r) - UNIQVAR(q_l) + 1 >= Q_THRESH) {\
         Q_UINT UNIQVAR(q_i), UNIQVAR(q_j);\
         Q_PARTITION(UNIQVAR(q_l), UNIQVAR(q_r), UNIQVAR(q_i), UNIQVAR(q_j), Q_UINT, Q_LESS, Q_SWAP);\
         /* Now have two subfiles: [q_l,q_j] and [q_i,q_r].\
          * Dealing with them depends on which one is bigger. */\
         if (UNIQVAR(q_j) - UNIQVAR(q_l) >= UNIQVAR(q_r) - UNIQVAR(q_i))\
           Q_SUBFILES(UNIQVAR(q_l), UNIQVAR(q_j), UNIQVAR(q_i), UNIQVAR(q_r));\
         else\
           Q_SUBFILES(UNIQVAR(q_i), UNIQVAR(q_r), UNIQVAR(q_l), UNIQVAR(q_j));\
       }\
       else {\
         Q_INSERTION_SORT(UNIQVAR(q_l), UNIQVAR(q_r), Q_UINT, Q_LESS, Q_SWAP);\
         /* Pop subfiles from the stack, until it gets empty. */\
         if (UNIQVAR(q_sp) == 0) break;\
         UNIQVAR(q_sp)--;\
         UNIQVAR(q_l) = UNIQVAR(q_st)[UNIQVAR(q_sp)].q_l;\
         UNIQVAR(q_r) = UNIQVAR(q_st)[UNIQVAR(q_sp)].q_r;\
       }\
     }\
   } while (0)
 
 /* The missing part: dealing with subfiles.
  * Assumes that the first subfile is not smaller than the second. */
 #define Q_SUBFILES(q_l1, q_r1, q_l2, q_r2) do {\
     /* If the second subfile is only a single element, it needs\
      * no further processing.  The first subfile will be processed\
      * on the next iteration (both subfiles cannot be only a single\
      * element, due to Q_THRESH). */\
     if (q_l2 == q_r2) {\
       UNIQVAR(q_l) = q_l1;\
       UNIQVAR(q_r) = q_r1;\
     }\
     else {\
       /* Otherwise, both subfiles need processing.\
        * Push the larger subfile onto the stack. */\
       UNIQVAR(q_st)[UNIQVAR(q_sp)].q_l = q_l1;\
       UNIQVAR(q_st)[UNIQVAR(q_sp)].q_r = q_r1;\
       UNIQVAR(q_sp)++;\
       /* Process the smaller subfile on the next iteration. */\
       UNIQVAR(q_l) = q_l2;\
       UNIQVAR(q_r) = q_r2;\
     }\
   } while (0)
 
 /* And now, ladies and gentlemen, may I proudly present to you... */
 #define QSORT(Q_N, Q_LESS, Q_SWAP) do {\
     if ((Q_N) > 1) {\
       if (sizeof(Q_N) == sizeof(unsigned long)) {\
         Q_LOOP(unsigned long, Q_N, Q_LESS, Q_SWAP);}\
       else if (sizeof(Q_N) <= sizeof(unsigned)) {\
         Q_LOOP(unsigned, Q_N, Q_LESS, Q_SWAP);}\
     }\
   } while (0)
 
 // QSORT END
 
 // BINARY SEARCH
 
 /**
  * binary search macro
  *
  * Synopsis:
  *	BSEARCH(RESULT_INDEX, SEARCH_ELEMENT, N, LESS, EQUAL);
  * where
  *  RESULT_INDEX             - variable holding the result index, signed int type (example: ssize_t),
  *                             declare RESULT_INDEX before calling BSEARCH;
  *  SEARCH_ELEMENT           - element to search in the array;
  *	N                        - the number of elements in A[];
  *	LESS(i, SEARCH_ELEMENT)  - compares A[i] to SEARCH_ELEMENT, 1 when less;
  *	EQUAL(i, SEARCH_ELEMENT) - compares A[i] to SEARCH_ELEMENT, 1 when equal;
  *
  * Example:
  * int A[] = {1,5,7,9,10,65};
  * ssize_t bsr;
  *
  * #define LESS(i, se) A[i] < se
  * #define EQUAL(i, se) A[i] == se
  * BSEARCH(bsr, 9, COUNT_ELEMENTS(A), LESS, EQUAL);
  * #undef LESS
  * #undef EQUAL
  *
  * logVar(bsr,"zd");
  *
  */
 #define BSEARCH(RESULT_INDEX, SEARCH_ELEMENT, B_N, B_LESS, B_EQUAL) do {\
   ssize_t UNIQVAR(b_first) = 0, UNIQVAR(b_middle), UNIQVAR(b_last);\
   UNIQVAR(b_last) = B_N-1;\
   while (UNIQVAR(b_first) <= UNIQVAR(b_last)) {\
     UNIQVAR(b_middle) = (UNIQVAR(b_first)+UNIQVAR(b_last))/2;\
     if (B_LESS(UNIQVAR(b_middle), SEARCH_ELEMENT)) UNIQVAR(b_first) = UNIQVAR(b_middle) + 1;\
     else if (B_EQUAL(UNIQVAR(b_middle), SEARCH_ELEMENT)) {\
       RESULT_INDEX = UNIQVAR(b_middle);\
       goto UNIQVAR(end);\
     }\
     else UNIQVAR(b_last) = UNIQVAR(b_middle) -1;\
   }\
   /* element not found */\
   RESULT_INDEX = -1;\
   UNIQVAR(end):;\
   } while(0)
 
 // BINARY SEARCH END
 
 // makeRoom is dynamic memory allocation algorithm
 // given a length, an allocated size and the additionnal length,
 // makeRoom returns the new allocated size for realloc
 // when the new allocated size equals alloc value, there is no need to realloc the memory, enough space is already available
 #define libsheepyPrealloc (1024*1024)
 #define makeRoom(length, alloc, addlength) funcbegin\
     typeof(alloc) r;\
     typeof(alloc) newlen = (length) + (addlength);\
     if (newlen < (alloc)) {\
       r = alloc;\
     } \
     else {\
       if (newlen < libsheepyPrealloc) {\
         r = newlen * 2;\
       }\
       else {\
         r = newlen + libsheepyPrealloc;\
       }\
     }\
     r;\
   funcend
 
 // initialize libsheepy (optional, for debug)
 typedef void(*initLibsheepyObjectP)(void);
 void initLibsheepyF(const char *progPath, initLibsheepyObjectP initF);
 #define initLibsheepy(progPath) initLibsheepyF(progPath, NULL)
 
 // free internal buffers at exit
 void finalizeLibsheepyCharAtExit(void);
 
 // get current stack limit - returns 0 when error
 int64_t getStackLimit(void) MUST_CHECK;
 
 // set stack limit (-1 for unlimited) - returns 0 when error
 int setStackLimit(int64_t stackSize) MUST_CHECK;
 
 // enable core dump
 int enableCoreDump(void) MUST_CHECK;
 
 // get program name
 const char *getProgName(void) MUST_CHECK;
 
 // set program name
 bool setProgName(const char *name) MUST_CHECK;
 
 // set default program name
 void setDefaultProgName(void);
 
 // free ProgName
 void freeProgName(void);
 
 // get program path as given in the shell
 const char *getProgPath(void) MUST_CHECK;
 
 // get real program path, allocates path string internally
 const char *getRealProgPath(void) MUST_CHECK;
 
 // free real program path
 void freeRealProgPath(void);
 
 // run system command and free command buffer
 #define systemNFree(command) systemNFreeF(command, __LINE__, __func__, __FILE__)
 int systemNFreeF(char *command, int line, const char *thisFunc, const char *thisFileName) MUST_CHECK;
 
 // get modification time for path
 time_t getModificationTime(const char *path) MUST_CHECK;
 
 // set modification time for path
 int setModificationTime(const char *path, time_t mtime) MUST_CHECK;
 
 // true when path is readable
 bool isReadable(const char *path) MUST_CHECK;
 
 // true when path is writable
 bool isWritable(const char *path) MUST_CHECK;
 
 // true when path is executable
 bool isExecutable(const char *path) MUST_CHECK;
 
 // compare modification times for path1 and path2
 bool equalModificationTimes(const char *path1, const char *path2) MUST_CHECK;
 
 // get current unix time
 time_t getCurrentUnixTime(void) MUST_CHECK;
 
 // convert date string to unix time
 time_t strToUnixTime(const char *date, const char *format) MUST_CHECK;
 
 // convert unix time to string
 char *timeToS(const time_t t) MUST_CHECK;
 char *bTimeToS(char *dst, const time_t t) MUST_CHECK;
 char *bLTimeToS(char *dst, size_t dstSize, const time_t t) MUST_CHECK;
 
 // convert unix time to Y-m-d H:M:S string
 char *timeToYMDS(const time_t t) MUST_CHECK;
 char *bTimeToYMDS(char *dst, const time_t t) MUST_CHECK;
 char *bLTimeToYMDS(char *dst, size_t dstSize, const time_t t) MUST_CHECK;
 
 // get current date in ctime format
 char *getCurrentDate(void) MUST_CHECK;
 char *bGetCurrentDate(char *dst) MUST_CHECK;
 char *bLGetCurrentDate(char *dst, size_t dstSize) MUST_CHECK;
 
 // get current date in Y-m-d H:M:S format
 char *getCurrentDateYMD(void) MUST_CHECK;
 char *bGetCurrentDateYMD(char *dst) MUST_CHECK;
 char *bLGetCurrentDateYMD(char *dst, size_t dstSize) MUST_CHECK;
 
 // dirname
 char *shDirname(const char *path) MUST_CHECK;
 char *bDirname(char *path) MUST_CHECK;
 char *bLDirname(char *path, size_t pathSize) MUST_CHECK;
 
 // expand home ~/
 char *expandHome(const char *path) MUST_CHECK;
 char *iExpandHome(char **path) MUST_CHECK;
 char *bExpandHome(char *path) MUST_CHECK;
 char *bLExpandHome(char *path, size_t pathSize) MUST_CHECK;
 
 // normalize path
 char *normalizePath(const char *path) MUST_CHECK;
 char *iNormalizePath(char **path) MUST_CHECK;
 char *bNormalizePath(char *path) MUST_CHECK;
 char *bLNormalizePath(char *path, size_t pathSize) MUST_CHECK;
 
 // relative path
 char *relPath(const char *path, const char *start) MUST_CHECK;
 char *iRelPath(char **path, const char *start) MUST_CHECK;
 char *bRelPath(char *dest, const char *path, const char *start) MUST_CHECK;
 char *bLRelPath(char *dest, size_t destSize, char *path, const char *start) MUST_CHECK;
 
 // get home path
 char *getHomePath(void) MUST_CHECK;
 char *bGetHomePath(char *path) MUST_CHECK;
 char *bLGetHomePath(char *path, size_t pathSize) MUST_CHECK;
 const char *getCHomePath(void) MUST_CHECK;
 
 // get current working directory
 char *getCwd(void) MUST_CHECK;
 char *bLGetCwd(char *path, size_t pathSize) MUST_CHECK;
 
 // change directory
 int chDir(const char *path) MUST_CHECK;
 
 // true when path is directory
 bool isDir(const char *path) MUST_CHECK;
 
 // read link to a new string
 char *shReadlink(const char *path) MUST_CHECK;
 
 // read link chain to the end to a new string
 char *endlink(const char *path) MUST_CHECK;
 
 // true when path is symbolic link
 bool isLink(const char *path) MUST_CHECK;
 
 // file and dir exists
 bool fileExists(const char *filePath) MUST_CHECK;
 #define isPath fileExists
 
 // chmod "721"
 bool fileChmod(const char *filePath, mode_t mode) MUST_CHECK;
 
 // file size
 ssize_t fileSize(const char *filePath) MUST_CHECK;
 ssize_t fileSizeFP(FILE *fp) MUST_CHECK;
 
 // read file
 void *readFileToS(const char *filePath) MUST_CHECK;
 void *bReadFileToS(const char *filePath, void *dst) MUST_CHECK;
 void *bLReadFileToS(const char *filePath, void *dst, size_t dstSize) MUST_CHECK;
 ssize_t readFile(const char *filePath, void **buffer) MUST_CHECK;
 ssize_t bReadFile(const char *filePath, void *buffer) MUST_CHECK;
 ssize_t bLReadFile(const char *filePath, void *buffer, size_t dstSize) MUST_CHECK;
 void *readStreamToS(FILE *fp) MUST_CHECK;
 void *bReadStreamToS(FILE *fp, void *dst) MUST_CHECK;
 void *bLReadStreamToS(FILE *fp, void *dst, size_t dstSize) MUST_CHECK;
 // defines without '...ToS'
 #define readFileS     readFileToS
 #define bReadFileS    bReadFileToS
 #define bLReadFileS   bLReadFileToS
 #define readStreamS   readStreamToS
 #define bReadStreamS  bReadStreamToS
 #define bLReadStreamS bLReadStreamToS
 
 // write file
 int writeFileS(const char *filePath, const char *string) MUST_CHECK;
 int writeFile(const char *filePath, void *buffer, size_t len) MUST_CHECK;
 int writeStreamS(FILE *fp, const char *string) MUST_CHECK;
 int writeLStream(FILE *fp, void *buffer, size_t len) MUST_CHECK;
 
 // append string to file
 bool appendFileS(const char *filePath, const char *string) MUST_CHECK;
 bool appendFile(const char *filePath, void *buffer, size_t len) MUST_CHECK;
 
 // walkDir lists files only
 char **walkDir(const char* dirPath) MUST_CHECK;
 
 // walkDirDir lists directories
 char **walkDirDir(const char* dirPath) MUST_CHECK;
 
 // readDir lists files in a directory
 char **readDir(const char *dirPath) MUST_CHECK;
 
 // readDirDir lists directories in a directory
 char **readDirDir(const char *dirPath) MUST_CHECK;
 
 // walkDirAll lists files and directories
 char **walkDirAll(const char* dirPath) MUST_CHECK;
 
 // readDirAll lists files and directories in a directory
 char **readDirAll(const char *dirPath) MUST_CHECK;
 
 // get umask
 mode_t getUmask(void) MUST_CHECK;
 
 // get current permissions for creating directories
 mode_t getCurrentPermissions(void) MUST_CHECK;
 
 // recursive mkdir
 int mkdirParents(const char* path) MUST_CHECK;
 
 // delete files and directories
 int rmAll(const char* path) MUST_CHECK;
 
 // copy files recursively
 int copy(const char* src, const char* dst) MUST_CHECK;
 
 // rename file
 int shRename(const char* src, const char* dst) MUST_CHECK;
 
 // move files recursively
 int shMove(const char* src, const char* dst) MUST_CHECK;
 
 // use /dev/urandom as a source of random numbers
 void setSoftwareRandom(void);
 
 // use cpu random instruction as a source of random numbers
 void setHardwareRandom(void);
 
 // open /dev/urandom in libsheepy
 int randomUrandomOpen(void) MUST_CHECK;
 
 // close /dev/urandom in libsheepy
 void randomUrandomClose(void);
 
 // return random 64 bit unsigned integer
 uint64_t randomWord(void) MUST_CHECK;
 
 // return random 64 bit unsigned integer from the cpu
 uint64_t randomWordFromHW(void) MUST_CHECK;
 
 // return a random value between 0 and range 0<=value<range
 uint64_t randomChoice(uint64_t range) MUST_CHECK;
 
 // generate random string
 char *randomS(uint64_t length) MUST_CHECK;
 char *bRandomS(char *dst, size_t length) MUST_CHECK;
 
 // generate random alpha numerical string
 char *randomAlphaNumS(uint64_t length) MUST_CHECK;
 char *bRandomAlphaNumS(char *dst, size_t dstSize) MUST_CHECK;
 
 // read user input (one line) as a string
 char *readS(void) MUST_CHECK;
 char *bLReadS(char *dst, size_t dstSize) MUST_CHECK;
 
 // read hidden password as a string - like getpass
 char *readPasswordS(void) MUST_CHECK;
 
 // write zero to all bytes in string with memset, for clearing password buffers
 bool zeroS(char *string) MUST_CHECK;
 
 // write zero to all bytes in buffer with memset
 bool zeroBuf(void *buf, size_t len) MUST_CHECK;
 
 // allocate and copy buffer
 void *memdup(const void *buf, size_t size) MUST_CHECK;
 
 // wait until press the enter key
 void readEnter(void);
 
 // TODO writeLine - copy cg_c code
 
 // readLine
 char *readLine(FILE *fp) MUST_CHECK;
 
 // convert char to string by declaring string dst with c in it
 #define charToS(dst, c) \
   ;char dst[2] = {c, 0}
 
 // free many char*
 void freeManySF(char *paramType, ...);
 #define freeManyS(...) freeManySF("", __VA_ARGS__, NULL)
 
 // duplicate string
 char *dupS(const char *string) MUST_CHECK;
 
 // print like printf, the formating can be NULL
 void shPrintfS(const char *fmt, ...);
 
 // stderr printf, the formating can be NULL
 void shEPrintfS(const char *fmt, ...);
 
 // print and free s
 void logNFree(char *s);
 
 // print buf as hexadecimal
 void loghex(const void *buf, size_t len);
 
 // create a string with bytes in buf converted to hex strings: 0xff,
 char *toHexS(const void *buf, size_t len) MUST_CHECK;
 
 // create a string with bytes in buf converted to hex strings separated by separator: 0xffSEP
 char *toHexSepS(const void *buf, size_t len, const char *separator) MUST_CHECK;
 
 // create a string with bytes in buf converted to hex strings separated by separator and with head string in front of earch byte: HEADffSEP
 char *toHexHeadSepS(const void *buf, size_t len, const char *head, const char *separator) MUST_CHECK;
 
 // print new line
 #define put puts("");
 
 // copy src to dst
 char *strCpy(char *restrict dst, const char *restrict src) MUST_CHECK;
 // copy string to buffer given string length: strNCpy(buffer, string, lenS(string));
 // null safe version of strncpy
 char *strNCpy(char *restrict dst, const char *restrict src, size_t srcSize) MUST_CHECK;
 char *strLCpy(char *restrict dst, size_t dstSize, const char *restrict src) MUST_CHECK;
 
 // concatenate src to dst
 char *strCat(char *restrict dst, const char *restrict src) MUST_CHECK;
 char *strNCat(char *restrict dst, const char *restrict src, size_t srcLen) MUST_CHECK;
 char *strLCat(char *restrict dst, size_t dstSize, const char *restrict src) MUST_CHECK;
 char *strLNCat(char *restrict dst, size_t dstSize, const char *restrict src, size_t srcLen) MUST_CHECK;
 
 // cat: f("qwd ", str," werr ", str2)
 char *catSF(const char *paramType, ...) MUST_CHECK;
 #define catS(...) catSF("", __VA_ARGS__, NULL)
 
 // cat and copy result to dst buffer
 char *iCatSF(char *dst, const char *paramType, ...) MUST_CHECK;
 #define iCatS(dst, ...) iCatSF(dst, "", __VA_ARGS__, NULL)
 #define bCatS iCatS
 char *bLCatSF(char *dst, size_t dstSize, const char *paramType, ...) MUST_CHECK;
 #define bLCatS(dst, dstSize, ...) bLCatSF(dst, dstSize, "", __VA_ARGS__, NULL)
 
 // allocate and format string using asprintf
 char *formatS(const char *fmt, ...) MUST_CHECK;
 
 /** format and store in string: bFormatS(string, "Value %d", i); */
 char *bFormatS(char *string, const char *fmt, ...) MUST_CHECK;
 
 /** format and store in string: bLFormatS(string, sizeof(string), "Value %d", i); */
 char *bLFormatS(char *string, size_t stringSize, const char *fmt, ...) MUST_CHECK;
 
 // append strings
 char *appendS(const char *string1, const char *string2) MUST_CHECK;
 char *appendCharS(const char *string1, char c) MUST_CHECK;
 char *appendSChar(char c, const char *string2) MUST_CHECK;
 char *iAppendS(char **string1, const char *string2) MUST_CHECK;
 char *iAppendCharS(char **string1, char c) MUST_CHECK;
 char *iAppendNFreeS(char **string1, char *string2) MUST_CHECK;
 char *iAppendManySF(char **string, const char *paramType, ...) MUST_CHECK;
 #define iAppendManyS(s, s1, ...) iAppendManySF(s, s1, __VA_ARGS__, NULL)
 char *bAppendManySF(char *string, const char *paramType, ...) MUST_CHECK;
 #define bAppendManyS(s, s1, ...) bAppendManySF(s, s1, __VA_ARGS__, NULL)
 char *bLAppendManySF(char *string, size_t stringSize, const char *paramType, ...) MUST_CHECK;
 #define bLAppendManyS(s, sSize, s1, ...) bLAppendManySF(s, sSize, s1, __VA_ARGS__, NULL)
 
 // prepend string
 char *prependS(const char *string1, const char *string2) MUST_CHECK;
 char *prependCharS(const char *string1, char c) MUST_CHECK;
 char *prependSChar(char c, const char *string2) MUST_CHECK;
 char *iPrependS(char **string1, const char *string2) MUST_CHECK;
 char *iPrependCharS(char **string1, char c) MUST_CHECK;
 char *iPrependNFreeS(char **string1, char *string2) MUST_CHECK;
 char *bPrependS(char *string1, const char *string2) MUST_CHECK;
 char *bLPrependS(char *string1, size_t string1Size, const char *string2) MUST_CHECK;
 
 // string replace
 char *replaceS(const char *s, const char *olds, const char *news, size_t max) MUST_CHECK;
 char *replaceCharSS(const char *s, char olds, const char *news, size_t max) MUST_CHECK;
 char *replaceSCharS(const char *s, const char *olds, char news, size_t max) MUST_CHECK;
 char *replaceCharCharS(const char *s, char olds, char news, size_t max) MUST_CHECK;
 #define replaceS_max(s,olds,news) replaceS(s,olds,news, 0)
 #define replaceSMax replaceS_max
 // TODO add support for all types, create a generic, create ignore case version
 size_t replaceSLen(const char *s, const char *olds, const char *news, size_t max) MUST_CHECK;
 #define replaceSMaxLen(s,olds,news) replaceSLen(s,olds,news, 0)
 char* iReplaceS(char **s, const char *olds, const char *news, size_t max) MUST_CHECK;
 char* iReplaceCharSS(char **s, char olds, const char *news, size_t max) MUST_CHECK;
 char* iReplaceSCharS(char **s, const char *olds, char news, size_t max) MUST_CHECK;
 char* iReplaceCharCharS(char **s, char olds, char news, size_t max) MUST_CHECK;
 #define iReplaceS_max(s,olds,news) iReplaceS(s,olds,news, 0)
 #define iReplaceSMax iReplaceS_max
 char* bReplaceS(char *s, const char *olds, const char *news, size_t max) MUST_CHECK;
 #define bReplaceS_max(s,olds,news) bReplaceS(s,olds,news, 0)
 #define bReplaceSMax bReplaceS_max
 char* bLReplaceS(char *s, size_t sSize, const char *olds, const char *news, size_t max) MUST_CHECK;
 #define bLReplaceS_max(s,sSize,olds,news) bLReplaceS(s,sSize,olds,news, 0)
 #define bLReplaceSMax bLReplaceS_max
 
 // string replace many olds with news (s, olds1, news1, olds2, news2,...)
 char *replaceManySF(const char *paramType, ...) MUST_CHECK;
 #define replaceManyS(s, ...) replaceManySF(s, __VA_ARGS__, NULL)
 char *iReplaceManySF(char **string, char *paramType, ...) MUST_CHECK;
 #define iReplaceManyS(s, olds, ...) iReplaceManySF(s, olds, __VA_ARGS__, NULL)
 char *bReplaceManySF(char *s, char *paramType, ...) MUST_CHECK;
 #define bReplaceManyS(s, olds, ...) bReplaceManySF(s, olds, __VA_ARGS__, NULL)
 char *bLReplaceManySF(char *s, size_t sSize, char *paramType, ...) MUST_CHECK;
 #define bLReplaceManyS(s, sSize, olds, ...) bLReplaceManySF(s, sSize, olds, __VA_ARGS__, NULL)
 
 // ignore case string replace
 char *icReplaceS(const char *s, const char *olds, const char *news, size_t max) MUST_CHECK;
 char *icReplaceCharSS(const char *s, char olds, const char *news, size_t max) MUST_CHECK;
 char *icReplaceSCharS(const char *s, const char *olds, char news, size_t max) MUST_CHECK;
 char *icReplaceCharCharS(const char *s, char olds, char news, size_t max) MUST_CHECK;
 #define icReplaceS_max(s,olds,news) icReplaceS(s,olds,news, 0)
 #define icReplaceSMax icReplaceS_max
 char* iicReplaceS(char **s, const char *olds, const char *news, size_t max) MUST_CHECK;
 char* iicReplaceCharSS(char **s, char olds, const char *news, size_t max) MUST_CHECK;
 char* iicReplaceSCharS(char **s, const char *olds, char news, size_t max) MUST_CHECK;
 char* iicReplaceCharCharS(char **s, char olds, char news, size_t max) MUST_CHECK;
 #define iicReplaceS_max(s,olds,news) iicReplaceS(s,olds,news, 0)
 #define iicReplaceSMax iicReplaceS_max
 char* bicReplaceS(char *s, const char *olds, const char *news, size_t max) MUST_CHECK;
 #define bicReplaceS_max(s,olds,news) bicReplaceS(s,olds,news, 0)
 #define bicReplaceSMax bicReplaceS_max
 char* bLicReplaceS(char *s, size_t sSize, const char *olds, const char *news, size_t max) MUST_CHECK;
 #define bLicReplaceS_max(s,sSize,olds,news) bLicReplaceS(s,sSize,olds,news, 0)
 #define bLicReplaceSMax bLicReplaceS_max
 
 // string replace many olds with news (s, olds1, news1, olds2, news2,...)
 char *icReplaceManySF(const char *paramType, ...) MUST_CHECK;
 #define icReplaceManyS(s, ...) icReplaceManySF(s, __VA_ARGS__, NULL)
 char *iicReplaceManySF(char **string, char *paramType, ...) MUST_CHECK;
 #define iicReplaceManyS(s, olds, ...) iicReplaceManySF(s, olds, __VA_ARGS__, NULL)
 char *bicReplaceManySF(char *s, char *paramType, ...) MUST_CHECK;
 #define bicReplaceManyS(s, olds, ...) bicReplaceManySF(s, olds, __VA_ARGS__, NULL)
 char *bLicReplaceManySF(char *s, size_t sSize, char *paramType, ...) MUST_CHECK;
 #define bLicReplaceManyS(s, sSize, olds, ...) bLicReplaceManySF(s, sSize, olds, __VA_ARGS__, NULL)
 
 // string equal (compare content)
 bool eqS(const char *string1, const char *string2) MUST_CHECK;
 #define strEq eqS
 bool eqCharS(char c, const char *string2) MUST_CHECK;
 bool eqSChar(const char *string1, char c) MUST_CHECK;
 
 // string equal at index (compare content)
 bool eqIS(const char *string1, const char *string2, int64_t index) MUST_CHECK;
 #define strIEq eqIS
 bool eqICharS(const char *string1, char c, int64_t index) MUST_CHECK;
 
 // look for string2 at string1 start
 bool startsWithS(const char *string1, const char *string2) MUST_CHECK;
 bool startsWithCharS(const char *string1, char c) MUST_CHECK;
 
 // look for string2 at string1 end
 bool endsWithS(const char *string1, const char *string2) MUST_CHECK;
 bool endsWithCharS(const char *string1, char c) MUST_CHECK;
 
 // count number of (non-overlapping) occurrences of a substring
 ssize_t countS(const char *s, const char *needle) MUST_CHECK;
 ssize_t countCharS(const char *s, char c) MUST_CHECK;
 
 // ignore case string equal (compare content)
 bool icEqS(const char *string1, const char *string2) MUST_CHECK;
 bool icEqCharS(char c, const char *string2) MUST_CHECK;
 bool icEqSChar(const char *string1, char c) MUST_CHECK;
 
 // ignore case string equal at index (compare content)
 bool icEqIS(const char *string1, const char *string2, int64_t index) MUST_CHECK;
 bool icEqICharS(const char *string1, char c, int64_t index) MUST_CHECK;
 
 // ignore case and look for string2 at string1 start
 bool icStartsWithS(const char *string1, const char *string2) MUST_CHECK;
 bool icStartsWithCharS(const char *string1, char c) MUST_CHECK;
 
 // ignore case look for string2 at string1 end
 bool icEndsWithS(const char *string1, const char *string2) MUST_CHECK;
 bool icEndsWithCharS(const char *string1, char c) MUST_CHECK;
 
 // ignore case and count number of (non-overlapping) occurrences of a substring
 ssize_t icCountS(const char *s, const char *needle) MUST_CHECK;
 ssize_t icCountCharS(const char *s, char c) MUST_CHECK;
 
 // has terminal control char (for example colors)
 bool hasCtrlChar(const char *string) MUST_CHECK;
 
 // remove terminal control char from string
 char *stripCtrlS(const char *string) MUST_CHECK;
 char *iStripCtrlS(char **string) MUST_CHECK;
 char *bStripCtrlS(char *string) MUST_CHECK;
 
 // remove ansi colors from string
 char *stripColorsS(const char *string) MUST_CHECK;
 char *iStripColorsS(char **string) MUST_CHECK;
 char *bStripColorsS(char *string) MUST_CHECK;
 
 // escape quotes and backslashes in string
 char* quoteS(const char *s, char delim) MUST_CHECK;
 char* bQuoteS(char *dest, const char *s, char delim) MUST_CHECK;
 char* bLQuoteS(char *dest, size_t destSize, const char *s, char delim) MUST_CHECK;
 size_t quoteLenS(const char *s, char delim) MUST_CHECK;
 // escape string to become a parsable json string
 char* escapeS(const char *s, char delim /*string delimiter ' or "*/) MUST_CHECK;
 char* bEscapeS(char *dest, const char *s, char delim /*string delimiter ' or "*/) MUST_CHECK;
 char* bLEscapeS(char *dest, size_t destSize, const char *s, char delim /*string delimiter ' or "*/) MUST_CHECK;
 size_t escapeLenS(const char *s, char delim /*string delimiter ' or "*/) MUST_CHECK;
 // convert nibble to hexadecimal digit character
 char nibbleToHex(u8 n) MUST_CHECK;
 // escape string to become compilable in a C source code
 char* cEscapeS(const char *S) MUST_CHECK;
 char* bCEscapeS(char *dest, const char *S) MUST_CHECK;
 char* bLCEscapeS(char *dest, size_t destSize, const char *S) MUST_CHECK;
 size_t cEscapeLenS(const char *s) MUST_CHECK;
 
 // true when string is a number (integer or float)
 bool isNumber(const char *string) MUST_CHECK;
 
 // true when string is an integer
 bool isInt(const char *string) MUST_CHECK;
 
 // parseInt
 int64_t parseInt(const char *string) MUST_CHECK;
 int64_t parseIntChar(char c) MUST_CHECK;
 int64_t parseI64(const char *string) MUST_CHECK;
 int64_t parseI64Char(char c) MUST_CHECK;
 
 // parseDouble
 double parseDouble(const char *string) MUST_CHECK;
 double parseDoubleChar(char c) MUST_CHECK;
 
 // parse hexadecimal string: 0xff
 uint64_t parseHex(const char *string) MUST_CHECK;
 // TODO parseHexChar
 
 // convert int to string
 char *intToS(int64_t n) MUST_CHECK;
 char *bIntToS(char *s, int64_t n) MUST_CHECK;
 
 // convert double to string
 char *doubleToS(double n) MUST_CHECK;
 char *bDoubleToS(char *s, double n) MUST_CHECK;
 
 // length
 size_t lenS(const char *string) MUST_CHECK;
 // string buffer size: strlen+1
 size_t sizeS(const char *string) MUST_CHECK;
 
 /**
  * upper case and store the result in c and return the result
  */
 #define toUpper(c) ((c) = toupper(c), c)
 
 // duplicate and upper case
 char *upperS(const char *string) MUST_CHECK;
 char *iUpperS(char **string) MUST_CHECK;
 char *bUpperS(char *string) MUST_CHECK;
 
 /**
  * lower case and store the result in c and return the result
  */
 #define toLower(c) ((c) = tolower(c), c)
 
 // duplicate and lower case
 char *lowerS(const char *string) MUST_CHECK;
 char *iLowerS(char **string) MUST_CHECK;
 char *bLowerS(char *string) MUST_CHECK;
 
 // duplicate and trim
 char *trimS(const char *string) MUST_CHECK;
 char *iTrimS(char **string) MUST_CHECK;
 char *bTrimS(char *string) MUST_CHECK;
 char *lTrimS(const char *string) MUST_CHECK;
 char *iLTrimS(char **string) MUST_CHECK;
 char *bLTrimS(char *string) MUST_CHECK;
 char *rTrimS(const char *string) MUST_CHECK;
 char *iRTrimS(char **string) MUST_CHECK;
 char *bRTrimS(char *string) MUST_CHECK;
 
 // remove successive repetitions of char c
 char *uniqS(const char *string, char c) MUST_CHECK;
 char *iUniqS(char **string, char c) MUST_CHECK;
 char *bUniqS(char *string, char c) MUST_CHECK;
 #define uniqSlash(s) uniqS(s, '/')
 #define iUniqSlash(s) iUniqS(&(s), '/')
 #define bUniqSlash(s) bUniqS(s, '/')
 
 // ignore case and remove successive repetitions of char c
 char *icUniqS(const char *string, char c) MUST_CHECK;
 char *iicUniqS(char **string, char c) MUST_CHECK;
 char *bicUniqS(char *string, char c) MUST_CHECK;
 
 // repeat string count times
 char *repeatS(const char *string, size_t count) MUST_CHECK;
 char *iRepeatS(char **string, size_t count) MUST_CHECK;
 char *bRepeatS(char *dest, const char *string, size_t count) MUST_CHECK;
 char *bLRepeatS(char *dest, size_t destSize, const char *string, size_t count) MUST_CHECK;
 char *repeatCharS(char c, size_t count) MUST_CHECK;
 char *bRepeatCharS(char *dest, char c, size_t count) MUST_CHECK;
 char *bLRepeatCharS(char *dest, size_t destSize, char c, size_t count) MUST_CHECK;
 
 // length of string repeated count times
 ssize_t repeatLenS(const char *string, size_t count) MUST_CHECK;
 
 // ellipsisStart string
 char *ellipsisStartS(const char *string, size_t targetLength, const char *ellipsisString) MUST_CHECK;
 char *iEllipsisStartS(char **string, size_t targetLength, const char *ellipsisString) MUST_CHECK;
 char *bEllipsisStartS(char *dest, const char *string, size_t targetLength, const char *ellipsisString) MUST_CHECK;
 char *bLEllipsisStartS(char *dest, size_t destSize, const char *string, size_t targetLength, const char *ellipsisString) MUST_CHECK;
 char *ellipsisStartCharS(const char *string, size_t targetLength, char ellipsisChar) MUST_CHECK;
 char *iEllipsisStartCharS(char **string, size_t targetLength, char ellipsisChar) MUST_CHECK;
 char *bEllipsisStartCharS(char *dest, const char *string, size_t targetLength, char ellipsisChar) MUST_CHECK;
 char *bLEllipsisStartCharS(char *dest, size_t destSize, const char *string, size_t targetLength, char ellipsisChar) MUST_CHECK;
 
 // length of string after ellipsis
 ssize_t ellipsisLenS(const char *string, size_t targetLength, const char *ellipsisString) MUST_CHECK;
 
 // ellipsisEnd string
 char *ellipsisEndS(const char *string, size_t targetLength, const char *ellipsisString) MUST_CHECK;
 char *iEllipsisEndS(char **string, size_t targetLength, const char *ellipsisString) MUST_CHECK;
 char *bEllipsisEndS(char *dest, const char *string, size_t targetLength, const char *ellipsisString) MUST_CHECK;
 char *bLEllipsisEndS(char *dest, size_t destSize, const char *string, size_t targetLength, const char *ellipsisString) MUST_CHECK;
 char *ellipsisEndCharS(const char *string, size_t targetLength, char ellipsisChar) MUST_CHECK;
 char *iEllipsisEndCharS(char **string, size_t targetLength, char ellipsisChar) MUST_CHECK;
 char *bEllipsisEndCharS(char *dest, const char *string, size_t targetLength, char ellipsisChar) MUST_CHECK;
 char *bLEllipsisEndCharS(char *dest, size_t destSize, const char *string, size_t targetLength, char ellipsisChar) MUST_CHECK;
 
 // padStart string
 char *padStartS(const char *string, size_t targetLength, const char *padString) MUST_CHECK;
 char *iPadStartS(char **string, size_t targetLength, const char *padString) MUST_CHECK;
 char *bPadStartS(char *dest, const char *string, size_t targetLength, const char *padString) MUST_CHECK;
 char *bLPadStartS(char *dest, size_t destSize, const char *string, size_t targetLength, const char *padString) MUST_CHECK;
 char *padStartCharS(const char *string, size_t targetLength, char padChar) MUST_CHECK;
 char *iPadStartCharS(char **string, size_t targetLength, char padChar) MUST_CHECK;
 char *bPadStartCharS(char *dest, const char *string, size_t targetLength, char padChar) MUST_CHECK;
 char *bLPadStartCharS(char *dest, size_t destSize, const char *string, size_t targetLength, char padChar) MUST_CHECK;
 
 // length of string after padStart
 ssize_t padStartLenS(const char *string, size_t targetLength, const char *padString) MUST_CHECK;
 
 // padEnd string
 char *padEndS(const char *string, size_t targetLength, const char *padString) MUST_CHECK;
 char *iPadEndS(char **string, size_t targetLength, const char *padString) MUST_CHECK;
 char *bPadEndS(char *dest, const char *string, size_t targetLength, const char *padString) MUST_CHECK;
 char *bLPadEndS(char *dest, size_t destSize, const char *string, size_t targetLength, const char *padString) MUST_CHECK;
 char *padEndCharS(const char *string, size_t targetLength, char padChar) MUST_CHECK;
 char *iPadEndCharS(char **string, size_t targetLength, char padChar) MUST_CHECK;
 char *bPadEndCharS(char *dest, const char *string, size_t targetLength, char padChar) MUST_CHECK;
 char *bLPadEndCharS(char *dest, size_t destSize, const char *string, size_t targetLength, char padChar) MUST_CHECK;
 
 // length of string after padEnd
 ssize_t padEndLenS(const char *string, size_t targetLength, const char *padString) MUST_CHECK;
 
 // get char at python index
 char getS(const char *string, int64_t index) MUST_CHECK;
 
 // set char at python index
 char *setS(char *string, int64_t index, char c) MUST_CHECK;
 
 // swap characters in a string
 char *swapS(char *string, int64_t index1, int64_t index2) MUST_CHECK;
 char *iSwapS(char **string, int64_t index1, int64_t index2) MUST_CHECK;
 char *bSwapS(char *string, int64_t index1, int64_t index2) MUST_CHECK;
 char *bLSwapS(char *string, size_t size, int64_t index1, int64_t index2) MUST_CHECK;
 
 // 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, int64_t start, int64_t end) MUST_CHECK;
 char *iSliceS(char **string, int64_t start, int64_t end) MUST_CHECK;
 char *bSliceS(char *string, int64_t start, int64_t end) MUST_CHECK;
 char *bLSliceS(char *string, size_t stringSize, int64_t start, int64_t end) MUST_CHECK;
 
 // crop string (slice+del)
 char *cropS(char *string, int64_t start, int64_t end) MUST_CHECK;
 char *iCropS(char **string, int64_t start, int64_t end) MUST_CHECK;
 char cropElemS(char *string, int64_t index) MUST_CHECK;
 char iCropElemS(char **string, int64_t index) MUST_CHECK;
 
 // insert string in string
 char *insertS(const char *string, int64_t index, const char *toInsert) MUST_CHECK;
 char *insertNFreeS(const char *string, int64_t index, char *toInsert) MUST_CHECK;
 char *iInsertS(char **string, int64_t index, const char *toInsert) MUST_CHECK;
 char *iInsertNFreeS(char **string, int64_t index, char *toInsert) MUST_CHECK;
 char *bInsertS(char *string, int64_t index, const char *toInsert) MUST_CHECK;
 char *bLInsertS(char *string, size_t stringSize, int64_t index, const char *toInsert) MUST_CHECK;
 
 // inject a char in string
 char *injectS(const char *string, int64_t index, char toInject) MUST_CHECK;
 char *iInjectS(char **string, int64_t index, char toInject) MUST_CHECK;
 char *bInjectS(char *string, int64_t index, char toInject) MUST_CHECK;
 char *bLInjectS(char *string, size_t stringSize, int64_t index, char toInject) MUST_CHECK;
 
 // 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, int64_t start, int64_t end) MUST_CHECK;
 char *iDelS(char **string, int64_t start, int64_t end) MUST_CHECK;
 char *bDelS(char *string, int64_t start, int64_t end) MUST_CHECK;
 char *bLDelS(char *string, size_t stringSize, int64_t start, int64_t end) MUST_CHECK;
 
 // del a character in string
 char *delElemS(const char *string, int64_t index) MUST_CHECK;
 char *iDelElemS(char **string, int64_t index) MUST_CHECK;
 char *bDelElemS(char *string, int64_t index) MUST_CHECK;
 char *bLDelElemS(char *string, size_t stringSize, int64_t index) MUST_CHECK;
 
 // find substring
 char *findS(const char *string, const char *needle) MUST_CHECK;
 char *findCharS(const char *string, char c) MUST_CHECK;
 ssize_t indexOfS(const char *string, const char *needle) MUST_CHECK;
 ssize_t indexOfCharS(const char *string, char c) MUST_CHECK;
 
 // true when needle is found
 bool hasS(const char *string, const char *needle) MUST_CHECK;
 bool hasCharS(const char *string, char c) MUST_CHECK;
 
 // ignore case find substring
 char *icFindS(const char *string, const char *needle) MUST_CHECK;
 char *icFindCharS(const char *string, char c) MUST_CHECK;
 ssize_t icIndexOfS(const char *string, const char *needle) MUST_CHECK;
 ssize_t icIndexOfCharS(const char *string, char c) MUST_CHECK;
 
 // ignore case, true when needle is found
 bool icHasS(const char *string, const char *needle) MUST_CHECK;
 bool icHasCharS(const char *string, char c) MUST_CHECK;
 
 // parse s string with delim - work like strtok_r from stdlib
 char *tokS(char *s, const char *delim, char **saveptr) MUST_CHECK;
 
 // ignore case and parse s string with delim - work like strtok_r from stdlib
 char *icTokS(char *s, const char *delim, char **saveptr) MUST_CHECK;
 
 //
 // UTF8 string functions
 //
 
 // rune is a 32 bit unicode integer
 typedef int rune;
 
 // character length of UTF-8 encoded string
 size_t lenUTF8(const char *s) MUST_CHECK;
 size_t bLLenUTF8(const char *s, size_t maxSize) MUST_CHECK;
 
 // is string valid UTF-8 encoded string
 bool isUTF8(const char * string) MUST_CHECK;
 bool bLIsUTF8(const char * string, size_t stringSize) MUST_CHECK;
 
 // is string a valid UTF-8 code point
 bool isCodeUTF8(const char *code) MUST_CHECK;
 
 extern const uint8_t codeSzUTF8[256];
 
 /** size in bytes of UTF-8 code point  */
 #define codeSizeUTF8(utf8) codeSzUTF8[*(const uint8_t *)(utf8)]
 
 /** move pointer to next UTF-8 code point, no checks are done, the utf8 pointer parameter is unchanged */
 #define nextCodeUTF8(utf8) ((utf8) + codeSizeUTF8(utf8))
 
 /** change the utf8 pointer parameter to next UTF-8 code point, like char *s; s++; */
 #define nxtCodeUTF8(utf8) EVA(utf8, nextCodeUTF8(utf8))
 #define nxCodeUTF8(utf8) (utf8 = nextCodeUTF8(utf8))
 
 // next code point, works only when utf8 points to a valid code point
 const char *nextUTF8(const char *utf8) MUST_CHECK;
 const char *bLNextUTF8(const char *string, size_t utf8Size, const char *utf8) MUST_CHECK;
 
 // find next code point even when utf8 points inside a code point
 const char *findNextUTF8(const char *string, size_t utf8Size, const char *utf8) MUST_CHECK;
 
 // previous code point, undefined behavior when utf8 points to the start of the string
 const char *prevUTF8(const char *utf8) MUST_CHECK;
 
 // previous code point
 const char *bPrevUTF8(const char *string, const char *utf8) MUST_CHECK;
 
 // character index to pointer
 const char *idx2PtrUTF8(const char *utf8, int64_t index) MUST_CHECK;
 const char *bLIdx2PtrUTF8(const char *utf8, size_t utf8Size, int64_t index) MUST_CHECK;
 
 // pointer to character index
 int64_t ptr2IdxUTF8(const char *utf8, const char *pos) MUST_CHECK;
 int64_t bPtr2IdxUTF8(const char *start, const char *utf8, const char *pos) MUST_CHECK;
 int64_t bLPtr2IdxUTF8(const char *utf8, size_t utf8Size, const char *pos) MUST_CHECK;
 int64_t bLPtr2NegIdxUTF8(const char *utf8, size_t utf8Size, const char *pos) MUST_CHECK;
 
 // make new valid UTF-8 encoded string
 char *makeValidUTF8(const char *utf8) MUST_CHECK;
 // make utf8 a valid UTF-8 encoded string
 char *bMakeValidUTF8(char *utf8) MUST_CHECK;
 char *nMakeValidUTF8(const char *utf8, size_t utf8Len) MUST_CHECK;
 char *bNMakeValidUTF8(char *dst, const char *utf8, size_t utf8Len) MUST_CHECK;
 char *bLMakeValidUTF8(char *dst, size_t dstSize, const char *utf8) MUST_CHECK;
 char *bLNMakeValidUTF8(char *dst, size_t dstSize, const char *utf8, size_t utf8Len) MUST_CHECK;
 
 // strncpy where srcLen is number of characters
 char *strNCpyUTF8(char *dst, const char *src, size_t srcLen) MUST_CHECK;
 
 // strLCpy for UTF-8 encoded strings
 char *strLCpyUTF8(char *dst, size_t dstSize, const char *src) MUST_CHECK;
 
 // strncat where srcLen is number of characters
 char *strNCatUTF8(char *dst, const char *src, size_t srcLen) MUST_CHECK;
 
 // strLCat for UTF-8 encoded strings
 char *strLCatUTF8(char *dst, size_t dstSize, const char *src) MUST_CHECK;
 
 // strLNCat for UTF-8 encoded strings
 char *strLNCatUTF8(char *dst, size_t dstSize, const char *src, size_t srcLen) MUST_CHECK;
 
 // TODO
 char* icReplaceUTF8(const char *s, const char *olds, const char *news, size_t max) MUST_CHECK;
 // TODO
 char *icReplaceCharSUTF8(const char *s, char olds, const char *news, size_t max) MUST_CHECK;
 // TODO
 char *icReplaceSCharUTF8(const char *s, const char *olds, char news, size_t max) MUST_CHECK;
 // TODO
 char* iicReplaceUTF8(char **s, const char *olds, const char *news, size_t max) MUST_CHECK;
 // TODO
 char *iicReplaceCharSUTF8(char **s, char olds, const char *news, size_t max) MUST_CHECK;
 // TODO
 char *iicReplaceSCharUTF8(char **s, const char *olds, char news, size_t max) MUST_CHECK;
 // TODO
 char* bicReplaceUTF8(char *s, const char *olds, const char *news, size_t max) MUST_CHECK;
 // TODO
 char* bLicReplaceUTF8(char *s, size_t sSize, const char *olds, const char *news, size_t max) MUST_CHECK;
 // TODO
 char *icReplaceManyUTF8F(const char *paramType, ...) MUST_CHECK;
 // TODO
 char *iicReplaceManyUTF8F(char **s, char *paramType, ...) MUST_CHECK;
 // TODO
 char *bicReplaceManyUTF8F(char *s, char *paramType, ...) MUST_CHECK;
 // TODO
 char *bLicReplaceManyUTF8F(char *s, size_t sSize, char *paramType, ...) MUST_CHECK;
 
 // UTF8 encoded string Index Equal
 bool eqIUTF8(const char *string1, const char *string2, int64_t index) MUST_CHECK;
 
 // UTF8 encoded string Index Equal
 bool eqICharUTF8(const char *string1, char c, int64_t index) MUST_CHECK;
 
 // ignore case UTF8 encoded string Equal
 bool icEqUTF8(const char *string1, const char *string2) MUST_CHECK;
 bool icEqCharUTF8(char c, const char *string2) MUST_CHECK;
 bool icEqUTF8Char(const char *string1, char c) MUST_CHECK;
 
 // TODO
 bool icEqIUTF8(const char *string1, const char *string2, int64_t index) MUST_CHECK;
 // TODO
 bool icEqICharUTF8(const char *string1, char c, int64_t index) MUST_CHECK;
 
 // starts with for UTF-8 encoded string
 bool icStartsWithUTF8(const char *string1, const char *string2) MUST_CHECK;
 
 // ends with for UTF-8 encoded string
 bool icEndsWithUTF8(const char *string1, const char *string2) MUST_CHECK;
 
 // ignore case count UTF8 encoded String
 ssize_t icCountUTF8(const char *s, const char *needle) MUST_CHECK;
 
 // UTF-8 code point to rune
 rune code2RuneUTF8(const char *code) MUST_CHECK;
 rune code2RuneLUTF8(const char *code, uint8_t *n) MUST_CHECK;
 
 // rune to UTF-8 code point
 size_t bRune2CodeUTF8(char *dst, rune c) MUST_CHECK;
 
 // rune length as UTF-8 code point
 uint8_t runeLenUTF8(rune r) MUST_CHECK;
 
 // rune toupper UTF8
 rune toupperUTF8(rune c) MUST_CHECK;
 
 // upper case UTF-8 encoded string
 char *upperUTF8(const char *string) MUST_CHECK;
 char *iUpperUTF8(char **string) MUST_CHECK;
 // TODO
 char *bUpperUTF8(char *string) MUST_CHECK;
 
 // rune tolower UTF8
 rune tolowerUTF8(rune c) MUST_CHECK;
 
 // lower case UTF-8 String
 char *lowerUTF8(const char *string) MUST_CHECK;
 char *iLowerUTF8(char **string) MUST_CHECK;
 // TODO
 char *bLowerUTF8(char *string) MUST_CHECK;
 
 // transform UTF-8 string to make it comparable regardless of case
 char *casefoldUTF8(const char *utf8) MUST_CHECK;
 
 // uniquify code point in UTF-8 String
 char *uniqUTF8(const char *string, const char *code) MUST_CHECK;
 char *iUniqUTF8(char **string, const char *code) MUST_CHECK;
 char *bUniqUTF8(char *string, const char *code) MUST_CHECK;
 // TODO
 char *icUniqUTF8(const char *string, const char *code) MUST_CHECK;
 // TODO
 char *iicUniqUTF8(char **string, const char *code) MUST_CHECK;
 // TODO
 char *bicUniqUTF8(char *string, char c) MUST_CHECK;
 
 // get rune in UTF8 encoded string
 rune getUTF8(const char *string, int64_t index) MUST_CHECK;
 
 // TODO
 char *setUTF8(char *string, int64_t index, rune c) MUST_CHECK;
 
 // slice UTF8 encoded String
 char *sliceUTF8(const char *string, int64_t start, int64_t end) MUST_CHECK;
 char *iSliceUTF8(char **string, int64_t start, int64_t end) MUST_CHECK;
 char *bSliceUTF8(char *string, int64_t start, int64_t end) MUST_CHECK;
 char *bLSliceUTF8(char *string, size_t stringSize, int64_t start, int64_t end) MUST_CHECK;
 
 // insert string in UTF8 encoded string at index
 char *insertUTF8(const char *string, int64_t index, const char *toInsert) MUST_CHECK;
 char *insertNFreeUTF8(const char *string, int64_t index, char *toInsert) MUST_CHECK;
 char *iInsertUTF8(char **string, int64_t index, const char *toInsert) MUST_CHECK;
 char *iInsertNFreeUTF8(char **string, int64_t index, char *toInsert) MUST_CHECK;
 char *bInsertUTF8(char *string, int64_t index, const char *toInsert) MUST_CHECK;
 char *bLInsertUTF8(char *string, size_t stringSize, int64_t index, const char *toInsert) MUST_CHECK;
 
 // delete UTF8 encoded string
 char *delUTF8(const char *string, int64_t start, int64_t end) MUST_CHECK;
 char *iDelUTF8(char **string, int64_t start, int64_t end) MUST_CHECK;
 char *bDelUTF8(char *string, int64_t start, int64_t end) MUST_CHECK;
 char *bLDelUTF8(char *string, size_t stringSize, int64_t start, int64_t end) MUST_CHECK;
 
 // indexOf UTF8 encoded String
 ssize_t indexOfUTF8(const char *string, const char *needle) MUST_CHECK;
 // TODO
 ssize_t icIndexOfUTF8(const char *string, const char *needle) MUST_CHECK;
 
 // ignore case has UTF8 encoded String
 bool icHasUTF8(const char *string, const char *needle) MUST_CHECK;
 
 // TODO
 char *icTokUTF8(const char *s, const char *delim, char **saveptr) MUST_CHECK;
 
 // TODO
 char **icExtractUTF8(const char *string, const char* delim1, const char* delim2) MUST_CHECK;
 char **icExtractCharSUTF8(const char *string, char delim1, const char* delim2) MUST_CHECK;
 char **icExtractSCharUTF8(const char *string, const char* delim1, char delim2) MUST_CHECK;
 
 // ignore case list Sort UTF8 encoded String
 char **icListSortUTF8(char **list) MUST_CHECK;
 char **iicListSortUTF8(char ***list) MUST_CHECK;
 
 // ignore case list Equal UTF8 encoded String
 bool icListEqUTF8(char **list1, char **list2) MUST_CHECK;
 
 // ignore case and return true when list has UTF8 encoded string
 bool icListHasUTF8(char **list, const char *string) MUST_CHECK;
 
 // ignore case and return index of UTF8 encoded string in list
 ssize_t icListIndexOfUTF8(char **list, const char *string) MUST_CHECK;
 
 // ignore case list binary search UTF8 encoded string
 ssize_t icListBinarySearchUTF8(char **list, const char *string) MUST_CHECK;
 
 // ignore case and uniquify UTF8 encoded elements of list
 char **icListUniqUTF8(char **list) MUST_CHECK;
 char **iicListUniqUTF8(char ***list) MUST_CHECK;
 
 //
 // End UTF8 string functions
 //
 
 
 // create empty string
 #define emptyS(string) \
   string = strdup("");
 char *emptySF(void) MUST_CHECK;
 char *iEmptySF(char **string) MUST_CHECK;
 // string buffer empty - set 0 at index 0
 #define bEmptyS(string) \
   (string)[0] = 0
 
 // is empty string
 bool isEmptyS(const char *string) MUST_CHECK;
 
 /**
  * orS - if string is empty, the value is alternative
  */
 #define orS(string, alternative) \
   !isEmptyS(string) ? (string) : (alternative)
 
 // true when string is empty or white spaces
 bool isBlankS(const char *string) MUST_CHECK;
 
 /**
  * blankS - if string is blank(white spaces) or empty, the value is alternative
  */
 #define orBlankS(string, alternative) \
   !isBlankS(string) ? (string) : (alternative)
 
 /**
  * nS - null String - replace null string with "" string (empty string)
  */
 #define nS(string) \
   (string) ? (string) : ""
 
 /**
  * nAS - null Alternative String - replace null string with alternative string
  */
 #define nAS(string, alternative) \
   (string) ? (string) : (alternative)
 
 
 // convert python index (int, positive and negative) to always positive index (uint), this function is more generic than listIntIndexS
 ssize_t intIndex(int64_t index, int64_t length);
 
 // create empty list
 #define listEmptyS(list) \
   do {\
     list = malloc(1 * sizeof(char *)); \
     if (list) list[0] = NULL; \
   } while(0);
 
 char **listEmptySF(void) MUST_CHECK;
 char **iListEmptySF(char ***list) MUST_CHECK;
 
 // false when there are elements in the list
 bool listIsEmptyS(char **list) MUST_CHECK;
 
 // false when there are non blank elements in the list
 bool listIsBlankS(char **list) MUST_CHECK;
 
 // String Lists
 // createList(...)
 char **listCreateSF(const char *paramType, ...) MUST_CHECK;
 #define listCreateS(...) listCreateSF("", __VA_ARGS__, NULL)
 
 // copy array to new list
 char **listFromArrayS(char **array, size_t size) MUST_CHECK;
 char **listFromCArrayS(const char **array, size_t size) MUST_CHECK;
 
 // push and pop (append) str
 // modifies the list
 char **listPushS(char ***list, const char *s) MUST_CHECK;
 char **listPushCharS(char ***list, char c) MUST_CHECK;
 char **iListPushS(char ***list, char *s) MUST_CHECK;
 
 // copy last string and free it in the list
 char *listPopS(char ***list) MUST_CHECK;
 
 // prepend and dequeue (append) str
 // modifies the list
 char **listPrependS(char ***list, const char *s) MUST_CHECK;
 char **listPrependCharS(char ***list, char c) MUST_CHECK;
 char **iListPrependS(char ***list, char *s) MUST_CHECK;
 
 // copy fist string and free it in the list
 char *listDequeueS(char ***list) MUST_CHECK;
 
 // freeList
 void listFreeS(char **list);
 
 // free many char**
 void listFreeManySF(char **paramType, ...);
 #define listFreeManyS(...) listFreeManySF(NULL, __VA_ARGS__, NULL)
 
 // length
 size_t listLengthS(char **list) MUST_CHECK;
 size_t listLengthCS(const char **list) MUST_CHECK;
 
 // list length as a single string
 ssize_t listStrLengthS(char **list) MUST_CHECK;
 
 // convert python index (int) to always positive index (uint)
 ssize_t listIntIndexS(char **list, int64_t index) MUST_CHECK;
 
 // pointer to the char* at python index
 char **listAddrS(char **list, int64_t index) MUST_CHECK;
 
 // list get - get a string at python index
 char *listGetS(char **list, int64_t index) MUST_CHECK;
 char *iListGetS(char **list, int64_t index) MUST_CHECK;
 char *listGetCS(const char **list, int64_t index) MUST_CHECK;
 const char *iListGetCS(const char **list, int64_t index) MUST_CHECK;
 
 // list set - replace a string at python index
 char **listSetS(char **list, int64_t index, const char *s) MUST_CHECK;
 char **listSetCharS(char **list, int64_t index, char c) MUST_CHECK;
 char **iListSetS(char **list, int64_t index, char *s) MUST_CHECK;
 
 // swap elements in a list
 char **listSwapS(char **list, int64_t index1, int64_t index2) MUST_CHECK;
 char **iListSwapS(char **list, int64_t index1, int64_t index2) MUST_CHECK;
 
 // split
 char **split(const char *string, const char* delim) MUST_CHECK;
 char **splitS(const char *string, const char* delim) MUST_CHECK;
 char **splitChar(const char *string, char delim) MUST_CHECK;
 
 // ignore case split
 char **icSplit(const char *string, const char* delim) MUST_CHECK;
 char **icSplitS(const char *string, const char* delim) MUST_CHECK;
 char **icSplitChar(const char *string, char delim) MUST_CHECK;
 
 // list length after joined with delimiter
 ssize_t joinLength(char **list, const char* delim) MUST_CHECK;
 
 // join
 char *join(char **list, const char* delim) MUST_CHECK;
 char *joinS(char **list, const char* delim) MUST_CHECK;
 char *joinCS(const char **list, const char* delim) MUST_CHECK;
 char *joinChar(char **list, char delim) MUST_CHECK;
 char *bJoin(char *string, char **list, const char* delim) MUST_CHECK;
 char *bJoinChar(char *string, char **list, char delim) MUST_CHECK;
 char *bLJoin(char *string, size_t stringSize, char **list, const char* delim) MUST_CHECK;
 char *bLJoinChar(char *string, size_t stringSize, char **list, char delim) MUST_CHECK;
 
 // extract string
 char **extractS(const char *string, const char* delim1, const char* delim2) MUST_CHECK;
 char **extractCharSS(const char *string, char delim1, const char* delim2) MUST_CHECK;
 char **extractSCharS(const char *string, const char* delim1, char delim2) MUST_CHECK;
 char **extractCharCharS(const char *string, char delim1, char delim2) MUST_CHECK;
 
 // ignore case extract string
 char **icExtractS(const char *string, const char* delim1, const char* delim2) MUST_CHECK;
 char **icExtractCharSS(const char *string, char delim1, const char* delim2) MUST_CHECK;
 char **icExtractSCharS(const char *string, const char* delim1, char delim2) MUST_CHECK;
 char **icExtractCharCharS(const char *string, char delim1, char delim2) MUST_CHECK;
 
 // duplicate list
 char **listDupS(char **list) MUST_CHECK;
 char **listDupCS(const char **list) MUST_CHECK;
 char **iListDupS(char **list) MUST_CHECK;
 
 // duplicate and reverse list
 char **listReverseS(char **list) MUST_CHECK;
 char **iListReverseS(char ***list) MUST_CHECK;
 
 // listCatS: f(l1, l2, l3)
 char **listCatSF(char **paramType, ...) MUST_CHECK;
 #define listCatS(...) listCatSF(NULL, __VA_ARGS__, NULL)
 
 // append lists
 char **listAppendS(char ***list1, char **list2) MUST_CHECK;
 char **iListAppendS(char ***list1, char **list2) MUST_CHECK;
 char **iListAppendNSmashS(char ***list1, char **list2) MUST_CHECK;
 
 // prepend list at the start and shift existing elements
 char **listShiftS(char ***list1, char **list2) MUST_CHECK;
 char **iListShiftS(char ***list1, char **list2) MUST_CHECK;
 char **iListShiftNSmashS(char ***list1, char **list2) MUST_CHECK;
 
 // add lists
 char **listAddS(char **list1, char **list2);
 char **listAddCS(char **list1, const char **list2);
 
 // slice - python style indexes 0..len-1 -1..-len+1
 char **listSliceS(char **list, int64_t start, int64_t end) MUST_CHECK;
 char **iListCopyS(char **list, int64_t start, int64_t end) MUST_CHECK;
 char **iListSliceS(char ***list, int64_t start, int64_t end) MUST_CHECK;
 
 // crop list (slice+del)
 char **listCropS(char **list, int64_t start, int64_t end) MUST_CHECK;
 char **iListCropS(char ***list, int64_t start, int64_t end) MUST_CHECK;
 char *listCropElemS(char **list, int64_t index) MUST_CHECK;
 char *iListCropElemS(char ***list, int64_t index) MUST_CHECK;
 
 // insert list in list
 char **listInsertS(char **list, int64_t index, char **toInsert) MUST_CHECK;
 char **iListInsertS(char ***list, int64_t index, char **toInsert) MUST_CHECK;
 char **iListInsertNFreeS(char ***list, int64_t index, char **toInsert) MUST_CHECK;
 
 // inject string in list
 char **listInjectS(char **list, int64_t index, char *toInject) MUST_CHECK;
 char **listInjectCharS(char **list, int64_t index, char toInject) MUST_CHECK;
 char **iListInjectS(char ***list, int64_t index, char *toInject) MUST_CHECK;
 char **iListInjectCharS(char ***list, int64_t index, char toInject) MUST_CHECK;
 
 // del - python style indexes 0..len-1 -1..-len+1
 char **listDelS(char **list, int64_t start, int64_t end) MUST_CHECK;
 char **iListDelS(char ***list, int64_t start, int64_t end) MUST_CHECK;
 char **iListRemoveS(char ***list, int64_t start, int64_t end);
 
 // del element in list
 char **listDelElemS(char **list, int64_t index) MUST_CHECK;
 char **iListDelElemS(char ***list, int64_t index) MUST_CHECK;
 char **iListRemoveElemS(char ***list, int64_t index) MUST_CHECK;
 
 // print list
 int listPrintS(char **list) MUST_CHECK;
 int listPrintCS(const char **list) MUST_CHECK;
 
 /**
  * forever loop
  */
 #define forever while(1)
 
 /**
  * range loop
  * ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define range(index, maxCount) \
   ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   for (size_t index = 0 ; index < UNIQVAR(maxCnt) ; index++)
 
 /**
  * infinity loop
  * increase the index infinitly
  */
 #define rangeInf(index) \
   for (size_t index = 0 ;; index++)
 
 /**
  * range down loop, index is ssize_t
  */
 #define rangeDown(index, maxCount) \
   for (ssize_t index = (maxCount)-1 ; index >= 0 ; index--)
 
 /**
  * range down loop to to index, index is ssize_t
  * ;ssize_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define rangeDownTo(index, maxCount, to) \
   ;ssize_t UNIQVAR(_to) = to;\
   for (ssize_t index = (maxCount)-1 ; index >= UNIQVAR(_to) ; index--)
 
 /**
  * range loop starting at value from
  * ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define rangeFrom(index, from, maxCount) \
   ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   for (size_t index = from ; index < UNIQVAR(maxCnt) ; index++)
 
 /**
  * loop on the elements of C static array of any type
  *
  * Example:
  * u32 array[20];
  * arange(i, array) {}
  */
 #define arange(index, array) range(index, ARRAY_SIZE(array))
 
 /**
  * loop on the elements of C static array of any type from highest index down to 0
  *
  * Example:
  * u32 array[20];
  * arangeDown(i, array) {}
  */
 #define arangeDown(index, array) rangeDown(index, ARRAY_SIZE(array))
 
 /**
  * loop on the elements of C static array of any type from highest index down to index 'to'
  *
  * Example:
  * u32 array[20];
  * arangeDownTo(i, array, 5) {}
  */
 #define arangeDownTo(index, array, to) rangeDownTo(index, ARRAY_SIZE(array), to)
 
 /**
  * loop on the elements of C static array of any type starting at index 'from'
  *
  * Example:
  * u32 array[20];
  * arange(i, 10, array) {}
  */
 #define arangeFrom(index, from, array) rangeFrom(index, from, ARRAY_SIZE(array))
 
 /**
  * range from value from to maxCount-1 then from 0 to from-1
  *
  * Example:
  * circular(i, 2, 4)
  *
  * counts: 2, 3, 0, 1
  *
  * ;bool UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define circular(index, from, maxCount) \
   ;bool UNIQVAR(libsheepyInternalStatus) = true; \
   size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   size_t UNIQVAR(frm) = (size_t)(from); \
   for (size_t index = UNIQVAR(frm) ; (index != UNIQVAR(frm)) || (UNIQVAR(libsheepyInternalStatus)); index == (UNIQVAR(maxCnt)-1) ? index = 0 : index++, UNIQVAR(libsheepyInternalStatus) = false)
 
 /**
  * range from value from down to 0 then from maxCount-1 to from+1
  *
  * Example:
  * circularDown(i, 2, 4)
  *
  * counts: 2, 1, 0, 3
  *
  * ;bool UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define circularDown(index, from, maxCount) \
   ;bool UNIQVAR(libsheepyInternalStatus) = true; \
   size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   size_t UNIQVAR(frm) = (size_t)(from); \
   for (size_t index = UNIQVAR(frm) ; (index != UNIQVAR(frm)) || (UNIQVAR(libsheepyInternalStatus)); index == 0 ? index = (UNIQVAR(maxCnt)-1) : index--, UNIQVAR(libsheepyInternalStatus) = false)
 
 /**
  * range step loop
  * ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define rangeStep(index, maxCount, step) \
   ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   for (size_t index = 0 ; index < UNIQVAR(maxCnt) ; index+=step)
 
 /**
  * range down step loop, index is int64_t
  */
 #define rangeDownStep(index, maxCount, step) \
   for (int64_t index = (maxCount)-1 ; index >= 0 ; index-=step)
 
 /**
  * range step loop starting at value from
  * ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define rangeFromStep(index, from, maxCount, step) \
   ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   for (size_t index = from ; index < UNIQVAR(maxCnt) ; index+=(size_t)step)
 
 
 /**
  * loops without index
  * ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define loop(maxCount) \
   ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   for (size_t UNIQVAR(index) = 0 ; UNIQVAR(index) < UNIQVAR(maxCnt) ; UNIQVAR(index)++)
 
 /**
  * loop to to index
  * ;ssize_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define loopDownTo(maxCount, to) \
   ;ssize_t UNIQVAR(_to) = to;\
   for (ssize_t UNIQVAR(index) = (maxCount)-1 ; UNIQVAR(index) >= UNIQVAR(_to) ; UNIQVAR(index)--)
 
 /**
  * loop starting at value from
  * ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define loopFrom(from, maxCount) \
   ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   for (size_t UNIQVAR(index) = from ; UNIQVAR(index) < UNIQVAR(maxCnt) ; UNIQVAR(index)++)
 
 /**
  * step loop
  * ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define loopStep(maxCount, step) \
   ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   for (size_t UNIQVAR(index) = 0 ; UNIQVAR(index) < UNIQVAR(maxCnt) ; UNIQVAR(index)+=step)
 
 /**
  * step loop starting at value from
  * ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define loopFromStep(from, maxCount, step) \
   ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
   for (size_t UNIQVAR(index) = from ; UNIQVAR(index) < UNIQVAR(maxCnt) ; UNIQVAR(index)+=step)
 
 
 /**
  * loop on array elements
  * element is a pointer to a value in the array
  *
  * aForEach(array, e) {
  *    e->x = 0;
  * }
  */
 #define aForEach(array, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
   for (typeof(&array[0]) element = &array[0] ; UNIQVAR(libsheepyInternalIndex) < ARRAY_SIZE(array) ; UNIQVAR(libsheepyInternalIndex)++, element = &array[UNIQVAR(libsheepyInternalIndex)])
 
 /**
  * enumerate array elements
  * index is the position of the element in the array
  * index is declared as size_t and is available after the loop
  * element is a pointer to a value in the array
  *
  * aEnumerate(array, i, e) {
  *    e->x = 0;
  *    printf("aEnumerate %d\n", i);
  * }
  */
 #define aEnumerate(array, index, element) \
   ; size_t index = 0 ; \
   for (typeof(&array[0]) element = &array[0] ; index < ARRAY_SIZE(array) ; index++, element = &array[index])
 
 /**
  * forEach - loop macro on list indexes
  * to access the element in the loop, use *element
   */
 #define forEachCharP(list, element) \
   for (char **element=list ; *element != NULL ; element++)
 
 /**
  * forEach for const char** lists
  */
 #define forEachCCharP(list, element) \
   for (const char **element=list ; *element != NULL ; element++)
 
 /**
  * forEach - loop macro on list indexes
  * to access the element in the loop, use element
  * ;size_t UNIQVAR needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define forEachS(list, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
   for (char *element = (list)[0]; (list)[UNIQVAR(libsheepyInternalIndex)]!= NULL ; UNIQVAR(libsheepyInternalIndex)++, element = (list)[UNIQVAR(libsheepyInternalIndex)])
 
 /**
  * forEach for const char** lists
  */
 #define forEachCS(list, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
   for (const char *element = (list)[0]; (list)[UNIQVAR(libsheepyInternalIndex)]!= NULL ; UNIQVAR(libsheepyInternalIndex)++, element = (list)[UNIQVAR(libsheepyInternalIndex)])
 
 /**
  * forEach - loop macro on list indexes
  */
 #define forEachType(type, list, element) \
   for (type **element=list ; *element != NULL ; element++)
 
 /**
  * enumerateCharP list
  * to access the element in the loop, use *element
  * ;size_t needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define enumerateCharP(list, element, index) \
   ;size_t index = 0; \
   for (char **element=list; *element != NULL ; element++, index++)
 
 /**
  * enumerateCCharP const list
  * to access the element in the loop, use *element
  * ;size_t needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define enumerateCCharP(list, element, index) \
   ;size_t index = 0; \
   for (const char **element=list; *element != NULL ; element++, index++)
 
 /**
  * enumerateS list
  * to acess the element in the loop, use element
  * ;size_t needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define enumerateS(list, element, index) \
   ;size_t index = 0; \
   for (char *element=(list)[0]; element != NULL ; index++, element = (list)[index])
 
 /**
  * enumerateCS const list
  * to acess the element in the loop, use element
  * ;size_t needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define enumerateCS(list, element, index) \
   ;size_t index = 0; \
   for (const char *element=(list)[0]; element != NULL ; index++, element = (list)[index])
 
 /**
  * enumerateType list
  * ;size_t needed to avoid: error: a label can only be part of a statement and a declaration is not a statement
  * on older compilers
  */
 #define enumerateType(type, list, element, index) \
   ;size_t index = 0; \
   for (type **element=list; *element != NULL ; element++, index++)
 
 /**
  * loop for linked lists from startNode to last
  *
  * node must be a pointer to a struct with a next member pointing
  * to the next node in the list
  *
  * when node->next is NULL, the list end is reached
  * */
 #define lForEach(node, startNode)\
   for(var node = startNode; node ; node = (node)->next)
 
 /**
  * loop for linked lists from startNode to head
  *
  * node must be a pointer to a struct with a prev member pointing
  * to the previous node in the list
  *
  * when node->prev is NULL, the list head is reached
  */
 #define lForEachDown(node, startNode)\
   for(var node = startNode; node ; node = (node)->prev)
 
 #define lForEachPrev lForEachDown
 
 // user defined function for sort functions
 typedef int (*shCmpt)(const void * a, const void * b);
 
 // duplicate and sort
 char **listSortS(char **list) MUST_CHECK;
 char **iListSortS(char ***list) MUST_CHECK;
 char **listSortFS(char **list, shCmpt compareFunction) MUST_CHECK;
 char **iListSortFS(char ***list, shCmpt compareFunction) MUST_CHECK;
 
 // ignore case, duplicate and sort
 char **icListSortS(char **list) MUST_CHECK;
 char **iicListSortS(char ***list) MUST_CHECK;
 
 // open text file and return lines in list
 char **readText(const char *filePath) MUST_CHECK;
 
 // read opened text file and return lines in list
 // the file is left open
 char **readStream(FILE *fp) MUST_CHECK;
 
 // write text file
 bool writeText(const char *filePath, char **list) MUST_CHECK;
 bool writeCText(const char *filePath, const char **list) MUST_CHECK;
 
 // write buffer
 bool writeStream(FILE *fp, char **list) MUST_CHECK;
 bool writeCStream(FILE *fp, const char **list) MUST_CHECK;
 
 // append text to file
 bool appendText(const char *filePath, char **list) MUST_CHECK;
 bool appendCText(const char *filePath, const char **list) MUST_CHECK;
 
 // execOut
 char **execOut(const char *cmd) MUST_CHECK;
 // convenience define
 #define execOutf systemOutf
 #define execf systemf
 
 // system command with formatting
 char **systemOutf(const char *fmt, ...) MUST_CHECK;
 // convenience define
 #define systemOut execOut
 int systemf(const char *fmt, ...) MUST_CHECK;
 
 // system commands and log
 #define logSystem(cmd) funcbegin\
     var UNIQVAR(cm) = cmd;\
     logI("%s",UNIQVAR(cm));\
     system   (UNIQVAR(cm));\
   funcend
 #define logExec logSystem
 #define logSystemOut(cmd) ({\
     var UNIQVAR(cm) = cmd;\
     logI("%s",UNIQVAR(cm));\
     systemOut(UNIQVAR(cm));\
   })
 #define logExecOut logSystemOut
 #define logSystemOutf(fmt, ...) ({\
     logI      (fmt, __VA_ARGS__);\
     systemOutf(fmt, __VA_ARGS__);})
 #define logExecOutf logSystemOutf
 #define logSystemf(fmt, ...) ({\
     logI   (fmt, __VA_ARGS__);\
     systemf(fmt, __VA_ARGS__);})
 #define logExecf logSystemf
 
 // run command and return exit code from command (not system return value like system, systemf and systemNFree)
 #define command(cmd) commandF(cmd, __LINE__, __func__, __FILE__)
 int commandF(const char *cmd, int line, const char *thisFunc, const char *thisFileName) MUST_CHECK;
 #define commandf(...) commandfF(__LINE__, __func__, __FILE__, __VA_ARGS__)
 int commandfF(int line, const char *thisFunc, const char *thisFileName, const char *fmt, ...) MUST_CHECK;
 #define commandNFree(cmd) commandNFreeF(cmd, __LINE__, __func__, __FILE__)
 int commandNFreeF(char *cmd, int line, const char *thisFunc, const char *thisFileName) MUST_CHECK;
 #define commandOut execOut
 #define commandOutf systemOutf
 
 // log then run command and return exit code from command (not system return value like system, systemf and systemNFree)
 #define logCommand(cmd) funcbegin\
     var UNIQVAR(cm) = cmd;\
     logI("%s",UNIQVAR(cm));\
     command  (UNIQVAR(cm));\
   funcend
 
 #define logCommandf(fmt, ...) funcbegin\
     logI    (fmt, __VA_ARGS__);\
     commandf(fmt, __VA_ARGS__);\
   funcend
 
 #define logCommandNFree(cmd) funcbegin\
     var UNIQVAR(cm) = cmd;\
     logI   ("%s",UNIQVAR(cm));\
     commandNFree(UNIQVAR(cm));\
   funcend
 
 #define logCommandOut logExecOut
 #define logCommandOutf logExecOutf
 
 // compare lists
 bool listEqS(char **list1, char **list2) MUST_CHECK;
 bool listEqCS(char **list1, const char **list2) MUST_CHECK;
 bool listEqC1S(const char **list1, char **list2) MUST_CHECK;
 bool listEqCCS(const char **list1, const char **list2) MUST_CHECK;
 
 // has
 bool listHasS(char **list, const char *string) MUST_CHECK;
 bool listHasCS(const char **list, const char *string) MUST_CHECK;
 bool listHasCharS(char **list, char c) MUST_CHECK;
 bool listHasCharCS(const char **list, char c) MUST_CHECK;
 
 // indexOf
 ssize_t listIndexOfS(char **list, const char *string) MUST_CHECK;
 ssize_t listIndexOfCS(const char **list, const char *string) MUST_CHECK;
 ssize_t listIndexOfCharS(char **list, char c) MUST_CHECK;
 ssize_t listIndexOfCharCS(const char **list, char c) MUST_CHECK;
 
 // list binary search string
 ssize_t listBinarySearchS(char **list, const char *string) MUST_CHECK;
 ssize_t listBinarySearchCharS(char **list, char c) MUST_CHECK;
 
 // duplicate and uniquify
 char **listUniqS(char **list) MUST_CHECK;
 char **iListUniqS(char ***list) MUST_CHECK;
 
 // ignore case and compare lists
 bool icListEqS(char **list1, char **list2) MUST_CHECK;
 bool icListEqCS(char **list1, const char **list2) MUST_CHECK;
 bool icListEqC1S(const char **list1, char **list2) MUST_CHECK;
 bool icListEqCCS(const char **list1, const char **list2) MUST_CHECK;
 
 // ignore case has
 bool icListHasS(char **list, const char *string) MUST_CHECK;
 bool icListHasCharS(char **list, char c) MUST_CHECK;
 bool icListHasCS(const char **list, const char *string) MUST_CHECK;
 bool icListHasCharCS(const char **list, char c) MUST_CHECK;
 
 // ignore case indexOf
 ssize_t icListIndexOfS(char **list, const char *string) MUST_CHECK;
 ssize_t icListIndexOfCS(const char **list, const char *string) MUST_CHECK;
 ssize_t icListIndexOfCharS(char **list, char c) MUST_CHECK;
 ssize_t icListIndexOfCharCS(const char **list, char c) MUST_CHECK;
 
 // ignore case list binary search string
 ssize_t icListBinarySearchS(char **list, const char *string) MUST_CHECK;
 ssize_t icListBinarySearchCharS(char **list, char c) MUST_CHECK;
 
 // ignore case, duplicate and uniquify
 char **icListUniqS(char **list) MUST_CHECK;
 char **iicListUniqS(char ***list) MUST_CHECK;
 
 // duplicate and compact
 char **listCompactS(char **list) MUST_CHECK;
 char **iListCompactS(char ***list) MUST_CHECK;
 
 void btraceEnable(void);
 void btraceDisable(void);
 bool btraceConfig(void) MUST_CHECK;
 
 // get backtrace
 char **btrace(void);
 
 // print backtrace
 #if __APPLE__
 // TODO readelf missing in macOS
 #define logBtrace
 #else
 #define logBtrace char **UNIQVAR(r)=btrace();if(UNIQVAR(r)){logN("\n"BLD WHT"Backtrace:"RST);forEachS(UNIQVAR(r), element){logN(element);}listFreeS(UNIQVAR(r));logN("---");}
 #endif
 
 extern bool btraceCfg;
 
 /** print backtrace in error messages, default is on, use btraceEnable and btraceDisable to configure */
 #define logEBtrace if (btraceCfg) { char **UNIQVAR(r)=btrace();if(UNIQVAR(r)){logE("\n"BLD WHT"Backtrace:"RST);forEachS(UNIQVAR(r), element){logE(element);}listFreeS(UNIQVAR(r));logE("---");} }
 
 
 // **************************
 // void ** lists
 // **************************
 
 // create empty list
 #define listEmpty(list) \
   do {\
     list = malloc(1 * sizeof(void *)); \
     if (list) list[0] = NULL; \
   } while(0);
 
 void **listEmptyF(void) MUST_CHECK;
 void **iListEmptyF(void ***list) MUST_CHECK;
 
 // false when there are elements in the list
 bool listIsEmpty(void **list) MUST_CHECK;
 
 // createList(...)
 void **listCreateF(void *paramType, ...) MUST_CHECK;
 #define listCreate(...) listCreateF(NULL, __VA_ARGS__, NULL)
 
 // copy array to new list
 void **listFromArray(void **array, size_t size) MUST_CHECK;
 
 // push and pop (append) element
 // modifies the list
 void **listPush(void ***list, void *s) MUST_CHECK;
 
 // return last element and remove it from the list
 void *listPop(void ***list) MUST_CHECK;
 
 // prepend and dequeue (append) element
 // modifies the list
 void **listPrepend(void ***list, void *s) MUST_CHECK;
 
 // return fist element and remove it from the list
 void *listDequeue(void ***list) MUST_CHECK;
 
 // freeList
 void listFree(void **list);
 
 // free many void**
 void listFreeManyF(void **paramType, ...);
 #define listFreeMany(...) listFreeManyF(NULL, __VA_ARGS__, NULL)
 
 // length
 size_t listLength(void **list) MUST_CHECK;
 
 // list get - get an element at python index
 void *listGet(void **list, int64_t index) MUST_CHECK;
 
 // list set - replace a string at python index
 void **listSet(void **list, int64_t index, void *s) MUST_CHECK;
 
 // duplicate list
 void **listDup(void **list) MUST_CHECK;
 
 // duplicate and reverse list
 void **listReverse(void **list) MUST_CHECK;
 void **iListReverse(void ***list) MUST_CHECK;
 
 // listCatS: f(l1, l2, l3)
 void **listCatF(void **paramType, ...) MUST_CHECK;
 #define listCat(...) listCatF(NULL, __VA_ARGS__, NULL)
 
 // append lists
 void **listAppend(void ***list1, void **list2) MUST_CHECK;
 
 // add lists
 void **listAdd(void **list1, void **list2) MUST_CHECK;
 
 // slice - python style indexes 0..len-1 -1..-len+1
 void **listSlice(void **list, int64_t start, int64_t end) MUST_CHECK;
 void **iListSlice(void ***list, int64_t start, int64_t end) MUST_CHECK;
 
 // insert list in list
 void **listInsert(void **list, int64_t index, void **toInsert) MUST_CHECK;
 void **iListInsert(void ***list, int64_t index, void **toInsert) MUST_CHECK;
 
 // del - python style indexes 0..len-1 -1..-len+1
 void **listDel(void **list, int64_t start, int64_t end) MUST_CHECK;
 void **iListDel(void ***list, int64_t start, int64_t end) MUST_CHECK;
 //NOT NEEDED same as iListDel - void **iListRemove(void ***list, int64_t start, int64_t end);
 
 // duplicate and sort
 //TODO void **listSort(void **list);
 //TODO void iListSort(void ***list);
 
 // compare lists
 //TODO bool listEq(void **list1, void **list2);
 
 // indexOf
 //TODO ssize_t listIndexOf(void **list, const void *string);
 
 // list binary search string
 //TODO ssize_t listBinarySearch(void **list, const void *string);
 
 // duplicate and uniquify
 //TODO void **listUniq(void **list);
 //TODO void iListUniq(void ***list);
 
 // duplicate and compact
 //TODO void **listCompact(void **list);
 //TODO void iListCompact(void ***list);
 
 // create name variable and allocate it on heap
 #define newPtr(name, type)\
   ;type *name = malloc(sizeof(type))
 
 // create name variable and calloc it on heap
 #define new0Ptr(name, type)\
   ;type *name = calloc(1, sizeof(type))
 
 // allocate struct on heap and assign address
 #define allocAPtr(name) name = malloc(sizeof(*(name)))
 
 // calloc struct on heap and assign address
 #define callocAPtr(name) name = calloc(1, sizeof(*(name)))
 
 // create name variable and allocate array of type on heap
 #define newArray(name, type, count)\
   ;type *name = malloc((count) * sizeof(type))
 
 // create name variable and calloc array of type on heap
 #define new0Array(name, type, count)\
   ;type *name = calloc(count, sizeof(type))
 
 // allocate array
 #define allocArray(name, count) malloc((count) * sizeof(*(name)))
 
 // allocate and assign array
 #define allocAArray(name, count) name = malloc((count) * sizeof(*(name)))
 
 // calloc array
 #define callocArray(name, count) calloc(count,  sizeof(*(name)))
 
 // calloc and assign array
 #define callocAArray(name, count) name = calloc(count,  sizeof(*(name)))
 
 // realloc array
 #define reallocArray(name, count) realloc(name, (count) * sizeof(*(name)))
 
 /**
  * slice - dynamic array in one chunk of memory (similar to vector and slab below)
  *
  * This is a simple dynamic array holding element count and the data
  *
  * this type of array has a dynamic element count
  * pushing elements into the array increases the element count
  * poping elements only decreases the element count, call sliceFit to realloc the slice
  *
  * no sanity checks are done
  *
  * the prefix is slice
  *
  * Usage:
  *
  * to declare a slice:
  *
  * sliceT(typeName, type);
  *
  * typeName slce;
  *
  * sliceInit(&slce);
  * or
  * sliceInitCount(&slce, 17);
  *
  * sliceAppend(&slce, value);
  *
  * // get an element
  * int a                = sliceAt(&slce, 0);
  *
  * set
  * sliceAt(&slce, 1) = 3;
  *
  * sliceFree(&slce);
  *
  * Slice variables:
  * slce.array:    elements
  * slce.count:    current element count
  *
  * Note: some functions are macros to be able to have structs as element and
  *       access the struct members directly, for example:
  *         sliceLast(chan).a = 0;
  */
 
 /** number of elements added by sliceAlloc */
 #define sliceSz 1
 
 /**
  * declares type for slice
  *
  * \param
  * typeName slice type name
  * \param
  * element type of elements (int, struct, pointer...)
  */
 #define sliceT(typeName, elementType)\
   typedef struct {\
     size_t count;\
     elementType *array;\
   } typeName
 
 #define createSlice(typeName, name) ;typeName name; sliceInit(&name)
 
 #define createSliceCount(typeName, name, count) ;typeName name; sliceInitCount(&name, count)
 
 #define createSliceClearCount(typeName, name, count) ;typeName name; sliceCalloc(&name, count)
 
 #define createAllocateSlice(typeName, name) ;typeName *name = calloc(1, sizeof(typeName))
 
 #define createAllocateSliceCount(typeName, name, count) ;typeName *name = calloc(1, sizeof(typeName)); sliceInitCount(name, count)
 
 #define createAllocateSliceClearCount(typeName, name, count) ;typeName *name = calloc(1, sizeof(typeName)); sliceCalloc(name, count)
 
 #define sliceTerminate(name) if (name) sliceFree(name);free(name)
 
 /**
  * initialize empty slice
  *
  * \param
  * name variable name for slice
  */
 #define sliceInit(name) do{\
     (name)->array    = NULL;\
     (name)->count    = 0;\
   } while(0)
 
 /**
  * initialize slice and count
  *
  * \param
  * name variable name for slice
  * \param
  * count initial element count for name type
  */
 #define sliceInitCount(name, countInt) do{\
     var UNIQVAR(c)   = countInt;\
     /* TODO check if countInt is 0 then +1 */\
     (name)->array    = malloc(UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count    = UNIQVAR(c);\
   } while(0)
 
 /**
  * initialize slice and count and set slice data to 0
  *
  * \param
  * name variable name for slice
  * \param
  * count initial element count for name type
  */
 #define sliceCalloc(name, countInt) do{\
     var UNIQVAR(c)   = countInt;\
     (name)->array    = calloc(UNIQVAR(c), sizeof (name)->array[0]);\
     (name)->count    = 0;\
   } while(0)
 
 /**
  * resize slice (even empty slices)
  */
 #define sliceResize(name, countInt) do{\
   var UNIQVAR(c) = countInt;\
   if ((name)->array) {\
     /* realloc */\
     (name)->array = realloc((name)->array, sizeof((name)->array[0]) * UNIQVAR(c));\
   }\
   else {\
     /* was empty */\
     (name)->array = malloc(sizeof((name)->array[0]) * UNIQVAR(c));\
   }\
   /* element count when shrinking */\
   if (UNIQVAR(c) < (name)->count) (name)->count = UNIQVAR(c);\
   } while(0)
 
 /**
  * resize slice and clear the new elements with memset
  * even empty slices can be resized and cleared
  */
 #define sliceClearResize(name, countInt) do{\
   var UNIQVAR(c) = countInt;\
   if ((name)->array) {\
     /* realloc */\
     (name)->array = realloc((name)->array, sizeof((name)->array[0]) * UNIQVAR(c));\
     if ((name)->count < UNIQVAR(c)) {\
       /* there are new elements */\
       memset(&(name)->array[(name)->count], 0, (UNIQVAR(c) - (name)->count) * sizeof (name)->array[0]);\
     }\
   }\
   else {\
     /* was empty */\
     (name)->array = calloc(UNIQVAR(c), sizeof((name)->array[0]));\
   }\
   /* element count when shrinking */\
   if (UNIQVAR(c) < (name)->count) (name)->count = UNIQVAR(c);\
   } while(0)
 
 /**
  * free the internal buffers
  *
  * \param
  * name slice
  */
 #define sliceFree(name) free((name)->array)
 
 /**
  * element type in slice
  */
 #define sliceElemType(name) typeof((name)->array[0])
 
 /**
  * element pointer type in slice
  */
 #define sliceElemPtrType(name) typeof(&(name)->array[0])
 
 /**
  * duplicate slice
  */
 #define sliceDup(name) ({\
     typeof(*(name)) dest;\
     sliceInitCount(&dest, (name)->count);\
     if ((name)->array) {\
       memcpy(dest.array, (name)->array, (name)->count * sizeof (name)->array[0]);\
       dest.count = (name)->count;\
     }\
     /* return */ dest;\
   })
 
 /**
  * assign slice from to slice to
  * the data is shared between slice from and slice to
  * the counts are not shared
  *
  * NO need for this macro, do like this:
  * *to = *from;
  */
 /* #define sliceAgn(to, from) do{\
     (to)->count = (from)->count;\
     (to)->array = (from)->array;\
   } while(0) */
 
 /**
  * declare dest slice and duplicate slice
  */
 #define sliceCreateNDup(name, dest) ;typeof(*(name)) dest; sliceInitCount(&dest, (name)->count); if ((name)->array) { memcpy(dest.array, (name)->array, (name)->count * sizeof (name)->array[0]); dest.count = (name)->count;}
 
 /**
  * duplicate slice to already declared dest slice
  */
 #define sliceBDup(name, dest) do{\
   var UNIQVAR(dst) = dest;\
   sliceResize(UNIQVAR(dst), (name)->count);\
   if ((name)->array) {\
     memcpy(UNIQVAR(dst)->array, (name)->array, (name)->count * sizeof (name)->array[0]);\
     UNIQVAR(dst)->count = (name)->count;\
   }\
   } while(0)
 
 
 /**
  * direct access to underlying array
  */
 #define sliceData(name) (name)->array
 
 /**
  * copy data from array to slice
  */
 #define sliceFrom(name, arrayIn, countInt) do{\
     var UNIQVAR(c) = countInt;\
     var UNIQVAR(a) = arrayIn;\
     if (sizeof((name)->array[0]) == sizeof(*(UNIQVAR(a)))) {\
       sliceResize(name, UNIQVAR(c));\
       memcpy((name)->array, UNIQVAR(a), UNIQVAR(c) * sizeof UNIQVAR(a)[0]);\
       (name)->count = UNIQVAR(c);\
     }\
   } while(0)
 
 /**
  * mirror a range in a slice
  * the data is not copied to dest slice, to copy data see sliceCopy or sliceBCopy
  */
 #define sliceMirror(name, start, end) ({\
   var UNIQVAR(strt) = start;\
   typeof(*(name)) UNIQVAR(r);\
   UNIQVAR(r).array = slicePtr(name, UNIQVAR(strt));\
   UNIQVAR(r).count = end - UNIQVAR(strt);\
   UNIQVAR(r);\
   })
 
 /**
  * mirror a range in a slice
  * the data is not copied to dest slice, to copy data see sliceCopy or sliceBCopy
  *
  * name can be slice, vector or slab
  * dest must be slice
  */
 #define sliceBMirror(name, dest, start, end) do{\
   var UNIQVAR(strt)   = start;\
   var UNIQVAR(dst)    = dest;\
   UNIQVAR(dst)->array = slicePtr(name, UNIQVAR(strt));\
   UNIQVAR(dst)->count = end - UNIQVAR(strt);\
   } while(0)
 
 /**
  * mirror from array to slice
  * the data is not copied to dest slice, to copy data see sliceCopy or sliceBCopy
  */
 #define sliceMirrorFrom(name, array, countInt) do{\
   var UNIQVAR(strt) = start;\
   (name)->array     = array;\
   (name)->count     = countInt;\
   } while(0)
 
 
 /**
  * set 0 in slice elements
  * count is unchanged
  */
 #define sliceClear(name) do{\
     if ((name)->array)\
       memset((name)->array, 0, (name)->count * sizeof (name)->array[0]);\
   } while(0)
 
 #define sliceClearRange(name, start, end) do{\
     if ((name)->array)\
       memset((name)->array + start, 0, (end-start) * sizeof (name)->array[0]);\
   } while(0)
 
 /**
  * Empty slice
  * Set count to 0
  * Allocated buffers in the slice must be freed before running sliceEmpty
  */
 #define sliceEmpty(name) (name)->count = 0
 
 /**
  * is slice Empty
  */
 #define sliceIsEmpty(name) ((name)->count == 0 || !(name)->array)
 
 /**
  * realloc slice to count
  */
 #define sliceFit(name) do{\
     sliceResize(name, (name)->count);\
   } while(0)
 
 /**
  * return element count
  */
 #define sliceCount(name) (name)->count
 
 /**
  * size of slice element
  */
 #define sliceElemSize(name) sizeof((name)->array[0])
 
 /**
  * allocate an element
  * only when the slice is full
  */
 #define sliceAlloc(name) do{\
     if (!(name)->array) {\
       (name)->array    = malloc(sliceSz * sizeof (name)->array[0]);\
     }\
     else {\
       (name)->array    = realloc((name)->array, ((name)->count + sliceSz) * sizeof (name)->array[0]);\
     }\
   } while(0)
 
 /**
  * clear (set 0) in element at index
  */
 #define sliceClearElem(name, index) memset(&(name)->array[index], 0, sizeof (name)->array[0])
 
 /**
  * push element and expand the slice
  * no data (random) is set in the new element
  *
  * \param
  * name slice
  */
 #define slicePush(name) do {\
     sliceAlloc(name);\
     (name)->count++;\
   } while(0)
 
 /**
  * append element and expand the slice
  *
  * \param
  * name slice
  * \param
  * v element to push
  */
 #define sliceAppend(name, v) do{\
     slicePush(name);\
     sliceLast(name) = v;\
   } while(0)
 
 
 /**
  * push element and expand the slice
  * the new element is cleared
  *
  * \param
  * name slice
  */
 #define sliceClearPush(name) do{\
     slicePush(name);\
     sliceClearElem(name, (name)->count - 1);\
   } while(0)
 
 /**
  * pop element
  * the element count is decreased
  *
  * NOTE: using comma operator to avoid warning
  * warning: operation on ‘b.head’ may be undefined [-Wsequence-point]
  *
  *
  * \param
  * name slice
  */
 #define slicePop(name) ((name)->count--, (name)->array[(name)->count])
 
 /**
  * delete the last element
  * useful for avoiding warning: right-hand operand of comma expression has no effect
  * when the poped value is not used
  */
 #define sliceDelLast(name) ((name)->count--)
 
 /**
  * set value at index and clearResize slice when index is outside slice count
  */
 #define sliceSet(name, index, v) do{\
     var UNIQVAR(idx) = index;\
     if (UNIQVAR(idx) >= (name)->count) {\
       /* clear and resize */\
       sliceClearResize(name, UNIQVAR(idx)+1);\
     }\
     sliceAt(name, UNIQVAR(idx)) = v;\
   } while(0)
 
 /**
  * get / set element at index
  *
  * \param
  * name slice
  * \param
  * index index in array
  */
 #define sliceAt(name, index) ((name)->array[index])
 
 /**
  * get pointer to element at index
  *
  * \param
  * name slice
  * \param
  * index index in array
  */
 #define slicePtr(name, index) ((name)->array + index)
 
 /**
  * last element
  *
  * \param
  * name slice
  */
 #define sliceLast(name) ((name)->array[(name)->count-1])
 
 /**
  * pointer to last element
  *
  * \param
  * name slice
  */
 #define sliceLastPtr(name) ((name)->array + (name)->count - 1)
 
 /**
  * index of last element
  */
 #define sliceLastIndex(name) ((name)->count - 1)
 
 
 /**
  * first element
  *
  * \param
  * name slice
  */
 #define sliceFirst(name) ((name)->array[0])
 
 
 /**
  * write the slice content to filename file
  * No NULL checks are done on the parameters
  *
  * \param
  *    filename file name string
  */
 #define sliceWriteFilename(name, filename) do {\
     FILE *UNIQVAR(f) = fopen(filename, "w");\
     if (UNIQVAR(f)) {\
       fwrite((name)->array, sizeof((name)->array[0]), sliceCount(name), UNIQVAR(f));\
       fclose(UNIQVAR(f));\
     }\
   } while(0)
 
 /**
  * write the slice content to disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define sliceWrite(name, file) fwrite((name)->array, sizeof((name)->array[0]), sliceCount(name), file)
 
 /**
  * read a slice from filename file
  * No NULL checks are done on the parameters
  *
  * \param
  * filename file name string
  */
 #define sliceReadFilename(name, filename) do {\
     if (fileExists(filename)) {\
       size_t UNIQVAR(sz) = fileSize(filename);\
       FILE *UNIQVAR(f) = fopen(filename, "r");\
       if (UNIQVAR(f)) {\
         range(UNIQVAR(i), UNIQVAR(sz)/sizeof((name)->array[0])) {\
           slicePush(name);\
           fread(sliceLastPtr(name), 1, sizeof((name)->array[0]), UNIQVAR(f));\
         }\
         fclose(UNIQVAR(f));\
       }\
     }\
   } while(0)
 
 /**
  * read a slice from disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define sliceRead(name, file) do {\
     fseek(file, 0 , SEEK_END);\
     size_t UNIQVAR(sz) = ftell(file);\
     fseek(file, 0 , SEEK_SET);\
     range(UNIQVAR(i), UNIQVAR(sz)/sizeof((name)->array[0])) {\
       slicePush(name);\
       fread(sliceLastPtr(name), 1, sizeof((name)->array[0]), file);\
     }\
   } while(0)
 
 
 /**
  * loop index on slice elements
  *
  * For example:
  * forEachV(vec, i) {
  *   sliceAt(vec, i) = 0;
  * }
  */
 #define forEachSc(name, index) range(index, (name)->count)
 
 /**
  * loop on slice elements
  * element is a pointer to a value in the array
  *
  * sliceForEach(&slc, e) {
  *    e->x = 0;
  * }
  */
 #define sliceForEach(name, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
   for (sliceElemPtrType(name) element = slicePtr(name, 0) ; UNIQVAR(libsheepyInternalIndex) < (name)->count ; UNIQVAR(libsheepyInternalIndex)++, element = slicePtr(name, UNIQVAR(libsheepyInternalIndex)))
 
 /**
  * enumerate slice elements
  * index is the position of the element in the array
  * index is declared as size_t and is available after the loop
  * element is a pointer to a value in the array
  *
  * sliceEnumerate(&slc, i, e) {
  *    e->x = 0;
  *    printf("sliceEnumerate %d\n", i);
  * }
  */
 #define sliceEnumerate(name, index, element) \
   ; size_t index = 0 ; \
   for (sliceElemPtrType(name) element = slicePtr(name, 0) ; index < (name)->count ; index++, element = slicePtr(name, index))
 
 /**
  * insert an element at index
  * the data is moved to create space for the new element
  * to set data at the new element, use sliceAt(name, index) = value;
  */
 #define sliceInject(name, index) do {\
   var UNIQVAR(idx) = index;\
   slicePush(name);\
   if (index < sliceCount(name)) {\
       memmove(slicePtr(name, UNIQVAR(idx) +1), slicePtr(name, UNIQVAR(idx)), ((name)->count - UNIQVAR(idx)-1) * sizeof (name)->array[0]);\
     }\
   } while(0)
 
 /**
  * prepend element
  *
  * \param
  * name slice
  * \param
  * v element to prepend
  */
 #define slicePrepend(name, v) do {\
     sliceInject(name, 0);\
     sliceAt(name, 0) = v;\
   } while(0)
 
 /**
  * dequeue element
  *
  * \param
  * name slice
  */
 #define sliceDequeue(name) ({\
     var r = sliceAt(name, 0);\
     sliceDelFirst(name);\
     /* return */r;\
   })
 
 /**
  * delete first element in slice
  * the data is moved when count > 1
  */
 #define sliceDelFirst(name) do {\
     if ((name)->count) {\
       if ((name)->count > 1) {\
         /* move elements */\
         memcpy((name)->array, (name)->array +1 , ((name)->count - 1) * sizeof (name)->array[0]);\
       }\
       (name)->count--;\
     }\
   } while(0)
 
 
 /**
  * delete an element in slice
  * the data is moved when index < (count-1)
  * when index = count -1, the last element is deleted and no data is moved
  */
 #define sliceDelElem(name, index) do {\
   var UNIQVAR(idx) = index;\
   if ((size_t)UNIQVAR(idx) < (size_t)sliceLastIndex(name)) {\
     /* move elements */\
     memmove(slicePtr(name, UNIQVAR(idx)), slicePtr(name, UNIQVAR(idx) +1), ((name)->count - (UNIQVAR(idx) +1)) * sizeof (name)->array[0]);\
   }\
   (name)->count--;\
   } while(0)
 
 /**
  * delete range in slice
  * start must be between 0 and last index
  * end must be between 1 and count
  */
 #define sliceDel(name, start, end) do {\
   var UNIQVAR(strt) = start;\
   var UNIQVAR(ed)   = end;\
   if (UNIQVAR(ed) < (name)->count and UNIQVAR(strt) < UNIQVAR(ed)) {\
     /* move elements */\
     memmove(slicePtr(name, UNIQVAR(strt)), slicePtr(name, UNIQVAR(ed)), ((name)->count - UNIQVAR(ed)) * sizeof (name)->array[0]);\
   }\
   (name)->count -= UNIQVAR(ed) - UNIQVAR(strt);\
   } while(0)
 
 /**
  * append slice to slice name
  * the data is copied
  */
 #define sliceVAppend(name, slice) do {\
   var UNIQVAR(vec) = slice;\
   if (sizeof((name)->array[0]) == sizeof((UNIQVAR(vec))->array[0])) {\
     sliceResize(name, (name)->count + (UNIQVAR(vec))->count);\
     memmove((name)->array + (name)->count, (UNIQVAR(vec))->array, (UNIQVAR(vec))->count * sizeof (name)->array[0]);\
     (name)->count += (UNIQVAR(vec))->count;\
   }\
   } while(0)
 
 /**
  * append array to slice
  * the data is copied
  */
 #define sliceAppendFrom(name, array, countInt) do {\
   var UNIQVAR(c) = countInt;\
   var UNIQVAR(a) = array;\
   if (sizeof((name)->array[0]) == sizeof(*(UNIQVAR(a)))) {\
     sliceResize(name, (name)->count + UNIQVAR(c));\
     memmove((name)->array + (name)->count, UNIQVAR(a), UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(c);\
   }\
   } while(0)
 
 /**
  * prepend slice to slice name
  * the data in slice name is moved and
  * the data in slice is copied to slice name
  */
 #define sliceVPrepend(name, slice) do {\
   var UNIQVAR(vec) = slice;\
   if (sizeof((name)->array[0]) == sizeof((UNIQVAR(vec))->array[0])) {\
     sliceResize(name, (name)->count + (UNIQVAR(vec))->count);\
     memmove((name)->array + (UNIQVAR(vec))->count, (name)->array, (name)->count * sizeof (name)->array[0]);\
     memmove((name)->array, (UNIQVAR(vec))->array, (UNIQVAR(vec))->count * sizeof (name)->array[0]);\
     (name)->count += (UNIQVAR(vec))->count;\
   }\
   } while(0)
 
 /**
  * prepend array to slice
  * the data in slice is moved and
  * the data in array is copied to slice
  */
 #define slicePrependFrom(name, array, countInt) do {\
   var UNIQVAR(c) = countInt;\
   var UNIQVAR(a) = array;\
   if (sizeof((name)->array[0]) == sizeof(*(UNIQVAR(a)))) {\
     sliceResize(name, (name)->count + UNIQVAR(c));\
     memmove((name)->array + UNIQVAR(c), (name)->array, (name)->count * sizeof (name)->array[0]);\
     memmove((name)->array, UNIQVAR(a), UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(c);\
   }\
   } while(0);
 
 /**
  * insert slice at position index
  * the data in slice name is moved and
  * the data in slice is copied to slice name
  */
 #define sliceInsert(name, index, slice) do {\
   var UNIQVAR(idx) = index;\
   var UNIQVAR(vec) = slice;\
   if (UNIQVAR(idx) == (name)->count) {\
     sliceAppend(name, UNIQVAR(vec));\
   }\
   else if (sizeof((name)->array[0]) == sizeof((UNIQVAR(vec))->array[0])) {\
     sliceResize(name, (name)->count + (UNIQVAR(vec))->count);\
     memmove((name)->array + UNIQVAR(idx) + (UNIQVAR(vec))->count, (name)->array + UNIQVAR(idx), ((name)->count - UNIQVAR(idx)) * sizeof (name)->array[0]);\
     memmove((name)->array + UNIQVAR(idx), (UNIQVAR(vec))->array, (UNIQVAR(vec))->count * sizeof (name)->array[0]);\
     (name)->count += (UNIQVAR(vec))->count;\
   }\
   } while(0)
 
 /**
  * insert array at position index
  * the data in slice is moved and
  * the data in array is copied to slice
  */
 #define sliceInsertFrom(name, index, array, countInt) do {\
   var UNIQVAR(idx) = index;\
   var UNIQVAR(c)   = countInt;\
   var UNIQVAR(a)   = array;\
   if (UNIQVAR(idx) == (name)->count) {\
     sliceAppendFrom(name, UNIQVAR(a), UNIQVAR(c));\
   }\
   else if (sizeof((name)->array[0]) == sizeof(UNIQVAR(a)[0])) {\
     sliceResize(name, (name)->count + UNIQVAR(c));\
     memmove((name)->array + UNIQVAR(idx) + UNIQVAR(c), (name)->array + UNIQVAR(idx), ((name)->count - UNIQVAR(idx)) * sizeof (name)->array[0]);\
     memmove((name)->array + UNIQVAR(idx), UNIQVAR(a), UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(c);\
   }\
   } while(0)
 
 /**
  * slice slice, keep only elements between start and end
  * start must be between 0 and last index
  * end must be between 1 and count
  * the slice is returned
  */
 #define sliceSlice(name, start, end) ({\
   var UNIQVAR(strt) = start;\
   var UNIQVAR(ed)   = end;\
   if (UNIQVAR(strt))\
     memmove((name)->array, (name)->array + UNIQVAR(strt), (UNIQVAR(ed) - UNIQVAR(strt)) * sizeof (name)->array[0]);\
   (name)->count = UNIQVAR(ed) - UNIQVAR(strt);\
   name;\
   })
 
 /**
  * copy slice elements between start and end to a new slice
  * start must be between 0 and last index
  * end must be between 1 and count
  * the new slice is returned and must be freed with sliceTerminate
  */
 #define sliceCopy(name, start, end) ({\
   var UNIQVAR(strt) = start;\
   var UNIQVAR(ed)   = end;\
   createAllocateSliceCount(typeof(*(name)),UNIQVAR(r), UNIQVAR(ed) - UNIQVAR(strt));\
   memmove(UNIQVAR(r)->array, (name)->array + UNIQVAR(strt), (UNIQVAR(ed) - UNIQVAR(strt)) * sizeof (name)->array[0]);\
   UNIQVAR(r)->count = UNIQVAR(ed) - UNIQVAR(strt);\
   UNIQVAR(r);\
   })
 
 /**
  * copy slice elements between start and end to the dest slice
  * start must be between 0 and last index
  * end must be between 1 and count
  */
 #define sliceBCopy(name, dest, start, end) do{\
   if (sizeof((name)->array[0]) == sizeof((dest)->array[0])) {\
     var UNIQVAR(strt) = start;\
     var UNIQVAR(ed)   = end;\
     sliceResize(dest, UNIQVAR(ed) - UNIQVAR(strt));\
     memmove((dest)->array, (name)->array + UNIQVAR(strt), (UNIQVAR(ed) - UNIQVAR(strt)) * sizeof (name)->array[0]);\
     (dest)->count = UNIQVAR(ed) - UNIQVAR(strt);\
   }\
   } while(0)
 
 /**
  * sort the slice
  * the compareFunction must prototype of type:
  * int cmp(const void * a, const void * b);
  * the results of the compareFunction should be:
  * <0 when a < b
  * 0  when a = b
  * >0 when a > b
  */
 #define sliceSort(name, compareFunction) do{ \
   qsort((name)->array, sizeof (name)->array[0], compareFunction);\
   } while(0)
 
 /**
  * return true when slice name is equal to slice
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  */
 #define sliceEq(name, slice, eqFunction) ({\
     var UNIQVAR(vec) = slice;\
     bool UNIQVAR(r)  = true;\
     if (sizeof((name)->array[0]) == sizeof((UNIQVAR(vec))->array[0]) and (name)->count == UNIQVAR(vec)->count) {\
       forEachV(name, UNIQVAR(idx)) {\
         if (not eqFunction(sliceAt(name,UNIQVAR(idx)), sliceAt(UNIQVAR(vec),UNIQVAR(idx)))) {\
           UNIQVAR(r) = false;\
           break;\
         }\
       }\
     }\
     else UNIQVAR(r) = false;\
     UNIQVAR(r);\
   })
 
 /**
  * return true when slice has value
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  */
 #define sliceHas(name, value, eqFunction) ({\
     var UNIQVAR(v)  = value;\
     bool UNIQVAR(r) = false;\
     forEachV(name, UNIQVAR(idx)) {\
         if (eqFunction(sliceAt(name,UNIQVAR(idx)), UNIQVAR(v))) {\
           UNIQVAR(r) = true;\
           break;\
         }\
     }\
     UNIQVAR(r);\
   })
 
 /**
  * return index (ssize_t) of value in slice
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  *
  * return value is -1 when value is not found
  */
 #define sliceIndexOf(name, value, eqFunction) ({\
     var UNIQVAR(v)     = value;\
     ssize_t UNIQVAR(r) = -1;\
     forEachV(name, UNIQVAR(idx)) {\
         if (eqFunction(sliceAt(name,UNIQVAR(idx)), UNIQVAR(v))) {\
           UNIQVAR(r) = UNIQVAR(idx);\
           break;\
         }\
     }\
     UNIQVAR(r);\
   })
 
 /**
  * binary search value in slice
  *
  * efficiently finds the index of value in slice
  * the slice has to be sorted before calling sliceBinarySearch
  *
  * less is a macro taking an index and the search value returning 1 when sliceAt(name,index) is less than value:
  * #define less(index, value) sliceAt(name, index) < value
  *
  * equal is a macro returning 1 when sliceAt(name,index) is equal to value:
  * #define equal(index, value) sliceAt(name,index) == value
  *
  * return value is -1 when value is not found
  */
 #define sliceBinarySearch(name, value, less, equal) ({\
     var UNIQVAR(v) = value;\
     ssize_t UNIQVAR(r);\
     BSEARCH(UNIQVAR(r), UNIQVAR(v), (name)->count, less, equal);\
     UNIQVAR(r);\
   })
 
 /**
  * Uniquify elements in slice
  * each elements are unique in the slice
  *
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  */
 #define sliceUniq(name, eqFunction) do{\
   if ((name)->count > 1) {\
     /* more than 1 element in slice, it is possible to have non unique elements */\
     /* where to copy unique elements */\
     size_t UNIQVAR(addIdx) = 0;\
     /* scan all elements */\
     forEachV(name, UNIQVAR(idx)) {\
       /* whether [idx+1, count] has an element equal the one at idx */\
       bool UNIQVAR(has) = false;\
       /* last element is always unique */\
       if (UNIQVAR(idx) < (name)->count) {\
         rangeFrom(UNIQVAR(i), UNIQVAR(idx)+1, (name)->count) {\
           if (eqFunction(sliceAt(name,UNIQVAR(i)), sliceAt(name,UNIQVAR(idx)))) {\
             UNIQVAR(r) = true;\
             break;\
           }\
         }\
       }\
       /* if [idx+1, count] doesnt have an equal element then the element at idx is unique */\
       if (not UNIQVAR(has)) {\
         /* copy element to addIdx when addIdx < idx */\
         /* when addIdx == idx there is no need to copy the element */\
         if (UNIQVAR(addIdx) < UNIQVAR(idx)) {\
           sliceAt(name,UNIQVAR(addIdx)) = sliceAt(name,UNIQVAR(idx));\
         }\
         UNIQVAR(addIdx)++;\
       }\
     }\
     /* set new count */\
     (name)->count = UNIQVAR(addIdx);\
   }\
   } while(0)
 
 /*
  * end slice
  */
 
 /**
  * staticSlice - static array with element count
  *
  * pushing elements into the array increases the element count
  * poping elements only decreases the element count
  *
  * no sanity checks are done
  *
  * the prefix is staticSlice
  *
  * Usage:
  *
  * to declare a staticSlice:
  *
  * staticSliceT(typeName, type, 10);
  *
  * typeName slce;
  *
  * staticSliceInit(&slce);
  *
  * staticSliceAppend(&slce, value);
  *
  * // get an element
  * int a                = staticSliceAt(&slce, 0);
  *
  * set
  * staticSliceAt(&slce, 1) = 3;
  *
  * staticSliceFree(&slce);
  *
  * StaticSlice variables:
  * slce.array:    elements
  * slce.count:    current element count
  *
  * Note: some functions are macros to be able to have structs as element and
  *       access the struct members directly, for example:
  *         staticSliceLast(chan).a = 0;
  */
 
 /**
  * declares type for staticSlice
  *
  * \param
  * typeName staticSlice type name
  * \param
  * element type of elements (int, struct, pointer...)
  * \param
  * MAXCOUNT array/ring buffer size
  */
 #define staticSliceT(typeName, elementType, MAXCOUNT)\
   typedef struct {\
     size_t count;\
     elementType array[MAXCOUNT];\
   } typeName
 
 #define createStaticSlice(typeName, name) ;typeName name; staticSliceInit(&name)
 
 /**
  * initialize empty staticSlice
  *
  * \param
  * name variable name for staticSlice
  */
 #define staticSliceInit(name) do{\
     (name)->count    = 0;\
   } while(0)
 
 /**
  * element type in slice
  */
 #define staticSliceElemType(name) typeof((name)->array[0])
 
 /**
  * element pointer type in slice
  */
 #define staticSliceElemPtrType(name) typeof(&(name)->array[0])
 
 /**
  * duplicate staticSlice to already declared dest staticSlice
  */
 #define staticSliceBDup(name, dest) do{\
   var UNIQVAR(dst) = dest;\
   if ((name)->count <= ARRAY_SIZE(UNIQVAR(dst)->array)) {\
     memcpy(UNIQVAR(dst)->array, (name)->array, (name)->count * sizeof (name)->array[0]);\
     UNIQVAR(dst)->count = (name)->count;\
   }\
   } while(0)
 
 
 /**
  * direct access to underlying array
  */
 #define staticSliceData sliceData
 
 /**
  * copy data from array to staticSlice
  */
 #define staticSliceFrom(name, arrayIn, countInt) do{\
     var UNIQVAR(c) = countInt;\
     var UNIQVAR(a) = arrayIn;\
     if (sizeof((name)->array[0]) == sizeof(*(UNIQVAR(a))) /* slice compatibility and UNIQVAR(c) <= ARRAY_SIZE((name)->array)*/) {\
       memcpy((name)->array, UNIQVAR(a), UNIQVAR(c) * sizeof UNIQVAR(a)[0]);\
       (name)->count = UNIQVAR(c);\
     }\
   } while(0)
 
 
 /**
  * set 0 in staticSlice elements
  * count is unchanged
  */
 #define staticSliceClear(name) memset((name)->array, 0, (name)->count * sizeof (name)->array[0])
 
 #define staticSliceClearRange(name, start, end) memset((name)->array + start, 0, (end-start) * sizeof (name)->array[0])
 
 /**
  * Empty staticSlice
  * Set count to 0
  * Allocated buffers in the staticSlice must be freed before running staticSliceEmpty
  */
 #define staticSliceEmpty sliceEmpty
 
 /**
  * is staticSlice Empty
  */
 #define staticSliceIsEmpty(name) ((name)->count == 0)
 
 /**
  * return element count
  */
 #define staticSliceCount sliceCount
 
 /**
  * size of staticSlice element
  */
 #define staticSliceElemSize sliceElemSize
 
 /**
  * clear (set 0) in element at index
  */
 #define staticSliceClearElem sliceClearElem
 
 /**
  * push element and expand the staticSlice
  * no data (random) is set in the new element
  *
  * \param
  * name staticSlice
  */
 #define staticSlicePush(name)  (name)->count++
 
 /**
  * append element and expand the staticSlice
  *
  * \param
  * name staticSlice
  * \param
  * v element to push
  */
 #define staticSliceAppend(name, v) do{\
     staticSlicePush(name);\
     staticSliceLast(name) = v;\
   } while(0)
 
 
 /**
  * push element and expand the staticSlice
  * the new element is cleared
  *
  * \param
  * name staticSlice
  */
 #define staticSliceClearPush(name) do{\
     staticSlicePush(name);\
     staticSliceClearElem(name, (name)->count - 1);\
   } while(0)
 
 /**
  * pop element
  * the element count is decreased
  *
  * NOTE: using comma operator to avoid warning
  * warning: operation on ‘b.head’ may be undefined [-Wsequence-point]
  *
  *
  * \param
  * name staticSlice
  */
 #define staticSlicePop slicePop
 
 /**
  * delete the last element
  * useful for avoiding warning: right-hand operand of comma expression has no effect
  * when the poped value is not used
  */
 #define staticSliceDelLast sliceDelLast
 
 /**
  * get / set element at index
  *
  * \param
  * name staticSlice
  * \param
  * index index in array
  */
 #define staticSliceAt sliceAt
 
 /**
  * get pointer to element at index
  *
  * \param
  * name staticSlice
  * \param
  * index index in array
  */
 #define staticSlicePtr slicePtr
 
 /**
  * last element
  *
  * \param
  * name staticSlice
  */
 #define staticSliceLast sliceLast
 
 /**
  * pointer to last element
  *
  * \param
  * name staticSlice
  */
 #define staticSliceLastPtr sliceLastPtr
 
 /**
  * index of last element
  */
 #define staticSliceLastIndex sliceLastIndex
 
 
 /**
  * first element
  *
  * \param
  * name staticSlice
  */
 #define staticSliceFirst sliceFirst
 
 
 /**
  * write the staticSlice content to filename file
  * No NULL checks are done on the parameters
  *
  * \param
  *    filename file name string
  */
 #define staticSliceWriteFilename sliceWriteFilename
 
 /**
  * write the staticSlice content to disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define staticSliceWrite sliceWrite
 
 /**
  * read a staticSlice from filename file
  * No NULL checks are done on the parameters
  *
  * \param
  * filename file name string
  */
 #define staticSliceReadFilename(name, filename) do {\
     if (fileExists(filename)) {\
       size_t UNIQVAR(sz) = fileSize(filename);\
       FILE *UNIQVAR(f) = fopen(filename, "r");\
       if (UNIQVAR(f)) {\
         range(UNIQVAR(i), UNIQVAR(sz)/sizeof((name)->array[0])) {\
           staticSlicePush(name);\
           fread(staticSliceLastPtr(name), 1, sizeof((name)->array[0]), UNIQVAR(f));\
         }\
         fclose(UNIQVAR(f));\
       }\
     }\
   } while(0)
 
 /**
  * read a staticSlice from disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define staticSliceRead(name, file) do {\
     fseek(file, 0 , SEEK_END);\
     size_t UNIQVAR(sz) = ftell(file);\
     fseek(file, 0 , SEEK_SET);\
     range(UNIQVAR(i), UNIQVAR(sz)/sizeof((name)->array[0])) {\
       staticSlicePush(name);\
       fread(staticSliceLastPtr(name), 1, sizeof((name)->array[0]), file);\
     }\
   } while(0)
 
 
 /**
  * loop index on staticSlice elements
  *
  * For example:
  * forEachV(vec, i) {
  *   staticSliceAt(vec, i) = 0;
  * }
  */
 #define forEachSSc forEachSc
 
 /**
  * loop on slice elements
  * element is a pointer to a value in the array
  *
  * staticSliceForEach(&slc, e) {
  *    e->x = 0;
  * }
  */
 #define staticSliceForEach(name, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
   for (staticSliceElemPtrType(name) element = staticSlicePtr(name, 0) ; UNIQVAR(libsheepyInternalIndex) < (name)->count ; UNIQVAR(libsheepyInternalIndex)++, element = staticSlicePtr(name, UNIQVAR(libsheepyInternalIndex)))
 
 /**
  * enumerate slice elements
  * index is the position of the element in the array
  * index is declared as size_t and is available after the loop
  * element is a pointer to a value in the array
  *
  * sliceEnumerate(&slc, i, e) {
  *    e->x = 0;
  *    printf("sliceEnumerate %d\n", i);
  * }
  */
 #define staticSliceEnumerate(name, index, element) \
   ; size_t index = 0 ; \
   for (staticSliceElemPtrType(name) element = staticSlicePtr(name, 0) ; index < (name)->count ; index++, element = staticSlicePtr(name, index))
 
 /**
  * insert an element at index
  * the data is moved to create space for the new element
  * to set data at the new element, use staticSliceAt(name, index) = value;
  */
 #define staticSliceInject(name, index) do {\
   var UNIQVAR(idx) = index;\
   staticSlicePush(name);\
   memmove(staticSlicePtr(name, UNIQVAR(idx) +1), staticSlicePtr(name, UNIQVAR(idx)), ((name)->count - UNIQVAR(idx)) * sizeof (name)->array[0]);\
   } while(0)
 
 /**
  * prepend element
  *
  * \param
  * name staticSlice
  * \param
  * v element to prepend
  */
 #define staticSlicePrepend(name, v) do {\
     staticSliceInject(name, 0);\
     staticSliceAt(name, 0) = v;\
   } while(0)
 
 /**
  * dequeue element
  *
  * \param
  * name staticSlice
  */
 #define staticSliceDequeue sliceDequeue
 
 /**
  * delete first element in staticSlice
  * the data is moved when count > 1
  */
 #define staticSliceDelFirst sliceDelFirst
 
 
 /**
  * delete an element in staticSlice
  * the data is moved when index < (count-1)
  * when index = count -1, the last element is deleted and no data is moved
  */
 #define staticSliceDelElem sliceDelElem
 
 /**
  * delete range in staticSlice
  * start must be between 0 and last index
  * end must be between 1 and count
  */
 #define staticSliceDel sliceDel
 
 /**
  * append staticSlice to staticSlice name
  * the data is copied
  */
 #define staticSliceVAppend(name, staticSlice) do {\
   var UNIQVAR(vec) = staticSlice;\
   if (sizeof((name)->array[0]) == sizeof(UNIQVAR(vec)->array[0]) /* slice compatibility and ((name)->count + UNIQVAR(vec)->count) <= ARRAY_SIZE((name)->array)*/) {\
     memcpy((name)->array + (name)->count, UNIQVAR(vec)->array, UNIQVAR(vec)->count * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(vec)->count;\
   }\
   } while(0)
 
 /**
  * append array to staticSlice
  * the data is copied
  */
 #define staticSliceAppendFrom(name, array, countInt) do {\
   var UNIQVAR(c) = countInt;\
   var UNIQVAR(a) = array;\
   if (sizeof((name)->array[0]) == sizeof(*(UNIQVAR(a))) /* slice compatibility and ((name)->count + UNIQVAR(c)) <= ARRAY_SIZE((name)->array)*/) {\
     memcpy((name)->array + (name)->count, UNIQVAR(a), UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(c);\
   }\
   } while(0)
 
 /**
  * prepend staticSlice to staticSlice name
  * the data in staticSlice name is moved and
  * the data in staticSlice is copied to staticSlice name
  */
 #define staticSliceVPrepend(name, staticSlice) do {\
   var UNIQVAR(vec) = staticSlice;\
   if (sizeof((name)->array[0]) == sizeof((UNIQVAR(vec))->array[0]) /* slice compatibility and ((name)->count + UNIQVAR(vec)->count) <= ARRAY_SIZE((name)->array)*/) {\
     memmove((name)->array + (UNIQVAR(vec))->count, (name)->array, (name)->count * sizeof (name)->array[0]);\
     memcpy((name)->array, (UNIQVAR(vec))->array, (UNIQVAR(vec))->count * sizeof (name)->array[0]);\
     (name)->count += (UNIQVAR(vec))->count;\
   }\
   } while(0)
 
 /**
  * prepend array to staticSlice
  * the data in staticSlice is moved and
  * the data in array is copied to staticSlice
  */
 #define staticSlicePrependFrom(name, array, countInt) do {\
   var UNIQVAR(c) = countInt;\
   var UNIQVAR(a) = array;\
   if (sizeof((name)->array[0]) == sizeof(*(UNIQVAR(a))) /* slice compatibility and ((name)->count + UNIQVAR(c)) <= ARRAY_SIZE((name)->array)*/) {\
     staticSliceResize(name, (name)->count + UNIQVAR(c));\
     memmove((name)->array + UNIQVAR(c), (name)->array, (name)->count * sizeof (name)->array[0]);\
     memcpy((name)->array, UNIQVAR(a), UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(c);\
   }\
   } while(0);
 
 /**
  * insert staticSlice at position index
  * the data in staticSlice name is moved and
  * the data in staticSlice is copied to staticSlice name
  */
 #define staticSliceInsert(name, index, staticSlice) do {\
   var UNIQVAR(idx) = index;\
   var UNIQVAR(vec) = staticSlice;\
   if (UNIQVAR(idx) == (name)->count) {\
     staticSliceAppend(name, UNIQVAR(vec));\
   }\
   else if (sizeof((name)->array[0]) == sizeof((UNIQVAR(vec))->array[0]) /* slice compatibility and ((name)->count + UNIQVAR(vec)->count) <= ARRAY_SIZE((name)->array)*/) {\
     memmove((name)->array + UNIQVAR(idx) + (UNIQVAR(vec))->count, (name)->array + UNIQVAR(idx), ((name)->count - UNIQVAR(idx)) * sizeof (name)->array[0]);\
     memcpy((name)->array + UNIQVAR(idx), (UNIQVAR(vec))->array, (UNIQVAR(vec))->count * sizeof (name)->array[0]);\
     (name)->count += (UNIQVAR(vec))->count;\
   }\
   } while(0)
 
 /**
  * insert array at position index
  * the data in staticSlice is moved and
  * the data in array is copied to staticSlice
  */
 #define staticSliceInsertFrom(name, index, array, countInt) do {\
   var UNIQVAR(idx) = index;\
   var UNIQVAR(c)   = countInt;\
   var UNIQVAR(a)   = array;\
   if (UNIQVAR(idx) == (name)->count) {\
     staticSliceAppendFrom(name, UNIQVAR(a), UNIQVAR(c));\
   }\
   else if (sizeof((name)->array[0]) == sizeof(UNIQVAR(a)[0]) /* slice compatibility and ((name)->count + UNIQVAR(c)) <= ARRAY_SIZE((name)->array)*/) {\
     memmove((name)->array + UNIQVAR(idx) + UNIQVAR(c), (name)->array + UNIQVAR(idx), ((name)->count - UNIQVAR(idx)) * sizeof (name)->array[0]);\
     memcpy((name)->array + UNIQVAR(idx), UNIQVAR(a), UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(c);\
   }\
   } while(0)
 
 /**
  * staticSlice staticSlice, keep only elements between start and end
  * start must be between 0 and last index
  * end must be between 1 and count
  * the staticSlice is returned
  */
 #define staticSliceSlice sliceSlice
 
 /**
  * copy staticSlice elements between start and end to the dest staticSlice
  * start must be between 0 and last index
  * end must be between 1 and count
  */
 #define staticSliceBCopy(name, dest, start, end) do{\
   if (sizeof((name)->array[0]) == sizeof((dest)->array[0]) /* slice compatibility and (UNIQVAR(ed) - UNIQVAR(strt)) <= ARRAY_SIZE((dest)->array)*/) {\
     var UNIQVAR(strt) = start;\
     var UNIQVAR(ed)   = end;\
     staticSliceResize(dest, UNIQVAR(ed) - UNIQVAR(strt));\
     memcpy((dest)->array, (name)->array + UNIQVAR(strt), (UNIQVAR(ed) - UNIQVAR(strt)) * sizeof (name)->array[0]);\
     (dest)->count = UNIQVAR(ed) - UNIQVAR(strt);\
   }\
   } while(0)
 
 /**
  * sort the staticSlice
  * the compareFunction must prototype of type:
  * int cmp(const void * a, const void * b);
  * the results of the compareFunction should be:
  * <0 when a < b
  * 0  when a = b
  * >0 when a > b
  */
 #define staticSliceSort sliceSort
 
 /**
  * return true when staticSlice name is equal to staticSlice
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  */
 #define staticSliceEq sliceEq
 
 /**
  * return true when staticSlice has value
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  */
 #define staticSliceHas sliceHas
 
 /**
  * return index (ssize_t) of value in staticSlice
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  *
  * return value is -1 when value is not found
  */
 #define staticSliceIndexOf sliceIndexOf
 
 /**
  * binary search value in staticSlice
  *
  * efficiently finds the index of value in staticSlice
  * the staticSlice has to be sorted before calling staticSliceBinarySearch
  *
  * less is a macro taking an index and the search value returning 1 when staticSliceAt(name,index) is less than value:
  * #define less(index, value) staticSliceAt(name, index) < value
  *
  * equal is a macro returning 1 when staticSliceAt(name,index) is equal to value:
  * #define equal(index, value) staticSliceAt(name,index) == value
  *
  * return value is -1 when value is not found
  */
 #define staticSliceBinarySearch sliceBinarySearch
 
 /**
  * Uniquify elements in staticSlice
  * each elements are unique in the staticSlice
  *
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  */
 #define staticSliceUniq sliceUniq
 
 /*
  * end staticSlice
  */
 
 /**
  * vector - dynamic array in one chunk of memory (similar to slab below)
  *
  * This is a simple dynamic array holding element count, maximum element count and the data
  *
  * vector supports shrinking through vectorResize
  *
  * this type of array has a dynamic element count
  * pushing elements into the array increases the element count
  * poping elements only decreases the element count, call vectorFit to resize the vector
  *
  * no sanity checks are done
  *
  * the prefix is vector
  *
  * Usage:
  *
  * to declare a vector:
  *
  * vectorT(typeName, type);
  *
  * typeName vectr;
  *
  * vectorInit(&vectr);
  * or
  * vectorInitCount(&vectr, 17);
  *
  * vectorAppend(&vectr, value);
  *
  * // get an element
  * int a                = vectorAt(&vectr, 0);
  *
  * set
  * vectorAt(&vectr, 1) = 3;
  *
  * vectorFree(&vectr);
  *
  * Vector variables:
  * vectr.array:    elements
  * vectr.count:    current element count
  * vectr.maxCount: maximum element count allowed
  *
  * Note: some functions are macros to be able to have structs as element and
  *       access the struct members directly, for example:
  *         vectorLast(chan).a = 0;
  */
 
 /** number of elements added by vectorAlloc */
 #define vectorSz 1
 
 /**
  * declares type for vector
  *
  * \param
  * typeName vector type name
  * \param
  * element type of elements (int, struct, pointer...)
  */
 #define vectorT(typeName, elementType)\
   typedef struct {\
     size_t count;\
     size_t maxCount;\
     elementType *array;\
   } typeName
 
 
 #define createVector(typeName, name) ;typeName name; vectorInit(&name)
 
 #define createVectorCount(typeName, name, count) ;typeName name; vectorInitCount(&name, count)
 
 #define createVectorClearCount(typeName, name, count) ;typeName name; vectorCalloc(&name, count)
 
 #define createAllocateVector(typeName, name) ;typeName *name = calloc(1, sizeof(typeName))
 
 #define createAllocateVectorCount(typeName, name, count) ;typeName *name = calloc(1, sizeof(typeName)); vectorInitCount(name, count)
 
 #define createAllocateVectorClearCount(typeName, name, count) ;typeName *name = calloc(1, sizeof(typeName)); vectorCalloc(name, count)
 
 #define vectorTerminate(name) if (name) vectorFree(name);free(name)
 
 /**
  * initialize empty vector
  *
  * \param
  * name variable name for vector
  */
 #define vectorInit(name) do{\
     (name)->array    = NULL;\
     (name)->count    = 0;\
     (name)->maxCount = 0;\
   } while(0)
 
 /**
  * initialize vector and count
  *
  * \param
  * name variable name for vector
  * \param
  * count initial element count for name type
  */
 #define vectorInitCount(name, countInt) do{\
     var UNIQVAR(c)   = countInt;\
     (name)->array    = malloc(UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count    = 0;\
     (name)->maxCount = UNIQVAR(c);\
   } while(0)
 
 /**
  * initialize vector and count and set vector data to 0
  *
  * \param
  * name variable name for vector
  * \param
  * count initial element count for name type
  */
 #define vectorCalloc(name, countInt) do{\
     var UNIQVAR(c)   = countInt;\
     (name)->array    = calloc(UNIQVAR(c), sizeof (name)->array[0]);\
     (name)->count    = 0;\
     (name)->maxCount = UNIQVAR(c);\
   } while(0)
 
 /**
  * resize vector (even empty vectors)
  */
 #define vectorResize(name, countInt) do{\
   var UNIQVAR(c) = countInt;\
   if ((name)->array) {\
     /* realloc */\
     (name)->array = realloc((name)->array, sizeof((name)->array[0]) * UNIQVAR(c));\
   }\
   else {\
     /* was empty */\
     (name)->array = malloc(sizeof((name)->array[0]) * UNIQVAR(c));\
   }\
   /* element count when shrinking */\
   if (UNIQVAR(c) < (name)->count) (name)->count = UNIQVAR(c);\
   (name)->maxCount = UNIQVAR(c);\
   } while(0)
 
 /**
  * resize vector and clear the new elements with memset
  * even empty vectors can be resized and cleared
  */
 #define vectorClearResize(name, countInt) do{\
   var UNIQVAR(c) = countInt;\
   if ((name)->array) {\
     /* realloc */\
     (name)->array = realloc((name)->array, sizeof((name)->array[0]) * UNIQVAR(c));\
     if ((name)->count < UNIQVAR(c)) {\
       /* there are new elements */\
       memset(&(name)->array[(name)->count], 0, (UNIQVAR(c) - (name)->count) * sizeof (name)->array[0]);\
     }\
   }\
   else {\
     /* was empty */\
     (name)->array = calloc(UNIQVAR(c), sizeof((name)->array[0]));\
   }\
   /* element count when shrinking */\
   if (UNIQVAR(c) < (name)->count) (name)->count = UNIQVAR(c);\
   (name)->maxCount = UNIQVAR(c);\
   } while(0)
 
 /**
  * free the internal buffers
  *
  * \param
  * name vector
  */
 #define vectorFree sliceFree
 
 /**
  * element type in vector
  */
 #define vectorElemType(name) typeof((name)->array[0])
 
 /**
  * element pointer type in vector
  */
 #define vectorElemPtrType(name) typeof(&(name)->array[0])
 
 /**
  * duplicate vector
  */
 #define vectorDup(name) ({\
     typeof(*(name)) dest;\
     vectorInitCount(dest, (name)->count);\
     if ((name)->array) {\
       memcpy(dest->array, (name)->array, (name)->count * sizeof (name)->array[0]);\
       dest->count = (name)->count;\
     }\
     /* return */ dest;\
   })
 /**
  * declare dest vector and duplicate vector
  */
 #define vectorCreateNDup(name, dest) ;typeof(*(name)) dest; vectorInitCount(dest, (name)->count); if ((name)->array) { memcpy(dest->array, (name)->array, (name)->count * sizeof (name)->array[0]); dest->count = (name)->count;}
 
 /**
  * duplicate vector to already declared dest vector
  */
 #define vectorBDup(name, dest) do{\
   var UNIQVAR(dst) = dest;\
   vectorResize(UNIQVAR(dst), (name)->count);\
   if ((name)->array) {\
     memcpy(UNIQVAR(dst)->array, (name)->array, (name)->count * sizeof (name)->array[0]);\
     dest->count = (name)->count;\
   }\
   } while(0)
 
 /**
  * direct access to underlying array
  */
 #define vectorData sliceData
 
 /**
  * copy data from array to vector
  */
 #define vectorFrom(name, array, countInt) do{\
     var UNIQVAR(c) = countInt;\
     var UNIQVAR(a) = array;\
     if (sizeof((name)->array[0]) == sizeof(*(UNIQVAR(a)))) {\
       if (UNIQVAR(c) > (name)->maxCount)\
         vectorResize(name, UNIQVAR(c));\
       memcpy((name)->array, UNIQVAR(a), UNIQVAR(c) * sizeof UNIQVAR(a)[0]);\
       (name)->count = UNIQVAR(c);\
     }\
   } while(0)
 
 /**
  * set 0 in vector elements
  * count is unchanged
  */
 #define vectorClear sliceClear
 
 #define vectorClearRange sliceClearRange
 
 /**
  * Empty vector
  * Set count to 0
  * Allocated buffers in the vector must be freed before running vectorEmpty
  */
 #define vectorEmpty sliceEmpty
 
 /**
  * is vector Empty
  */
 #define vectorIsEmpty sliceIsEmpty
 
 /**
  * resize vector from maxCount to count
  */
 #define vectorFit(name) do{\
     if ((name)->maxCount > (name)->count) {\
       vectorResize(name, (name)->count);\
     }\
   } while(0)
 
 /**
  * return element count
  */
 #define vectorCount sliceCount
 
 /**
  * return max element count
  */
 #define vectorMaxCount(name) (name)->maxCount
 
 /**
  * size of vector element
  */
 #define vectorElemSize sliceElemSize
 
 /**
  * allocate an element
  * only when the vector is full
  */
 #define vectorAlloc(name) do{\
     if (!(name)->array) {\
       (name)->array    = malloc(vectorSz * sizeof (name)->array[0]);\
       (name)->maxCount = vectorSz;\
     }\
     else if ((name)->count == (name)->maxCount) {\
       (name)->maxCount += vectorSz;\
       (name)->array     = realloc((name)->array, (name)->maxCount * sizeof (name)->array[0]);\
     }\
   } while(0)
 
 /**
  * clear (set 0) in element at index
  */
 #define vectorClearElem sliceClearElem
 
 /**
  * push element and expand the vector
  * no data (random) is set in the new element
  *
  * \param
  * name vector
  */
 #define vectorPush(name) do {\
     vectorAlloc(name);\
     (name)->count++;\
   } while(0)
 
 /**
  * append element and expand the vector
  *
  * \param
  * name vector
  * \param
  * v element to push
  */
 #define vectorAppend(name, v) do{\
     vectorPush(name);\
     vectorLast(name) = v;\
   } while(0)
 
 
 /**
  * push element and expand the vector
  * the new element is cleared
  *
  * \param
  * name vector
  */
 #define vectorClearPush(name) do{\
     vectorPush(name);\
     vectorClearElem(name, (name)->count - 1);\
   } while(0)
 
 /**
  * pop element
  * the element count is decreased
  *
  * NOTE: using comma operator to avoid warning
  * warning: operation on ‘b.head’ may be undefined [-Wsequence-point]
  *
  *
  * \param
  * name vector
  */
 #define vectorPop slicePop
 
 /**
  * delete the last element
  * useful for avoiding warning: right-hand operand of comma expression has no effect
  * when the poped value is not used
  */
 #define vectorDelLast sliceDelLast
 
 /**
  * push multiple elements at once
  *
  * \param
  * name vector
  * \param
  * countp number of elements to add
  */
 #define vectorPushCount(name, countp) procbegin\
     u32 UNIQVAR(count) = countp;\
     if (((name)->count + UNIQVAR(count)) > (name)->maxCount) {\
             (name)->maxCount += UNIQVAR(count);\
             (name)->array     = realloc((name)->array, (name)->maxCount * sizeof (name)->array[0]);\
           }\
     (name)->count += UNIQVAR(count);\
   procend
 
 
 /**
  * set value at index and clearResize vector when index is outside vector maxCount
  */
 #define vectorSet(name, index, v) do{\
     var UNIQVAR(idx) = index;\
     if (UNIQVAR(idx) >= (name)->count) {\
       /* clear and resize */\
       vectorClearResize(name, UNIQVAR(idx)+1);\
     }\
     vectorAt(name, UNIQVAR(idx)) = v;\
   } while(0)
 
 /**
  * get / set element at index
  *
  * \param
  * name vector
  * \param
  * index index in array
  */
 #define vectorAt sliceAt
 
 /**
  * get pointer to element at index
  *
  * \param
  * name vector
  * \param
  * index index in array
  */
 #define vectorPtr slicePtr
 
 /**
  * last element
  *
  * \param
  * name vector
  */
 #define vectorLast sliceLast
 
 /**
  * pointer to last element
  *
  * \param
  * name vector
  */
 #define vectorLastPtr sliceLastPtr
 
 /**
  * index of last element
  */
 #define vectorLastIndex sliceLastIndex
 
 
 /**
  * first element
  *
  * \param
  * name vector
  */
 #define vectorFirst sliceFirst
 
 
 /**
  * write the vector content to filename file
  * No NULL checks are done on the parameters
  *
  * \param
  *    filename file name string
  */
 #define vectorWriteFilename sliceWriteFilename
 
 /**
  * write the vector content to disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define vectorWrite sliceWrite
 
 /**
  * read a vector from filename file
  * No NULL checks are done on the parameters
  *
  * \param
  * filename file name string
  */
 #define vectorReadFilename(name, filename) do {\
     if (fileExists(filename)) {\
       size_t UNIQVAR(sz) = fileSize(filename);\
       FILE *UNIQVAR(f) = fopen(filename, "r");\
       if (UNIQVAR(f)) {\
         range(UNIQVAR(i), UNIQVAR(sz)/sizeof((name)->array[0])) {\
           vectorPush(name);\
           fread(vectorLastPtr(name), 1, sizeof((name)->array[0]), UNIQVAR(f));\
         }\
         fclose(UNIQVAR(f));\
       }\
     }\
   } while(0)
 
 /**
  * read a vector from disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define vectorRead(name, file) do {\
     fseek(file, 0 , SEEK_END);\
     size_t UNIQVAR(sz) = ftell(file);\
     fseek(file, 0 , SEEK_SET);\
     range(UNIQVAR(i), UNIQVAR(sz)/sizeof((name)->array[0])) {\
       vectorPush(name);\
       fread(vectorLastPtr(name), 1, sizeof((name)->array[0]), file);\
     }\
   } while(0)
 
 
 /**
  * loop index on vector elements
  *
  * For example:
  * forEachV(vec, i) {
  *   vectorAt(vec, i) = 0;
  * }
  */
 #define forEachV forEachSc
 
 /**
  * loop on vector elements
  * element is a pointer to a value in the array
  *
  * vectorForEach(&slc, e) {
  *    e->x = 0;
  * }
  */
 #define vectorForEach(name, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
   for (vectorElemPtrType(name) element = vectorPtr(name, 0) ; UNIQVAR(libsheepyInternalIndex) < (name)->count ; UNIQVAR(libsheepyInternalIndex)++, element = vectorPtr(name, UNIQVAR(libsheepyInternalIndex)))
 
 /**
  * enumerate vector elements
  * index is the position of the element in the array
  * index is declared as size_t and is available after the loop
  * element is a pointer to a value in the array
  *
  * vectorEnumerate(&slc, i, e) {
  *    e->x = 0;
  *    printf("vectorEnumerate %d\n", i);
  * }
  */
 #define vectorEnumerate(name, index, element) \
   ; size_t index = 0 ; \
   for (vectorElemPtrType(name) element = vectorPtr(name, 0) ; index < (name)->count ; index++, element = vectorPtr(name, index))
 
 /**
  * insert an element at index
  * the data is moved to create space for the new element
  * to set data at the new element, use vectorAt(name, index) = value;
  */
 #define vectorInject(name, index) do {\
   var UNIQVAR(idx) = index;\
   vectorPush(name);\
   memmove(vectorPtr(name, UNIQVAR(idx) +1), vectorPtr(name, UNIQVAR(idx)), ((name)->count - UNIQVAR(idx)) * sizeof (name)->array[0]);\
   } while(0)
 
 /**
  * prepend element
  *
  * \param
  * name vector
  * \param
  * v element to prepend
  */
 #define vectorPrepend(name, v) do {\
     vectorInject(name, 0);\
     vectorAt(name, 0) = v;\
   } while(0)
 
 /**
  * dequeue element
  *
  * \param
  * name vector
  */
 #define vectorDequeue sliceDequeue
 
 /**
  * delete first element in vector
  * the data is moved when count > 1
  */
 #define vectorDelFirst sliceDelFirst
 
 
 /**
  * delete an element in vector
  * the data is moved when index < (count-1)
  * when index = count -1, the last element is deleted and no data is moved
  */
 #define vectorDelElem sliceDelElem
 
 /**
  * delete range in vector
  * start must be between 0 and last index
  * end must be between 1 and count
  */
 #define vectorDel sliceDel
 
 /**
  * append vector to vector name
  * the data is copied
  */
 #define vectorVAppend(name, vector) do {\
   var UNIQVAR(vec) = vector;\
   if (sizeof((name)->array[0]) == sizeof((UNIQVAR(vec))->array[0])) {\
     if (((name)->count + (UNIQVAR(vec))->count) > (name)->maxCount)\
       vectorResize(name, (name)->count + (UNIQVAR(vec))->count);\
     memcpy((name)->array + (name)->count, (UNIQVAR(vec))->array, (UNIQVAR(vec))->count * sizeof (name)->array[0]);\
     (name)->count += (UNIQVAR(vec))->count;\
   }\
   } while(0)
 
 /**
  * append array to vector
  * the data is copied
  */
 #define vectorAppendFrom(name, array, countInt) do {\
   var UNIQVAR(c) = countInt;\
   var UNIQVAR(a) = array;\
   if (sizeof((name)->array[0]) == sizeof(*(UNIQVAR(a)))) {\
     if (((name)->count + UNIQVAR(c)) > (name)->maxCount)\
       vectorResize(name, (name)->count + UNIQVAR(c));\
     memcpy((name)->array + (name)->count, UNIQVAR(a), UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(c);\
   }\
   } while(0)
 
 /**
  * prepend vector to vector name
  * the data in vector name is moved and
  * the data in vector is copied to vector name
  */
 #define vectorVPrepend(name, vector) do {\
   var UNIQVAR(vec) = vector;\
   if (sizeof((name)->array[0]) == sizeof((UNIQVAR(vec))->array[0])) {\
     if (((name)->count + (UNIQVAR(vec))->count) > (name)->maxCount)\
       vectorResize(name, (name)->count + (UNIQVAR(vec))->count);\
     memmove((name)->array + (UNIQVAR(vec))->count, (name)->array, (name)->count * sizeof (name)->array[0]);\
     memcpy((name)->array, (UNIQVAR(vec))->array, (UNIQVAR(vec))->count * sizeof (name)->array[0]);\
     (name)->count += (UNIQVAR(vec))->count;\
   }\
   } while(0)
 
 /**
  * prepend array to vector
  * the data in vector is moved and
  * the data in array is copied to vector
  */
 #define vectorPrependFrom(name, array, countInt) do {\
   var UNIQVAR(c) = countInt;\
   var UNIQVAR(a) = array;\
   if (sizeof((name)->array[0]) == sizeof(*(UNIQVAR(a)))) {\
     if (((name)->count + UNIQVAR(c)) > (name)->maxCount)\
       vectorResize(name, (name)->count + UNIQVAR(c));\
     memmove((name)->array + UNIQVAR(c), (name)->array, (name)->count * sizeof (name)->array[0]);\
     memcpy((name)->array, UNIQVAR(a), UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(c);\
   }\
   } while(0);
 
 /**
  * insert vector at position index
  * the data in vector name is moved and
  * the data in vector is copied to vector name
  */
 #define vectorInsert(name, index, vector) do {\
   var UNIQVAR(idx) = index;\
   var UNIQVAR(vec) = vector;\
   if (UNIQVAR(idx) == (name)->count) {\
     vectorAppend(name, UNIQVAR(vec));\
   }\
   else if (sizeof((name)->array[0]) == sizeof((UNIQVAR(vec))->array[0])) {\
     if (((name)->count + (UNIQVAR(vec))->count) > (name)->maxCount)\
       vectorResize(name, (name)->count + (UNIQVAR(vec))->count);\
     memmove((name)->array + UNIQVAR(idx) + (UNIQVAR(vec))->count, (name)->array + UNIQVAR(idx), ((name)->count - UNIQVAR(idx)) * sizeof (name)->array[0]);\
     memcpy((name)->array + UNIQVAR(idx), (UNIQVAR(vec))->array, (UNIQVAR(vec))->count * sizeof (name)->array[0]);\
     (name)->count += (UNIQVAR(vec))->count;\
   }\
   } while(0)
 
 /**
  * insert array at position index
  * the data in vector is moved and
  * the data in array is copied to vector
  */
 #define vectorInsertFrom(name, index, array, countInt) do {\
   var UNIQVAR(idx) = index;\
   var UNIQVAR(c)   = countInt;\
   var UNIQVAR(a)   = array;\
   if (UNIQVAR(idx) == (name)->count) {\
     vectorAppendFrom(name, UNIQVAR(a), UNIQVAR(c));\
   }\
   else if (sizeof((name)->array[0]) == sizeof(UNIQVAR(a)[0])) {\
     if (((name)->count + UNIQVAR(c)) > (name)->maxCount)\
       vectorResize(name, (name)->count + UNIQVAR(c));\
     memmove((name)->array + UNIQVAR(idx) + UNIQVAR(c), (name)->array + UNIQVAR(idx), ((name)->count - UNIQVAR(idx)) * sizeof (name)->array[0]);\
     memcpy((name)->array + UNIQVAR(idx), UNIQVAR(a), UNIQVAR(c) * sizeof (name)->array[0]);\
     (name)->count += UNIQVAR(c);\
   }\
   } while(0)
 
 /**
  * slice vector, keep only elements between start and end
  * start must be between 0 and last index
  * end must be between 1 and count
  * the vector is returned
  */
 #define vectorSlice sliceSlice
 
 /**
  * copy vector elements between start and end to a new vector
  * start must be between 0 and last index
  * end must be between 1 and count
  * the new vector is returned and must be freed with vectorTerminate
  */
 #define vectorCopy(name, start, end) ({\
   var UNIQVAR(strt) = start;\
   var UNIQVAR(ed)   = end;\
   createAllocateVectorCount(typeof(*(name)),UNIQVAR(r), UNIQVAR(ed) - UNIQVAR(strt));\
   memcpy(UNIQVAR(r)->array, (name)->array + UNIQVAR(strt), (UNIQVAR(ed) - UNIQVAR(strt)) * sizeof (name)->array[0]);\
   UNIQVAR(r)->count = UNIQVAR(ed) - UNIQVAR(strt);\
   UNIQVAR(r);\
   })
 
 /**
  * copy vector elements between start and end to the dest vector
  * start must be between 0 and last index
  * end must be between 1 and count
  */
 #define vectorBCopy(name, dest, start, end) do{\
   if (sizeof((name)->array[0]) == sizeof((dest)->array[0])) {\
     var UNIQVAR(strt) = start;\
     var UNIQVAR(ed)   = end;\
     if ((UNIQVAR(ed) - UNIQVAR(strt)) > (dest)->maxCount)\
       vectorResize(dest, UNIQVAR(ed) - UNIQVAR(strt));\
     memcpy((dest)->array, (name)->array + UNIQVAR(strt), (UNIQVAR(ed) - UNIQVAR(strt)) * sizeof (name)->array[0]);\
     (dest)->count = UNIQVAR(ed) - UNIQVAR(strt);\
   }\
   } while(0)
 
 /**
  * sort the vector
  * the compareFunction must prototype of type:
  * int cmp(const void * a, const void * b);
  * the results of the compareFunction should be:
  * <0 when a < b
  * 0  when a = b
  * >0 when a > b
  */
 #define vectorSort sliceSort
 
 /**
  * return true when vector name is equal to vector
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  */
 #define vectorEq sliceEq
 
 /**
  * return true when vector has value
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  */
 #define vectorHas sliceHas
 
 /**
  * return index (ssize_t) of value in vector
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  *
  * return value is -1 when value is not found
  */
 #define vectorIndexOf sliceIndexOf
 
 /**
  * binary search value in vector
  *
  * efficiently finds the index of value in vector
  * the vector has to be sorted before calling vectorBinarySearch
  *
  * less is a macro taking an index and the search value returning 1 when vectorAt(name,index) is less than value:
  * #define less(index, value) vectorAt(name, index) < value
  *
  * equal is a macro returning 1 when vectorAt(name,index) is equal to value:
  * #define equal(index, value) vectorAt(name,index) == value
  *
  * return value is -1 when value is not found
  */
 #define vectorBinarySearch sliceBinarySearch
 
 /**
  * Uniquify elements in vector
  * each elements are unique in the vector
  *
  * eqFunction should return true when the elements are equal
  * eqFunction can be either a macro or a function
  */
 #define vectorUniq sliceUniq
 
 /*
  * end vector
  */
 
 
 /**
  * dynamic segmented vector
  *
  * this type of array is faster than vector when there are many elements and has a dynamic element count
  * pushing elements into the array increases the element count
  * the data is stored in static array segments
  *
  * no sanity checks are done
  *
  * usage examples: regular array, stack
  *
  * the prefix is dVector
  *
  * Usage:
  *
  * to declare an array:
  *
  * dVectorT(typeName, type);
  *
  * typeName dvector;
  *
  * dVectorInit(&dvector);
  * or
  * dVectorInitCount(&dvector, 17);
  *
  * dVectorAppend(&dvector, value);
  *
  * // get an element
  * int a                = dVectorAt(&dvector, 0);
  *
  * set
  * dVectorAt(&dvector, 1) = 3;
  *
  * dVectorFree(&dvector);
  *
  * dVector variables:
  * dvector.maxCount: maximum element count allowed
  *
  * Note: dont combine the macros, it gives wrong results:
  *       a = dVectorAt(&dvector, dVectorPop(&dvector2));
  *       dVectorPop is run several time, more than one element is popped
  *
  * Note: some functions are macros to be able to have structs as element and
  *       access the struct members directly, for example:
  *         dVectorLast(chan).a = 0;
  */
 
 // user parameters
 /**
  * chunk size: 2^dVectorBits elements
  */
 #define dVectorBits 6
 // user parameters end
 
 #define dVectorSz   (1<<dVectorBits)
 #define dVectorMask (dVectorSz-1)
 
 /**
  * declares type for dynamic array
  *
  * \param
  * typeName dVector type name
  * \param
  * element type of elements (int, struct, pointer...)
  */
 #define dVectorT(typeName, elementType)\
   typedef struct {\
     int64_t    count;\
     int64_t    maxCount;\
     void**      buffers;\
     elementType element;\
   } typeName
 
 
 #define createDVector(typeName, name) ;typeName name; dVectorInit(&name)
 
 #define createDVectorCount(typeName, name, count) ;typeName name; dVectorInitCount(&name, count)
 
 /**
  * initialize dynamic array with minimum element count
  *
  * \param
  * a variable name for dVector
  */
 #define dVectorInit(a) do{\
     (a)->count            = 0;\
     (a)->buffers          = malloc(sizeof(void*));\
     (a)->buffers[0]       = malloc(dVectorSz * sizeof((a)->element));\
     (a)->maxCount         = 1;\
   }while(0)
 
 
 /**
  * initialize dynamic array and count
  *
  * \param
  * a variable name for dVector
  * \param
  * count initial element count for name type
  */
 #define dVectorInitCount(a, count) do{\
     dVectorInit(a);\
     if (count > dVectorSz) {\
       (a)->buffers = realloc((a)->buffers, ((count>>dVectorBits)+1) * sizeof(void*));\
       rangeFrom(UNIQVAR(i), 1, (count>>dVectorBits)+1) {\
         (a)->buffers[UNIQVAR(i)] = malloc(dVectorSz * sizeof((a)->element));\
       }\
       (a)->maxCount = (count>>dVectorBits)+1;\
     }\
   }while(0)
 
 #define dVectorResize(a, count) do{\
     if (count > (a)->maxCount * dVectorSz) {\
       /* grow array */\
       (a)->buffers = realloc((a)->buffers, ((count>>dVectorBits)+1) * sizeof(void*));\
       rangeFrom(UNIQVAR(i), (a)->maxCount, (count>>dVectorBits)+1) {\
         (a)->buffers[UNIQVAR(i)] = malloc(dVectorSz * sizeof((a)->element));\
       }\
       (a)->maxCount = (count>>dVectorBits)+1;\
     }\
     /*else TODO dVector shrink */\
   }while(0)
 
 /**
  * free the internal buffers
  *
  * \param
  * a dynamic array
  */
 #define dVectorFree(a) do{\
     range(UNIQVAR(i), (size_t)(a)->maxCount) {\
       free((a)->buffers[UNIQVAR(i)]);\
     }\
     free((a)->buffers);\
   }while(0)
 
 /**
  * element type in vector
  */
 #define dVectorElemType(name) typeof((name)->element)
 
 /**
  * element pointer type in vector
  */
 #define dVectorElemPtrType(name) typeof(&(name)->element)
 
 /**
  * Empty Array
  * Allocated buffers in the array must be freed before running dVectorEmpty
  */
 #define dVectorEmpty(name) (name)->count = 0
 
 /**
  * is Array Empty
  */
 #define dVectorIsEmpty(name) ((name)->count == 0)
 
 /**
  * return element count
  */
 #define dVectorCount(name) (name)->count
 
 /**
  * return max element count
  */
 #define dVectorMaxCount(name) ((name)->maxCount * dVectorSz)
 
 /**
  * allocate buffer for new elements
  * only when the array is full
  *
  * \param
  * a dynamic array
  */
 #define dVectorAlloc(a) do{\
     if ((a)->count == dVectorMaxCount(a)) {\
       (a)->maxCount++;\
       (a)->buffers = realloc((a)->buffers, (a)->maxCount * sizeof(void*));\
       (a)->buffers[(a)->maxCount-1] = malloc(dVectorSz * sizeof((a)->element));\
     }\
   }while(0)
 
 /**
  * push element and expand the dynamic array
  * no data (random) is set in the new element.
  *
  * \param
  * a dynamic array
  * \param
  * v element to push
  */
 #define dVectorPush(a) do{\
     dVectorAlloc(a);\
     (a)->count++;\
   }while(0)
 
 /**
  * append element and expand the dynamic array
  *
  * \param
  * a dynamic array
  * \param
  * v element to push
  */
 #define dVectorAppend(a, v) do{\
     dVectorAlloc(a);\
     if ((a)->count < dVectorMaxCount(a)) {\
       typeof((a)->element) *UNIQVAR(buffer) = (a)->buffers[((a)->count)>>dVectorBits];\
       *(UNIQVAR(buffer)+ (((a)->count)&dVectorMask)) = v;\
       (a)->count++;\
     }\
   }while(0)
 
 /**
  * pop element
  * the index of the last element is decreased
  *
  * NOTE: using comma operator to avoid warning
  * warning: operation on ‘b.head’ may be undefined [-Wsequence-point]
  *
  *
  * \param
  * a dynamic array
  */
 #define dVectorPop(a) ((a)->count--, *((typeof((a)->element)*)((a)->buffers[((a)->count)>>dVectorBits])+(((a)->count)&dVectorMask)))
 
 /**
  * delete the last element
  * useful for avoiding warning: right-hand operand of comma expression has no effect
  * when the poped value is not used
  */
 #define dVectorDelLast(a) ((a)->count--)
 
 // TODO poor perfomance #define dVectorPrepend(a, v)
 
 // TODO poor perfomance #define dVectorDequeue(a)
 
 // TODO poor perfomance #define dVectorDelFirst(a)
 
 /**
  * get / set element at index
  *
  * \param
  * a dynamic array
  * \param
  * index index in array
  */
 #define dVectorAt(a, index) (*((typeof((a)->element)*)((a)->buffers[(index)>>dVectorBits])+((index)&dVectorMask)))
 
 /**
  * get pointer to element at index
  *
  * \param
  * a dynamic array
  * \param
  * index index in array
  */
 #define dVectorPtr(a, index) ((typeof((a)->element)*)((a)->buffers[(index)>>dVectorBits])+((index)&dVectorMask))
 
 /**
  * last element
  *
  * \param
  * a dynamic array
  */
 #define dVectorLast(a) (*((typeof((a)->element)*)((a)->buffers[((a)->count-1)>>dVectorBits])+(((a)->count-1)&dVectorMask)))
 
 /**
  * pointer to last element
  *
  * \param
  * a dynamic array
  */
 #define dVectorLastPtr(a) ((typeof((a)->element)*)((a)->buffers[((a)->count-1)>>dVectorBits])+(((a)->count-1)&dVectorMask))
 
 /**
  * index of last element
  */
 #define dVectorLastIndex(a) ((a)->count-1)
 
 /**
  * first element
  *
  * \param
  * a dynamic array
  */
 #define dVectorFirst(a) (*((typeof((a)->element)*)((a)->buffers[0])))
 
 /**
  * write the dVector content to filename file
  * No NULL checks are done on the parameters
  *
  * \param
  *    filename file name string
  */
 #define dVectorWriteFilename(a, filename) do {\
     FILE *UNIQVAR(f) = fopen(filename, "w");\
     if (UNIQVAR(f)) {\
       range(UNIQVAR(i), (size_t)dVectorCount(a)) {\
         typeof((a)->element) *firstElement = (a)->buffers[UNIQVAR(i)/dVectorSz];\
         fwrite(firstElement+(UNIQVAR(i)%dVectorSz), 1, sizeof((a)->element), UNIQVAR(f));\
       }\
       fclose(UNIQVAR(f));\
     }\
   } while(0)
 
 /**
  * write the dVector content to disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define dVectorWrite(a, file) do {\
     range(UNIQVAR(i), (size_t)dVectorCount(a)) {\
       typeof((a)->element) *firstElement = (a)->buffers[UNIQVAR(i)/dVectorSz];\
       fwrite(firstElement+(UNIQVAR(i)%dVectorSz), 1, sizeof((a)->element), file);\
     }\
   } while(0)
 
 /**
  * read a dVector from filename file
  * No NULL checks are done on the parameters
  *
  * \param
  * filename file name string
  */
 #define dVectorReadFilename(a, filename) do {\
     if (fileExists(filename)) {\
       size_t UNIQVAR(sz) = fileSize(filename);\
       FILE *UNIQVAR(f) = fopen(filename, "r");\
       if (UNIQVAR(f)) {\
         range(UNIQVAR(i), UNIQVAR(sz)/sizeof((a)->element)) {\
           dVectorPush(a);\
           fread(dVectorLastPtr(a), 1, sizeof((a)->element), UNIQVAR(f));\
         }\
         fclose(UNIQVAR(f));\
       }\
     }\
   } while(0)
 
 /**
  * read a dVector from disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define dVectorRead(a, file) do {\
     fseek(file, 0 , SEEK_END);\
     size_t UNIQVAR(sz) = ftell(file);\
     fseek(file, 0 , SEEK_SET);\
     range(UNIQVAR(i), UNIQVAR(sz)/sizeof((a)->element)) {\
       dVectorPush(a);\
       fread(dVectorLastPtr(a), 1, sizeof((a)->element), file);\
     }\
   } while(0)
 
 /**
  * loop on dVector elements
  * element is a pointer to a value in the array
  *
  * dVectorForEach(&vec, e) {
  *    e->x = 0;
  * }
  */
 #define dVectorForEach(name, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
   for (dVectorElemPtrType(name) element = dVectorPtr(name, 0) ; UNIQVAR(libsheepyInternalIndex) < (name)->count ; UNIQVAR(libsheepyInternalIndex)++, element = dVectorPtr(name, UNIQVAR(libsheepyInternalIndex)))
 
 /**
  * enumerate dVector elements
  * index is the position of the element in the array
  * index is declared as size_t and is available after the loop
  * element is a pointer to a value in the array
  *
  * dVectorEnumerate(&vec, i, e) {
  *    e->x = 0;
  *    printf("dVectorEnumerate %d\n", i);
  * }
  */
 #define dVectorEnumerate(name, index, element) \
   ; size_t index = 0 ; \
   for (dVectorElemPtrType(name) element = dVectorPtr(name, 0) ; index < (name)->count ; index++, element = dVectorPtr(name, index))
 
 
 
 /*
  * end dynamic segmented vector
  */
 
 
 /**
  * staticArray type definition
  *
  * this type of array has a static maximum element count (fixed)
  * staticArray has head and last indexes, this allows dequeuing from head elements fast
  * it is used as a circular buffer, queue, fifo...
  * a ring is a pointer to a staticArray
  *
  * no sanity checks are done
  *
  * Usage:
  *
  * to declare an array:
  *
  * typedef struct {
  *   int a;
  *   char *key;
  * } element;
  *
  * staticArrayT(typeName, element, 10);
  *
  * typeName array;
  * staticArrayInit(array);
  *
  * staticArrayPush(array);
  * staticArrayLast(array).a = fork();
  *
  * val = staticArrayLast(array).a;
  * staticArrayPop(array);
  *
  * Array variables:
  * array.list:     elements
  * array.maxCount: maximum element count allowed
  *
  * Note: some functions are macros to be able to have structs as element and
  *       access the struct members directly, for example:
  *         staticArrayLast(chan).a = 0;
  */
 
 //
 // TODO add print elements func
 // TODO check boundaries
 
 /**
  * base type for all staticArrays and rings
  */
 typedef struct {
   i64 last; // last element
   i64 head;
   i64 maxCount;
   bool isEmpty;
 } staticArrayBase;
 
 /**
  * declares type for staticArray or ring
  *
  * \param
  * typeName staticArray/ring type name
  * \param
  * element type of elements (int, struct, pointer...)
  * \param
  * MAXCOUNT array/ring buffer size
  */
 #define staticArrayT(typeName, element, MAXCOUNT)\
   typedef struct {\
     i64 last;\
     i64 head;\
     i64 maxCount;\
     bool isEmpty;\
     element list[MAXCOUNT];\
   } typeName;
 
 #define createStaticArray(typeName, name) ;typeName name; staticArrayInit(name)
 
 /**
  * initialize count in array/static ring
  * this macro can initialize rings if the struct is accessed directly
  *
  * \param
  * name variable name for staticArray
  */
 #define staticArrayInit(name)\
   do{\
     (name).last = (name).head = 0;\
     (name).maxCount = COUNT_ELEMENTS((name).list);\
     (name).isEmpty = true;\
   } while(0);
 
 /**
  * element type in array
  */
 #define staticArrayElemType(name) typeof((name).list[0])
 
 /**
  * element pointer type in array
  */
 #define staticArrayElemPtrType(name) typeof(&(name).list[0])
 
 /**
  * Empty Array
  * Allocated buffers in the list must be freed before running staticArrayEmpty
  */
 #define staticArrayEmpty(name)\
   do{\
     (name).last = (name).head = 0;\
     (name).isEmpty = true;\
   } while(0);
 
 /**
  * is Array Empty
  */
 #define staticArrayIsEmpty(name) ((name).isEmpty)
 
 /**
  * is Array Full
  */
 #define staticArrayIsFull(name) ((name).isEmpty ? 0 : ((((name).last+1) % (name).maxCount) == (name).head))
 
 /**
  * return elements count
  */
 #define staticArrayCount(name) ((name).isEmpty ? 0 : ((((name).last) >= ((name).head)) ? ((name).last-(name).head+1) : (((name).maxCount-(name).head + (name).last+1))) )
 
 /**
  * push element to array (only increases last)
  * use staticArrayLast to access the element
  */
 #define staticArrayPush(name)\
   do{\
     if ((name).isEmpty) {\
       (name).isEmpty = false;\
     }\
     else {\
       (name).last++;\
       (name).last %= (name).maxCount;\
     }\
   } while(0);
 
 /**
  * pop element from array (only decreases last)
  */
 #define staticArrayPop(name)\
   do{\
     if (!(name).isEmpty && ((name).last == (name).head)) {\
       (name).isEmpty = true;\
     }\
     else if (!(name).isEmpty && ((name).last != (name).head)) {\
       if ((name).last)\
         (name).last--;\
       else\
         (name).last+=(name).maxCount-1;\
     }\
   } while(0);
 
 #define staticArrayDelLast staticArrayPop
 
 /**
  * prepend element to array (only decreases head)
  * use staticArrayFirst to access the element
  */
 #define staticArrayPrepend(name)\
   do{\
     if ((name).isEmpty) {\
       (name).isEmpty = false;\
     }\
     else {\
       if ((name).head)\
         (name).head--;\
       else\
         (name).head+=(name).maxCount-1;\
     }\
   } while(0);
 
 /**
  * dequeue element from array (only increases head)
  */
 #define staticArrayDequeue(name)\
   do{\
     if (!(name).isEmpty && ((name).last == (name).head)) {\
       (name).isEmpty = true;\
     }\
     else if (!(name).isEmpty && ((name).last != (name).head)) {\
       (name).head++;\
       (name).head %= (name).maxCount;\
     }\
   } while(0);
 
 #define staticArrayDelFirst staticArrayDequeue
 
 /**
  * get element at index, negative index is supported
  */
 #define staticArrayGet(name, index) (name).list[(((index) >= 0) ? (index) : staticArrayCount(name) + (index) )]
 #define staticArrayAt staticArrayGet
 
 /**
  * index of element for an index relative to 0, negative index is supported
  */
 #define staticArrayGetIndex(name, index) ((((index) >= 0) ? (index) : staticArrayCount(name) + (index) ))
 
 /**
  * get element at index with name->head index 0, negative index is supported
  */
 #define staticArrayRef(name, index) (name).list[((((index) >= 0) ? (index) : staticArrayCount(name) + (index) ) + name.head) % name.maxCount]
 
 /**
  * index of element for an index relative to head, negative index is supported
  */
 #define staticArrayRefIndex(name, index) (((((index) >= 0) ? (index) : staticArrayCount(name) + (index) ) + name.head) % name.maxCount)
 
 /**
  * last element in array
  */
 #define staticArrayLast(name) (name).list[(name).last]
 
 /**
  * index of last element
  */
 #define staticArrayLastIndex(name) (name).last
 
 /**
  * first element in array
  */
 #define staticArrayFirst(name) (name).list[(name).head]
 
 /**
  * index of first element
  */
 #define staticArrayFirstIndex(name) (name).head
 
 /**
  * delete an element in the array and move elements after it to fill the gap
  */
 #define staticArrayDelElem(name, index) do {\
     if ((name).head < (name).last) {\
       /* move elements after index in latest static array */\
       if (index < (name).last) {\
         memmove(&(name).list[index], &(name).list[index+1], ((name).last - index) * sizeof((name).list[0]));\
       }\
     }\
     elif ((name).head > (name).last) {\
       if (index >= (name).head) {\
         /* move elements after index in latest static array */\
         if (index < (name).maxCount - 1) {\
           memmove(&(name).list[index], &(name).list[index+1], ((name).maxCount - index -1) * sizeof((name).list[0]));\
         }\
         /* move list[0] to list[maxCount-1] */\
         /* then shift elements in [1..last+1] to [0..last] if needed */\
         staticArrayAt((name), (name).maxCount-1) = staticArrayAt((name), 0);\
         if ((name).last > 0) {\
           memmove(&(name).list[0], &(name).list[1], (name).last * sizeof((name).list[0]));\
         }\
       }\
       else {\
         /* 0 < index < last+1 */\
         /* move elements after index in latest static array */\
         if (index < (name).last) {\
           memmove(&(name).list[index], &(name).list[index+1], ((name).last - index) * sizeof((name).list[0]));\
         }\
       }\
     }\
     staticArrayDelLast((name));\
   } while(0)
 
 /**
  * write the staticArray content to filename file
  * No NULL checks are done on the parameters
  *
  * \param
  *    filename file name string
  */
 #define staticArrayWriteFilename(name, filename) do {\
     FILE *UNIQVAR(f) = fopen(filename, "w");\
     if (UNIQVAR(f)) {\
       if ((name).head <= (name).last) {\
         fwrite(&((name).list[(name).head]), 1, (size_t)staticArrayCount(name) * sizeof((name).list[0]), UNIQVAR(f));\
       } else {\
         /* write from head to maxcount and then from 0 to last*/\
         fwrite(&((name).list[(name).head]), 1, (size_t)((name).maxCount - (name).head) * sizeof((name).list[0]), UNIQVAR(f));\
         fwrite(&((name).list[(name).head])+((name).maxCount - (name).head), 1, (size_t)((name).last+1) * sizeof((name).list[0]), UNIQVAR(f));\
       }\
       fclose(UNIQVAR(f));\
     }\
   } while(0)
 
 /**
  * write the staticArray content to disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define staticArrayWrite(name, file) do {\
     if ((name).head <= (name).last) {\
       fwrite(&((name).list[(name).head]), 1, (size_t)staticArrayCount(name) * sizeof((name).list[0]), file);\
     } else {\
       /* write from head to maxcount and then from 0 to last*/\
       fwrite(&((name).list[(name).head]), 1, (size_t)((name).maxCount - (name).head) * sizeof((name).list[0]), file);\
       fwrite(&((name).list[(name).head])+((name).maxCount - (name).head), 1, (size_t)((name).last+1) * sizeof((name).list[0]), file);\
     }\
   } while(0)
 
 /**
  * read name staticArray from filename file
  * No NULL checks are done on the parameters
  *
  * \param
  * filename file name string
  */
 #define staticArrayReadFilename(name, filename) do {\
     if (fileExists(filename)) {\
       size_t UNIQVAR(sz) = fileSize(filename);\
       if (UNIQVAR(sz) > sizeof((name).list)) break;\
       /* check that UNIQVAR(sz) is a multiple of sizeof((name).list[0]), if not the file data doesnt fit the array */\
       if (UNIQVAR(sz) % sizeof((name).list[0])) break;\
       FILE *UNIQVAR(f) = fopen(filename, "r");\
       if (UNIQVAR(f)) {\
         fread((name).list, 1, UNIQVAR(sz), UNIQVAR(f));\
         fclose(UNIQVAR(f));\
         (name).head = 0;\
         if (UNIQVAR(sz)) {\
           (name).last    = (UNIQVAR(sz) / sizeof((name).list[0])) - 1;\
           (name).isEmpty = false;\
         }\
         else {\
           (name).last    = 0;\
           (name).isEmpty = true;\
         }\
       }\
     }\
   } while(0)
 
 /**
  * read name staticArray from disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define staticArrayRead(name, file) do {\
     fseek(file, 0 , SEEK_END);\
     size_t UNIQVAR(sz) = ftell(file);\
     fseek(file, 0 , SEEK_SET);\
     if (UNIQVAR(sz) > sizeof((name).list)) break;\
     /* check that UNIQVAR(sz) is a multiple of sizeof((name).list[0]), if not the file data doesnt fit the array */\
     if (UNIQVAR(sz) % sizeof((name).list[0])) break;\
     fread((name).list, 1, UNIQVAR(sz), file);\
     (name).head = 0;\
     if (UNIQVAR(sz)) {\
       (name).last    = (UNIQVAR(sz) / sizeof((name).list[0])) - 1;\
       (name).isEmpty = false;\
     }\
     else {\
       (name).last    = 0;\
       (name).isEmpty = true;\
     }\
   } while(0)
 
 /**
  * loop on staticArray elements
  * element is a pointer to a value in the array
  *
  * staticArrayForEach(sa, e) {
  *    e->x = 0;
  * }
  */
 #define staticArrayForEach(name, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
   for (staticArrayElemPtrType(name) element = &staticArrayRef(name, 0) ; UNIQVAR(libsheepyInternalIndex) < staticArrayCount(name) ; UNIQVAR(libsheepyInternalIndex)++, element = &staticArrayRef(name, UNIQVAR(libsheepyInternalIndex)))
 
 /**
  * enumerate staticArray elements
  * index is the position of the element in the array
  * index is declared as size_t and is available after the loop
  * element is a pointer to a value in the array
  *
  * staticArrayEnumerate(sa, i, e) {
  *    e->x = 0;
  *    printf("staticArrayEnumerate %d\n", i);
  * }
  */
 #define staticArrayEnumerate(name, index, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
   ; size_t index = name.head ; \
   for (staticArrayElemPtrType(name) element = &staticArrayRef(name, 0) ; UNIQVAR(libsheepyInternalIndex) < staticArrayCount(name) ; UNIQVAR(libsheepyInternalIndex)++, index = (name.head + UNIQVAR(libsheepyInternalIndex)) % name.maxCount, element = &staticArrayRef(name, index))
 
 /**
  * indexer is a staticArray without the list
  * It indexes an independent array
  *
  * Usage:
  *
  * declare an array:
  * char array[10][5];
  *
  * declare an indexer:
  * indexer indx;
  *
  * or declare an indexer with smaller counters (default is int64_t):
  * indexerT(typeName, i8);
  * typeName indx;
  *
  * indexerInit(indx, 10);
  *
  * indexerPush(indx);
  * array[indexerLast(indx)][0] = '0';
  *
  * // or
  * indexerPush(indx);
  * array[indx.last][0] = '0';
  *
  * indexerPop(indx);
  *
  * // accessing the first/head element
  *
  * char c = array[indexerFirst(indx)][0];
  * char c = array[indx.head][0];
  *
  *
  * For pointer to indexers (idxP), use:
  * indexerPInit,
  * indexerPEmpty,
  * indexerPIsEmpty,
  * indexerPIsFull,
  * indexerPCount,
  * indexerPPush,
  * indexerPPop,
  * indexerPPrepend,
  * indexerPDequeue,
  * indexerPRef,
  * indexerPLast or idxP->last,
  * indexerPFirst or idxP->head
  *
  */
 
 /**
  * base type, same as staticArray
  */
 #define indexer staticArrayBase
 
 /**
  * declare an indexer type with INT_TYPE counters instead of the default i64
  * INT_TYPE has to be signed integer
  *
  * The indexers of this type are not compatible with the indexerP* functions
  */
 #define indexerT(typeName, INT_TYPE)\
   typedef struct {\
     INT_TYPE last;\
     INT_TYPE head;\
     INT_TYPE maxCount;\
     bool isEmpty;\
   } typeName;
 
 #define createIndexer(typeName, name, maxCount) ;typeName name; indexerInit(name, maxCount)
 
 /**
  * initialize count in array/static ring
  * this macro can initialize rings if the struct is accessed directly
  *
  * \param
  * name variable name for staticArray
  * \param
  * MAXCOUNT max count for name type
  */
 #define indexerInit(name, MAXCOUNT)\
   do{\
     (name).last = (name).head = 0;\
     (name).maxCount = MAXCOUNT;\
     (name).isEmpty = true;\
   } while(0);
 
 #define indexerPInit ringInit
 
 /**
  * Empty Array
  * Allocated buffers in the list must be freed before running staticArrayEmpty
  */
 #define indexerEmpty staticArrayEmpty
 #define indexerPEmpty ringEmpty
 
 /**
  * is Array Empty
  */
 #define indexerIsEmpty staticArrayIsEmpty
 #define indexerPIsEmpty ringIsEmpty
 
 /**
  * is Array Full
  */
 #define indexerIsFull staticArrayIsFull
 #define indexerPIsFull ringIsFull
 
 /**
  * return elements count
  */
 #define indexerCount staticArrayCount
 #define indexerPCount ringCount
 
 /**
  * push element to array (only increases last)
  * use staticArrayLast to access the element
  */
 #define indexerPush staticArrayPush
 #define indexerPPush ringPush
 
 /**
  * pop element from array (only decreases last)
  */
 #define indexerPop staticArrayPop
 #define indexerPPop ringPop
 
 /**
  * prepend element to array (only decreases head)
  * use staticArrayFirst to access the element
  */
 #define indexerPrepend staticArrayPrepend
 #define indexerPPrepend ringPrepend
 
 /**
  * dequeue element from array (only increases head)
  */
 #define indexerDequeue staticArrayDequeue
 #define indexerPDequeue ringDequeue
 
 /**
  * index element at index with name->head index 0, negative index is supported
  */
 #define indexerRef(name, index) (((((index) >= 0) ? (index) : indexerCount(name) + (index) ) + name.head) % name.maxCount)
 #define indexerPRef(name, index) (((((index) >= 0) ? (index) : indexerPCount(name) + (index) ) + name->head) % name->maxCount)
 
 /**
  * index of last element in array
  */
 #define indexerLast(name) name.last
 #define indexerPLast(name) (name)->last
 
 /**
  * index of first element in array
  */
 #define indexerFirst(name) (name.head)
 #define indexerPFirst(name) (name)->head
 
 
 /**
  * rings usage
  *
  * Make the ring type:
  *
  *   #define chanMax 30                // max message count in ring type chanT
  *   ringMake(chanT, int, chanMax); // ring type is chanT, list 30 of ints
  *
  * Add ring to a fiber context:
  *
  *   typedef struct {int slot; int a; chanT *c;} AArgs;
  *
  * Declare a ring of type chanT and initialize:
  *
  *   chanT c;
  *   ringInit(&c, chanMax);
  *
  * When the ring is empty, ringLast and ringFirst are valid and equal (same index).
  *
  * Send and receive data through the ring:
  *
  *   ringSend(ctx->c, 10);
  *   int r;
  *   if (!ringIsEmpty(ctx->c))
  *     ringRecv(ctx->c, r);
  *
  * Note: some functions are macros to be able to have structs as element and
  *       access the struct members directly, for example:
  *         ringLast(chan).a = 0;
  *
  */
 /**
  * base type, same as staticArray
  */
 #define ringBase staticArrayBase
 
 /**
  * declares type for staticArray or ring
  * staticArrayT(typeName, element, MAXCOUNT)
  *
  * \param
  * typeName staticArray/ring type name
  * \param
  * element type of elements (int, struct, pointer...)
  * \pointer
  * MAXCOUNT array/ring buffer size
  */
 #define ringMake staticArrayT
 
 /**
  * initialize count in array/static ring
  * staticArrayInit(name, MAXCOUNT)
  *
  * this macro can initialize rings if the struct is accessed directly
  *
  * \param
  * name variable name for ring
  */
 #define ringStaticInit staticArrayInit
 
 // initialize ring/pointer to staticArray
 int ringInit(void *ring, int maxCount);
 
 // empty ring
 int ringEmpty(void *ring);
 
 // is ring Empty
 int ringIsEmpty(void *ring);
 
 // is ring Full
 int ringIsFull(void *ring);
 
 // return elements count
 ssize_t ringCount(void *ring);
 
 
 // push element to ring (only increases last, use ringSend), use ringLast to access the element
 i64 ringPush(void *ring);
 
 
 // pop element from ring (only decreases last)
 int ringPop(void *ring);
 
 
 // prepend element to ring (only decreases head), use ringFirst to access the element
 i64 ringPrepend(void *ring);
 
 // dequeue element from ring (only increases head, use ringRecv)
 int ringDequeue(void *ring);
 
 /**
  * get element at index, negative index is supported
  */
 #define ringGet(name, index) (name)->list[(((index) >= 0) ? (index) : ringCount(name) + (index) )]
 
 /**
  * get element at index with name->head index 0, negative index is supported
  */
 #define ringRef(name, index) (name)->list[((((index) >= 0) ? (index) : ringCount(name) + (index) ) + name->head) % name->maxCount]
 
 /**
  * last element in ring
  */
 #define ringLast(name) (name)->list[(name)->last]
 
 /**
  * index of last element
  */
 #define ringLastIndex(name) (name)->last
 
 /**
  * last element in ring
  */
 #define ringFirst(name) (name)->list[(name)->head]
 
 
 /**
  * send data in ring
  *
  * \param
  * name variable name for ring
  * \param
  * value data
  */
 #define ringSend(name, value)\
   do {\
     if (ringPush(name) >= 0) ringLast(name) = value;\
   } while(0);
 
 // send data and get ring status
 #define ringSendSt(status, name, value)\
   do {\
     if ((status = ringPush(name)) >= 0) ringLast(name) = value;\
   } while(0);
 
 
 /**
  * receive data from ring
  *
  * \param
  * name variable name for ring
  * \param
  * result previously declared variable to store the data
  */
 #define ringRecv(name, result)\
   do {\
     result = ringFirst(name);\
     ringDequeue(name);\
   } while(0);
 
 // receive data and get ring status
 #define ringRecvSt(status, name, result)\
   do {\
     if ((status = ringIsEmpty(name)) == 0) {\
       result = ringFirst(name);\
       ringDequeue(name);\
     }\
   } while(0);
 
 /**
  * fiber usage
  *
  * The stack is not restored, so all local variables should
  * be stored in the context struct.
  *
  * Declare a context type for the fiber:
  *
  *   typedef struct {int slot; int a; chanT *c;} AArgs;
  *
  * the context type must start with int slot;
  * in this example, the fiber has a ring c of type chanT
  *
  * Declare a function of type:
  *
  *   void fiberA(int thisSlot) {
  *     static AArgs *ctx;
  *     int slot;
  *     ctx = fiberCtx(thisSlot);
  *     ...
  *   }
  *
  * several fibers can have the function fiberA with different slots
  *
  * To yield, add:
  *
  *   yield(slot, ctx->slot); // switch to scheduler
  *   ctx = fiberCtx(slot);   // restore the context for this fiber
  *
  * The next steps show how to start the fibers
  *
  * Declare a variable for the context and create the ring chanT:
  *
  *   AArgs Aa;
  *   chanT c;
  *   ringInit(&c, chanMax);
  *
  * Initialize the fiber:
  *
  *   Aa.a = 0;
  *   Aa.c = &c;
  *   fiberAdd(&Aa, 1, fiberA);
  *
  * this can also be done from a running fiber
  *
  * Finally, start the scheduler:
  *
  *   scheduler();
  *
  */
 
 // schedule fibers
 void scheduler(void);
 
 // the scheduler takes slot 0
 // the system can handle tCount-1 fibers
 #define tCount 10
 
 /**
  * all contexts must start with fiberBaseT
  *
  * Example:
  * typedef struct {int slot; int a;} AArgs;
  */
 typedef struct {int slot;} fiberBaseT;
 
 /**
  * staticArray to hold the fiber slots
  */
 staticArrayT(fiberLT, int, tCount);
 
 /**
  * data type for fiber system
  */
 typedef struct {
   /**
    * setjmp buffers for fibers
    */
   jmp_buf jumpBuffers[tCount];
   /**
    * running fibers
    */
   fiberLT L;
   /**
    * fibers to start
    */
   fiberLT startL;
   /**
    * fiber context data
    */
   void *context[tCount];
   /**
    * fiber functions
    */
   void (*F[tCount])(int thisSlot);
 } fibersT;
 
 /**
  * data for fiber system
  */
 extern fibersT fibers;
 
 /**
  * get fiber context for thisSlot
  */
 #define fiberCtx(thisSlot) fibers.context[thisSlot]
 
 /**
  * fiber function type
  */
 typedef void (*fiberFT)(int);
 
 /**
  * add new fiber
  */
 bool fiberAdd(void *ctx, int thisSlot, fiberFT func);
 
 /**
  * add new fiber and start immediately after next yield
  */
 bool fiberPrepend(void *ctx, int thisSlot, fiberFT func);
 
 /**
  * fibers with setjmp (not ucontext)
  * internal
  *
  * startJump starts another fiber
  * slot is the index in fiberJumpBuffers for current fiber
  * func is the fiber to start
  *
  * the first fiber has to finish last
  */
 #define startJump(func)\
   if (!setjmp(fibers.jumpBuffers[0])) {\
       func;\
   }
 
 #if !__sun__
 /**
  * yield jumps back to other fiber
  * slot should be a local variable in the fiber
  * slot is set to the index in fiberJumpBuffers for current fiber
  * backToSlot is the index in fiberJumpBuffers for the other fiber
  */
 #define yield(slotValue, slot)\
   if (!(slotValue = setjmp(fibers.jumpBuffers[slot]))) {\
     staticArrayPush(fibers.L);\
     staticArrayLast(fibers.L) = slot;\
     longjmp(fibers.jumpBuffers[0], 1);\
   }
 #endif
 
 /**
  * return to scheduler and end the fiber
  */
 #define fiberEnd(slot)\
   if (!setjmp(fibers.jumpBuffers[slot])) {\
     longjmp(fibers.jumpBuffers[0], 1);\
   }
 
 // internal for scheduler
 #define schedulerYield(backToSlot)\
   if (!setjmp(fibers.jumpBuffers[0])) {\
     longjmp(fibers.jumpBuffers[backToSlot], backToSlot);\
   }
 
 
 
 /**
  * dynamic segmented array
  *
  * this type of array is faster than slab when there are many elements and has a dynamic element count
  * pushing elements into the array increases the element count
  * the data is stored in static array segments
  * dArray has head and last indexes, this allows dequeuing from head elements fast
  *
  * no sanity checks are done
  *
  * usage examples: regular array, stack, lifo, fifo
  *
  * the prefix is dArray
  *
  * Usage:
  *
  * to declare an array:
  *
  * dArrayT(typeName, type);
  *
  * typeName darray;
  *
  * dArrayInit(&darray);
  * or
  * dArrayInitCount(&darray, 17);
  *
  * dArrayAppend(&darray, value);
  *
  * // get an element
  * int a                = dArrayAt(&darray, 0);
  *
  * set
  * dArrayAt(&darray, 1) = 3;
  *
  * dArrayFree(&darray);
  *
  * dArray variables:
  * darray.maxCount: maximum element count allowed
  *
  * Note: dont combine the macros, it gives wrong results:
  *       a = dArrayAt(&darray, dArrayPop(&darray2));
  *       dArrayPop is run several time, more than one element is popped
  *
  * Note: some functions are macros to be able to have structs as element and
  *       access the struct members directly, for example:
  *         dArrayLast(chan).a = 0;
  */
 
 // user parameters
 /**
  * chunk size: 2^dArrayBits elements
  */
 #define dArrayBits 6
 // user parameters end
 
 #define dArraySz   (1<<dArrayBits)
 #define dArrayMask (dArraySz-1)
 
 /**
  * declares type for dynamic array
  *
  * \param
  * typeName dArray type name
  * \param
  * element type of elements (int, struct, pointer...)
  */
 #define dArrayT(typeName, elementType)\
   typedef struct {\
     int64_t    last;\
     int64_t    head;\
     int64_t    maxCount;\
     void**      buffers;\
     elementType element;\
   } typeName
 
 
 #define createDArray(typeName, name) ;typeName name; dArrayInit(&name)
 
 #define createDArrayCount(typeName, name, count) ;typeName name; dArrayInitCount(&name, count)
 
 /**
  * initialize dynamic array with minimum element count
  *
  * \param
  * a variable name for dArray
  */
 #define dArrayInit(a) do{\
     (a)->last = (a)->head = 0;\
     (a)->buffers          = malloc(sizeof(void*));\
     (a)->buffers[0]       = malloc(dArraySz * sizeof((a)->element));\
     (a)->maxCount         = 1;\
   }while(0)
 
 /**
  * initialize dynamic array and count
  *
  * \param
  * a variable name for dArray
  * \param
  * count initial element count for name type
  */
 #define dArrayInitCount(a, count) do{\
     dArrayInit(a);\
     if ((count) > dArraySz) {\
       (a)->buffers = realloc((a)->buffers, (((count)>>dArrayBits)+1) * sizeof(void*));\
       rangeFrom(UNIQVAR(i), 1, ((count)>>dArrayBits)+1) {\
         (a)->buffers[UNIQVAR(i)] = malloc(dArraySz * sizeof((a)->element));\
       }\
       (a)->maxCount = ((count)>>dArrayBits)+1;\
     }\
   }while(0)
 
 #define dArrayResize(a, count) do{\
     if ((count) > (a)->maxCount * dArraySz) {\
       /* grow array */\
       (a)->buffers = realloc((a)->buffers, (((count)>>dArrayBits)+1) * sizeof(void*));\
       rangeFrom(UNIQVAR(i), (a)->maxCount, ((count)>>dArrayBits)+1) {\
         (a)->buffers[UNIQVAR(i)] = malloc(dArraySz * sizeof((a)->element));\
       }\
       (a)->maxCount = ((count)>>dArrayBits)+1;\
     }\
     /*else TODO dArray shrink */\
   }while(0)
 
 /**
  * free the internal buffers
  *
  * \param
  * a dynamic array
  */
 #define dArrayFree dVectorFree
 
 /**
  * element type in array
  */
 #define dArrayElemType(a) typeof((a)->element)
 
 /**
  * element pointer type in array
  */
 #define dArrayElemPtrType(a) typeof(&(a)->element)
 
 /**
  * Empty Array
  * Allocated buffers in the array must be freed before running dArrayEmpty
  */
 #define dArrayEmpty(name) do{\
     (name)->last = (name)->head = 0;\
   } while(0);
 
 /**
  * is Array Empty
  */
 #define dArrayIsEmpty(name) ((name)->head == (name)->last)
 
 /**
  * return element count
  */
 #define dArrayCount(name) ((name)->last - (name)->head)
 
 /**
  * return max element count
  */
 #define dArrayMaxCount(name) ((name)->maxCount * dArraySz)
 
 /**
  * allocate buffer for new elements
  * only when the array is full
  *
  * \param
  * a dynamic array
  */
 #define dArrayAlloc(a) do{\
     if ((a)->last == dArrayMaxCount(a)) {\
       (a)->maxCount++;\
       (a)->buffers = realloc((a)->buffers, (size_t)(a)->maxCount * sizeof(void*));\
       (a)->buffers[(a)->maxCount-1] = malloc(dArraySz * sizeof((a)->element));\
     }\
   }while(0)
 
 /**
  * push element and expand the dynamic array
  * no data (random) is set in the new element.
  *
  * \param
  * a dynamic array
  * \param
  * v element to push
  */
 #define dArrayPush(a) do{\
     dArrayAlloc(a);\
     (a)->last++;\
   }while(0)
 
 /**
  * append element and expand the dynamic array
  *
  * \param
  * a dynamic array
  * \param
  * v element to push
  */
 #define dArrayAppend(a, v) do{\
     dArrayAlloc(a);\
     if ((a)->last < dArrayMaxCount(a)) {\
       typeof((a)->element) *UNIQVAR(buffer) = (a)->buffers[((a)->last)>>dArrayBits];\
       *(UNIQVAR(buffer)+ (((a)->last)&dArrayMask)) = v;\
       (a)->last++;\
     }\
   }while(0)
 
 /**
  * pop element
  * the index of the last element is decreased
  *
  * NOTE: using comma operator to avoid warning
  * warning: operation on ‘b.head’ may be undefined [-Wsequence-point]
  *
  *
  * \param
  * a dynamic array
  */
 #define dArrayPop(a) ((a)->last--, *((typeof((a)->element)*)((a)->buffers[((a)->last)>>dArrayBits])+(((a)->last)&dArrayMask)))
 
 /**
  * delete the last element
  * useful for avoiding warning: right-hand operand of comma expression has no effect
  * when the poped value is not used
  */
 #define dArrayDelLast(a) ((a)->last--)
 
 /**
  * prepend element
  *
  * \param
  * a dynamic array
  * \param
  * v element to prepend
  */
 #define dArrayPrepend(a, v) do{\
     if ((a)->head > 0) {\
       (a)->head--;\
       typeof((a)->element) *UNIQVAR(buffer) = (a)->buffers[((a)->head)>>dArrayBits];\
       *(UNIQVAR(buffer)+ (((a)->head)&dArrayMask)) = v;\
     }\
   }while(0)
 
 /**
  * dequeue element
  * the index of the head element is increased
  *
  * NOTE: using comma operator to avoid warning
  * warning: operation on ‘b.head’ may be undefined [-Wsequence-point]
  *
  *
  * \param
  * a dynamic array
  */
 #define dArrayDequeue(a) ((a)->head++, *((typeof((a)->element)*)((a)->buffers[((a)->head-1)>>dArrayBits])+(((a)->head-1)&dArrayMask)))
 
 /**
  * delete the first element
  * useful for avoiding warning: right-hand operand of comma expression has no effect
  * when the dequeued value is not used
  */
 #define dArrayDelFirst(a) ((a)->head++)
 
 /**
  * get / set element at index
  *
  * \param
  * a dynamic array
  * \param
  * index index in array
  */
 #define dArrayAt(a, index) (*((typeof((a)->element)*)((a)->buffers[(index)>>dArrayBits])+((index)&dArrayMask)))
 
 /**
  * get pointer to element at index
  *
  * \param
  * a dynamic array
  * \param
  * index index in array
  */
 #define dArrayPtr(a, index) ((typeof((a)->element)*)((a)->buffers[(index)>>dArrayBits])+((index)&dArrayMask))
 
 /**
  * set at index and resize dArray when index is greater then maxCount
  */
 #define dArraySet(a, index, v) do{\
   var UNIQVAR(idx) = index;\
   if (UNIQVAR(idx) < (a)->last) {\
     /* index is inside current array */\
     dArrayAt(a, UNIQVAR(idx)) = v;\
     if (UNIQVAR(idx) < (a)->head) {\
       /* update head since index is lower */\
       (a)->head = UNIQVAR(idx);\
     }\
   }\
   else {\
     /* index is after last element */\
     /* check if index is under maxCount */\
     if (UNIQVAR(idx) >= dArrayMaxCount(a)) {\
       /* resize array */\
       dArrayResize(a, UNIQVAR(idx)+1);\
     }\
     dArrayAt(a, UNIQVAR(idx)) = v;\
     /* update last since index is higher*/\
     (a)->last = UNIQVAR(idx)+1;\
   }\
   }while(0)
 
 /**
  * sparse set at index and resize dArray when index is greater then maxCount
  * dArraySparseSet allows using dArray as a sparse array
  *
  * head and last are not updated because there are empty regions in the sparse array
  *
  * the empty segments are marked with NULL in the a->buffers array
  *
  * after using dArraySparseSet only these macros are valid:
  * dArrayResize, dArrayElemType, dArrayElemPtrType, dArrayMaxCount, dArrayAt, dArrayPtr, dArrayFree
  */
 #define dArraySparseSet(a, index, v) do{\
   var UNIQVAR(idx)     = index;\
   var UNIQVAR(bIdx)    = UNIQVAR(idx)>>dArrayBits;\
   if (UNIQVAR(idx) >= dArrayMaxCount(a)) {\
     /* sparse resize array - grow array */\
     (a)->buffers = realloc((a)->buffers, (((UNIQVAR(bIdx)+1)>>dArrayBits)+1) * sizeof(void*));\
     /* empty segments are marked with NULL */\
     memset(&(a)->buffers[(a)->maxCount], 0, (UNIQVAR(bIdx)+1) - (a)->maxCount);\
     (a)->maxCount = UNIQVAR(bIdx)+1;\
     /* allocate new segment */\
     (a)->buffers[UNIQVAR(bIdx)] = malloc(dArraySz * sizeof((a)->element));\
     dArrayAt(a, UNIQVAR(idx)) = v;\
   }\
   else {\
     /* check if the segment is already allocated */\
     if (!(a)->buffers[UNIQVAR(bIdx)]) {\
       /* allocate new segment */\
       (a)->buffers[UNIQVAR(bIdx)] = malloc(dArraySz * sizeof((a)->element));\
     }\
     dArrayAt(a, UNIQVAR(idx)) = v;\
   }\
   }while(0)
 
 /**
  * last element
  *
  * \param
  * a dynamic array
  */
 #define dArrayLast(a) (*((typeof((a)->element)*)((a)->buffers[((a)->last-1)>>dArrayBits])+(((a)->last-1)&dArrayMask)))
 
 /**
  * pointer to last element
  *
  * \param
  * a dynamic array
  */
 #define dArrayLastPtr(a) ((typeof((a)->element)*)((a)->buffers[((a)->last-1)>>dArrayBits])+(((a)->last-1)&dArrayMask))
 
 /**
  * index of last element
  */
 #define dArrayLastIndex(a) ((a)->last-1)
 
 /**
  * direct access to the last element index variable for assignments
  */
 #define dArrayLastIndexVar(a) ((a)->last)
 
 /**
  * first element
  *
  * \param
  * a dynamic array
  */
 #define dArrayFirst(a) (*((typeof((a)->element)*)((a)->buffers[((a)->head)>>dArrayBits])+((a)->head)&dArrayMask))
 
 /**
  * index of first element
  */
 #define dArrayFirstIndex(a) ((a)->head)
 
 /**
  * write the dArray content to filename file
  * No NULL checks are done on the parameters
  *
  * \param
  *    filename file name string
  */
 #define dArrayWriteFilename(a, filename) do {\
     FILE *UNIQVAR(f) = fopen(filename, "w");\
     if (UNIQVAR(f)) {\
       range(UNIQVAR(i), (size_t)dArrayCount(a)) {\
         typeof((a)->element) *firstElement = (a)->buffers[UNIQVAR(i)/dArraySz];\
         fwrite(firstElement+(UNIQVAR(i)%dArraySz), 1, sizeof((a)->element), UNIQVAR(f));\
       }\
       fclose(UNIQVAR(f));\
     }\
   } while(0)
 
 /**
  * write the dArray content to disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define dArrayWrite(a, file) do {\
     range(UNIQVAR(i), (size_t)dArrayCount(a)) {\
       typeof((a)->element) *firstElement = (a)->buffers[UNIQVAR(i)/dArraySz];\
       fwrite(firstElement+(UNIQVAR(i)%dArraySz), 1, sizeof((a)->element), file);\
     }\
   } while(0)
 
 /**
  * read a dArray from filename file
  * No NULL checks are done on the parameters
  *
  * \param
  * filename file name string
  */
 #define dArrayReadFilename(a, filename) do {\
     if (fileExists(filename)) {\
       size_t UNIQVAR(sz) = fileSize(filename);\
       FILE *UNIQVAR(f) = fopen(filename, "r");\
       if (UNIQVAR(f)) {\
         range(UNIQVAR(i), UNIQVAR(sz)/sizeof((a)->element)) {\
           dArrayPush(a);\
           fread(dArrayLastPtr(a), 1, sizeof((a)->element), UNIQVAR(f));\
         }\
         fclose(UNIQVAR(f));\
       }\
     }\
   } while(0)
 
 /**
  * read a dArray from disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define dArrayRead(a, file) do {\
     fseek(file, 0 , SEEK_END);\
     size_t UNIQVAR(sz) = ftell(file);\
     fseek(file, 0 , SEEK_SET);\
     range(UNIQVAR(i), UNIQVAR(sz)/sizeof((a)->element)) {\
       dArrayPush(a);\
       fread(dArrayLastPtr(a), 1, sizeof((a)->element), file);\
     }\
   } while(0)
 
 /**
  * loop on dArray elements
  * element is a pointer to a value in the array
  *
  * dArrayForEach(&a, e) {
  *    e->x = 0;
  * }
  */
 #define dArrayForEach(name, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = (name)->head; \
   for (dArrayElemPtrType(name) element = dArrayPtr(name, (name)->head) ; UNIQVAR(libsheepyInternalIndex) < (name)->last + 1 ; UNIQVAR(libsheepyInternalIndex)++, element = dArrayPtr(name, UNIQVAR(libsheepyInternalIndex)))
 
 /**
  * enumerate dArray elements
  * index is the position of the element in the array
  * index is declared as size_t and is available after the loop
  * element is a pointer to a value in the array
  *
  * dArrayEnumerate(&a, i, e) {
  *    e->x = 0;
  *    printf("dArrayEnumerate %d\n", i);
  * }
  */
 #define dArrayEnumerate(name, index, element) \
   ; size_t index = (name)->head; \
   for (dArrayElemPtrType(name) element = dArrayPtr(name, (name)->head) ; index < (name)->last + 1 ; index++, element = dArrayPtr(name, index))
 
 
 
 /*
  * end dynamic array
  */
 
 
 /**
  * slab - dynamic array in one chunk of memory
  *
  * slab supports shrinking through slabResize, the slab is reset when head or last are outside the new size
  * slab has head and last indexes, this allows dequeuing from head elements fast
  *
  * this type of array has a dynamic element count
  * pushing elements into the array increases the element count
  *
  * no sanity checks are done
  *
  * usage examples: regular array, stack, lifo, fifo
  *
  * the prefix is slab
  *
  * Usage:
  *
  * to declare an array:
  *
  * slabT(typeName, type);
  *
  * typeName slab;
  *
  * slabInit(&slab);
  * or
  * slabInitCount(&slab, 17);
  *
  * slabAppend(&slab, value);
  *
  * // get an element
  * int a                = slabAt(&slab, 0);
  *
  * set
  * slabAt(&slab, 1) = 3;
  *
  * slabFree(&slab);
  *
  * Slab variables:
  * slab.array:     elements
  * slab.maxCount:  maximum element count allowed
  *
  * Note: some functions are macros to be able to have structs as element and
  *       access the struct members directly, for example:
  *         slabLast(chan).a = 0;
  */
 
 /** number of elements added by slabAlloc */
 #define slabSz 64
 
 /**
  * declares type for dynamic array
  *
  * \param
  * typeName slab type name
  * \param
  * element type of elements (int, struct, pointer...)
  */
 #define slabT(typeName, elementType)\
   typedef struct {\
     int64_t      last;\
     int64_t      head;\
     int64_t      maxCount;\
     elementType *array;\
   } typeName
 
 
 #define createSlab(typeName, name) ;typeName name; slabInit(&name)
 
 #define createSlabCount(typeName, name, count) ;typeName name; slabInitCount(&name, count)
 
 /**
  * initialize dynamic array with minimum element count
  *
  * \param
  * a variable name for slab
  */
 #define slabInit(a) do{\
     (a)->last = (a)->head = 0;\
     (a)->array            = malloc(sizeof(*((a)->array)) * slabSz);\
     (a)->maxCount         = slabSz;\
   }while(0)
 
 
 /**
  * initialize slab and count
  *
  * \param
  * a variable name for slab
  * \param
  * count initial element count for name type
  */
 #define slabInitCount(a, count) do{\
     var UNIQVAR(c)        = count;\
     (a)->last = (a)->head = 0;\
     (a)->array            = malloc(sizeof(*((a)->array)) * UNIQVAR(c));\
     (a)->maxCount         = UNIQVAR(c);\
   }while(0)
 
 #define slabResize(a, count) do{\
     var UNIQVAR(c)        = count;\
     (a)->array            = realloc((a)->array, sizeof(*((a)->array)) * UNIQVAR(c));\
     (a)->maxCount         = UNIQVAR(c);\
     if (((a)->last >= (a)->maxCount) || ((a)->head >= (a)->maxCount)) {\
       /* shrinking error - head or last outside the new array, reset to 0 */\
       (a)->last = (a)->head = 0;\
     }\
   }while(0)
 
 /**
  * free the internal buffers
  *
  * \param
  * a slab
  */
 #define slabFree sliceFree
 
 /**
  * element type in array
  */
 #define slabElemType(name) typeof((name)->array[0])
 
 /**
  * element pointer type in array
  */
 #define slabElemPtrType(name) typeof(&(name)->array[0])
 
 /**
  * Empty Array
  */
 #define slabEmpty(name) do{\
     (name)->last = (name)->head = 0;\
   } while(0);
 
 /**
  * is Array Empty
  */
 #define slabIsEmpty(name) ((name)->head == (name)->last)
 
 /**
  * return element count
  */
 #define slabCount(name) ((name)->last - (name)->head)
 
 /**
  * return max element count
  */
 #define slabMaxCount vectorMaxCount
 
 /**
  * allocate buffer for new elements
  * only when the slab is full
  *
  * \param
  * a dynamic array
  */
 #define slabAlloc(a) do{\
     if ((a)->last == slabMaxCount(a)) {\
       (a)->maxCount += slabSz;\
       slabResize(a, (a)->maxCount);\
     }\
   }while(0)
 
 /**
  * push element and expand the slab
  * no data (random) is set in the new element
  *
  * \param
  * a slab
  */
 #define slabPush(a) do{\
     slabAlloc(a);\
     (a)->last++;\
   }while(0)
 
 /**
  * append element and expand the slab
  *
  * \param
  * a slab
  * \param
  * v element to push
  */
 #define slabAppend(a, v) do{\
     slabAlloc(a);\
     if ((a)->last < slabMaxCount(a)) {\
       *( (a)->array + (a)->last ) = v;\
       (a)->last++;\
     }\
   }while(0)
 
 /**
  * pop element
  * the index of the last element is decreased
  *
  * NOTE: using comma operator to avoid warning
  * warning: operation on ‘b.head’ may be undefined [-Wsequence-point]
  *
  *
  * \param
  * a slab
  */
 #define slabPop(a) ((a)->last--, *((a)->array + (a)->last))
 
 /**
  * delete the last element
  * useful for avoiding warning: right-hand operand of comma expression has no effect
  * when the poped value is not used
  */
 #define slabDelLast(a) ((a)->last--)
 
 /**
  * prepend element
  *
  * \param
  * a slab
  * \param
  * v element to prepend
  */
 #define slabPrepend(a, v) do{\
     if ((a)->head > 0) {\
       (a)->head--;\
       *( (a)->array + (a)->head ) = v;\
     }\
   }while(0)
 
 /**
  * dequeue element
  * the index of the head element is increased
  *
  * NOTE: using comma operator to avoid warning
  * warning: operation on ‘b.head’ may be undefined [-Wsequence-point]
  *
  *
  * \param
  * a slab
  */
 #define slabDequeue(a) ((a)->head++, *((a)->array + (a)->head -1))
 
 /**
  * delete the first element
  * useful for avoiding warning: right-hand operand of comma expression has no effect
  * when the dequeued value is not used
  */
 #define slabDelFirst(a) ((a)->head++)
 
 /**
  * get / set element at index
  *
  * \param
  * a slab
  * \param
  * index index in array
  */
 #define slabAt sliceAt
 
 /**
  * get pointer to element at index
  *
  * \param
  * a slab
  * \param
  * index index in array
  */
 #define slabPtr slicePtr
 
 /**
  * last element
  *
  * \param
  * a slab
  */
 #define slabLast(a) (*((a)->array + (a)->last -1))
 
 /**
  * pointer to last element
  *
  * \param
  * a slab
  */
 #define slabLastPtr(a) ((a)->array + (a)->last -1)
 
 /**
  * index of last element
  */
 #define slabLastIndex(a) ((a)->last-1)
 
 /**
  * direct access to the last element index variable for assignments
  */
 #define slabLastIndexVar(a) ((a)->last)
 
 /**
  * first element
  *
  * \param
  * a slab
  */
 #define slabFirst(a) (*((a)->array + (a)->head))
 
 /**
  * index of first element
  */
 #define slabFirstIndex(a) ((a)->head)
 
 /**
  * write the slab content to filename file
  * No NULL checks are done on the parameters
  *
  * \param
  *    filename file name string
  */
 #define slabWriteFilename(a, filename) do {\
     FILE *UNIQVAR(f) = fopen(filename, "w");\
     if (UNIQVAR(f)) {\
       fwrite((a)->array + (a)->head, 1, sizeof(*((a)->array)) * slabCount(a), UNIQVAR(f));\
       fclose(UNIQVAR(f));\
     }\
   } while(0)
 
 /**
  * write the slab content to disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define slabWrite(a, file) fwrite((a)->array + (a)->head, 1, sizeof(*((a)->array)) * slabCount(a), file)
 
 /**
  * read a slab from filename file
  * No NULL checks are done on the parameters
  *
  * \param
  * filename file name string
  */
 #define slabReadFilename(a, filename) do {\
     if (fileExists(filename)) {\
       size_t UNIQVAR(sz) = fileSize(filename);\
       FILE *UNIQVAR(f) = fopen(filename, "r");\
       if (UNIQVAR(f)) {\
         range(UNIQVAR(i), UNIQVAR(sz)/sizeof(*((a)->array))) {\
           slabPush(a);\
           fread(slabLastPtr(a), 1, sizeof(*((a)->array)), UNIQVAR(f));\
         }\
         fclose(UNIQVAR(f));\
       }\
     }\
   } while(0)
 
 /**
  * read a slab from disk
  * No NULL checks are done on the parameters
  *
  * \param
  *    file already opened file
  */
 #define slabRead(a, file) do {\
     fseek(file, 0 , SEEK_END);\
     size_t UNIQVAR(sz) = ftell(file);\
     fseek(file, 0 , SEEK_SET);\
     range(UNIQVAR(i), UNIQVAR(sz)/sizeof(*((a)->array))) {\
       slabPush(a);\
       fread(slabLastPtr(a), 1, sizeof(*((a)->array)), file);\
     }\
   } while(0)
 
 /**
  * loop on slab elements
  * element is a pointer to a value in the array
  *
  * slabForEach(&a, e) {
  *    e->x = 0;
  * }
  */
 #define slabForEach(name, element) \
   ;size_t UNIQVAR(libsheepyInternalIndex) = (name)->head; \
   for (slabElemPtrType(name) element = slabPtr(name, (name)->head) ; UNIQVAR(libsheepyInternalIndex) < (name)->last + 1 ; UNIQVAR(libsheepyInternalIndex)++, element = slabPtr(name, UNIQVAR(libsheepyInternalIndex)))
 
 /**
  * enumerate slab elements
  * index is the position of the element in the array
  * index is declared as size_t and is available after the loop
  * element is a pointer to a value in the array
  *
  * slabEnumerate(&a, i, e) {
  *    e->x = 0;
  *    printf("slabEnumerate %d\n", i);
  * }
  */
 #define slabEnumerate(name, index, element) \
   ; size_t index = (name)->head; \
   for (slabElemPtrType(name) element = slabPtr(name, (name)->head) ; index < (name)->last + 1 ; index++, element = slabPtr(name, index))
 
 
 /*
  * end slab
  */
 
 
 /**
  * static bitset
  *
  * no sanity checks are done
  *
  * Usage:
  *
  * staticBitsetT(typeName, u64 , 8);
  *
  * typeName bits;
  *
  * staticBitsetInit(&bits);
  *
  * staticBitset1(&bits, index);
  *
  * bool bit = staticBitsetGet(&bits, index);
  *
  */
 
 /**
  * typedef for staticBitset
  *
  * \param
  *   typeName typedef name
  * \param
  *   containerType element type in array: u8, u16, u32, u64...
  * \param
  *   count bit count in array
  */
 #define staticBitsetT(typeName, containerType, count)\
   typedef struct {containerType map[BUCKETS(count, 8 * sizeof(containerType))];} typeName;
 
 #define staticBitsetInit staticBitsetClear
 
 /** bitset count */
 #define staticBitsetCount(name) (sizeof((name)->map) * 8)
 
 /** clear all bits in bitset */
 #define staticBitsetClear(name) memset(name, 0, sizeof(*(name)));
 
 /** bucket containing bit at given index */
 #define staticBitsetBucket(name, index) (name)->map[index / (8 * sizeof((name)->map[0]))]
 
 /** set 0 at index */
 #define staticBitset0(name, index) do{\
     var UNIQVAR(idx)         = index;\
     size_t byteOffset        = UNIQVAR(idx) / (8 * sizeof((name)->map[0]));\
     size_t bitOffset         = UNIQVAR(idx) % (8 * sizeof((name)->map[0]));\
     (name)->map[byteOffset] &= 0xFFFFFFFFFFFFFFFFUL ^ (1UL<<bitOffset);\
   } while(0)
 
 /** set 1 at index*/
 #define staticBitset1(name, index) do{\
     var UNIQVAR(idx)         = index;\
     size_t byteOffset        = UNIQVAR(idx) / (8 * sizeof((name)->map[0]));\
     size_t bitOffset         = UNIQVAR(idx) % (8 * sizeof((name)->map[0]));\
     (name)->map[byteOffset] |= 1UL<<bitOffset;\
   } while(0)
 
 /** set bit value at index*/
 #define staticBitsetSet(name, index, value) do{\
     var UNIQVAR(idx)         = index;\
     size_t byteOffset        = UNIQVAR(idx) / (8 * sizeof((name)->map[0]));\
     size_t bitOffset         = UNIQVAR(idx) % (8 * sizeof((name)->map[0]));\
     /* performance is about the same as the if version with gcc 6.3 on skylake cpu, use the less obscure version - (name)->map[byteOffset]  = ( (name)->map[byteOffset] & ~(1UL<<bitOffset)) | (-(value) & (1UL<<bitOffset));*/\
     if (!value)\
       (name)->map[byteOffset] &= 0xFFFFFFFFFFFFFFFFUL ^ (1UL<<bitOffset);\
     else\
       (name)->map[byteOffset] |= 1UL<<bitOffset;\
   } while(0)
 
 /** invert bit at index */
 #define staticBitsetInv(name, index) do{\
     var UNIQVAR(idx)         = index;\
     size_t byteOffset        = UNIQVAR(idx) / (8 * sizeof((name)->map[0]));\
     size_t bitOffset         = UNIQVAR(idx) % (8 * sizeof((name)->map[0]));\
     (name)->map[byteOffset] ^= 1UL<<bitOffset;\
   } while(0)
 
 /** get bit at index */
 #define staticBitsetGet(name, index) ({\
     var UNIQVAR(idx)  = index;\
     size_t byteOffset = UNIQVAR(idx) / (8 * sizeof((name)->map[0]));\
     size_t bitOffset  = UNIQVAR(idx) % (8 * sizeof((name)->map[0]));\
     ((name)->map[byteOffset] & (1UL<<bitOffset)) == 1UL<<bitOffset;\
   })
 
 /**
  * end static bitset
  */
 
 /**
  * bitset
  * the underlying array is defined in the provided at macro or function
  *
  * no sanity checks are done
  *
  * a dynamic bitset can be created using slice and sliceAt
  */
 
 #define bitsetModulo 8
 
 /** bucket containing bit at given index */
 #define bitsetBucket(name, index) (name)->map[index / (bitsetModulo)]
 
 /** set 0 at index
  * at must be macro or function taking 2 parameters:
  * at(name, intIndex)
  * and point to value at intIndex
  */
 #define bitset0(name, at, index) do{\
     var UNIQVAR(idx)         = index;\
     size_t byteOffset        = UNIQVAR(idx) / (bitsetModulo);\
     size_t bitOffset         = UNIQVAR(idx) % (bitsetModulo);\
     at(name, byteOffset)    &= 0xFFFFFFFFFFFFFFFFUL ^ (1UL<<bitOffset);\
   } while(0)
 
 /** set 1 at index
  * at must be macro or function taking 2 parameters:
  * at(name, intIndex)
  * and point to value at intIndex
  */
 #define bitset1(name, at, index) do{\
     var UNIQVAR(idx)         = index;\
     size_t byteOffset        = UNIQVAR(idx) / (bitsetModulo);\
     size_t bitOffset         = UNIQVAR(idx) % (bitsetModulo);\
     at(name, byteOffset)    |= 1UL<<bitOffset;\
   } while(0)
 
 /** set bit value at index
  * at must be macro or function taking 2 parameters:
  * at(name, intIndex)
  * and point to value at intIndex
  */
 #define bitsetSet(name, at, index, value) do{\
     var UNIQVAR(idx)         = index;\
     size_t byteOffset        = UNIQVAR(idx) / (bitsetModulo);\
     size_t bitOffset         = UNIQVAR(idx) % (bitsetModulo);\
     /* performance is about the same as the if version with gcc 6.3 on skylake cpu, use the less obscure version - at(name, byteOffset)     = ( at(name, byteOffset) & ~(1UL<<bitOffset)) | (-(value) & (1UL<<bitOffset)); */\
     if (!value)\
       at(name, byteOffset) &= 0xFFFFFFFFFFFFFFFFUL ^ (1UL<<bitOffset);\
     else\
       at(name, byteOffset) |= 1UL<<bitOffset;\
   } while(0)
 
 /** invert bit at index
  * at must be macro or function taking 2 parameters:
  * at(name, intIndex)
  * and point to value at intIndex
  */
 #define bitsetInv(name, at, index) do{\
     var UNIQVAR(idx)         = index;\
     size_t byteOffset        = UNIQVAR(idx) / (bitsetModulo);\
     size_t bitOffset         = UNIQVAR(idx) % (bitsetModulo);\
     at(name, byteOffset)    ^= 1UL<<bitOffset;\
   } while(0)
 
 /**
  * get bit at index
  * at must be macro or function taking 2 parameters:
  * at(name, intIndex)
  * and return the value at intIndex
  */
 #define bitsetGet(name, at, index) ({\
     var UNIQVAR(idx)  = index;\
     size_t byteOffset = UNIQVAR(idx) / (bitsetModulo);\
     size_t bitOffset  = UNIQVAR(idx) % (bitsetModulo);\
     (at(name, byteOffset) & (1UL<<bitOffset)) == 1UL<<bitOffset;\
   })
 
 /**
  * end bitset
  */
 
 /**
  * bitfield array
  *
  * a field is a group of bit representing an int stored in a larger int
  *
  * bitfield array is an array of fields (short int) similar to bitset
  *
  * Example:
  *
  * u64 v = 0;             // field storage
  * FIELD_SET(v, 3, 1, 0); // field is 2 bits from bit 0 to bit 1, set value 3
  *
  * u8 field = FIELD_GET(v, 1, 0); // get value in field at bit 0 to 1
  *
  * // declare a bitfield array
  * // the array has 256 elements and each element is a 2 bit integer
  * BITFIELD_VAR(bitfields, 256, 2) = init0Var;
  *
  * // set value for element at index 255
  * BITFIELD_SET(bitfields, 255, 3, 2);
  * // get value for element at index 255
  * v = BITFIELD_GET(bitfields, 255, 2);
  *
  */
 
 /**
  * set bitfield value in destination (opposite of EXTRACT macro)
  *
  * only bits between msb and lsb are set in dst
  *
  * \param
  *   dst destination, unsigned integer (u8, u16, u32, u64)
  * \param
  *   val value to set, the value is shifted to lsb
  * \param
  *   msb most significant bit in dst to be set
  * \param
  *   lsb least significant bit in dst to be set
  */
 #define FIELD_SET(dst, val, msb, lsb) dst = (/*clear field in dst*/ (dst) & ((0xFFFFFFFFFFFFFFFEUL << (msb)) | ((1UL<<(lsb))-1) )) | (/*clear highest bits in val and shift to field lsb*/(~(0xFFFFFFFFFFFFFFFEUL << ((msb)-(lsb))) & (val)) << (lsb))
 
 #define FIELD_GET EXTRACT
 
 /**
  * set bitfield value in destination, given bitfield index and length
  *
  * (index+1)*len-1 must be lower or equal to 8*sizeof(dst),
  * otherwise val will be truncated
  *
  * \param
  *   dst destination, unsigned integer (u8, u16, u32, u64)
  * \param
  *   index index of the bitfield in dst (bit index*len is lsb)
  * \param
  *   val value to set, the value is shifted to lsb
  * \param
  *   len bitfield length in dst
  */
 #define FIELD_SETL(dst, index, val, len) FIELD_SET(dst, val, ((index)+1)*(len)-1, (index)*(len))
 
 /**
  * set bitfield value in array of bitfields
  * the boundaries are not checked
  *
  * \param
  *   array array of u64
  * \param
  *   index index of the bitfield in array (bit index*len is lsb)
  * \param
  *   val value to set, the value is shifted to the correct position
  * \param
  *   len bitfield length in array, must divide 64 (2, 4, 8, 16, 32)
  */
 #define BITFIELD_SET(array, index, val, len) FIELD_SET((array)[((index)*(len))/64], val, ((index)*(len))%64+(len)-1, ((index)*(len))%64)
 
 /**
  * get bitfield value in array of bitfields
  * the boundaries are not checked
  *
  * \param
  *   array array of u64
  * \param
  *   index index of the bitfield in array (bit index*len is lsb)
  * \param
  *   len bitfield length in array, must divide 64 (2, 4, 8, 16, 32)
  */
 #define BITFIELD_GET(array, index, len) EXTRACT((array)[((index)*(len))/64], ((index)*(len))%64+(len)-1, ((index)*(len))%64)
 
 /**
  * return number of u64 necessary to hold count bitfields of length len
  */
 #define BITFIELD_SIZE(count, len, containerType) BUCKETS((count)*(len), 8 * sizeof(containerType))
 
 /**
  * declare an array to hold count bitfields of length len
  */
 #define BITFIELD_VAR(array, count, len) u64 array[BITFIELD_SIZE(count, len, u64)]
 
 /**
  * end bitfield
  */
 
 // get monotonic time in ns
 uint64_t getMonotonicTime(void) MUST_CHECK;
 
 // sleep nanoseconds
 int nanoSleepF(uint64_t time) MUST_CHECK;
 #define nanoSleep(time) pError0(nanoSleepF(time))
 
 /** sleep nanoseconds */
 #define nanoSleep(time) pError0(nanoSleepF(time))
 
 /** nanoSleep and error code */
 #define nanoSleepE(time, cmd) pErrorCmd(nanoSleepF(time), == 0, cmd)
 
 /** sleep microseconds */
 #define usSleep(time) pError0(nanoSleepF(1000 * (uint64_t)time))
 
 /** sleep miliseconds */
 #define msSleep(time) pError0(nanoSleepF(1000000 * (uint64_t)time))
 
 
 #ifdef __GNUC__
 #define UNUSED __attribute__ ((unused))
 #define DEPRECATED __attribute__ ((deprecated))
 #define PACKED __attribute__((__packed__))
 
 /**
  * cleanup calls a function when the variable is out of scope
  *
  * Also checkout the clean* macros using the cleanup attribute (cleanCharP, ...)
  *
  * Example:
  * void cleanUp(int *val) {
  *   logVarG(*val);
  * }
  * int a CLEANUP(cleanUp) = 1;
  * a++;
  *
  * The cleanUp function is called when the variable a is out of scope
  *
  */
 #define CLEANUP(func) __attribute__((cleanup(func)))
 
 /**
  * suppress warning: this statement may fall through [-Wimplicit-fallthrough=]
  *
  *    switch (cond)
  *    {
  *    case 1:
  *      bar (0);
  *      FALLTHRU;
  *    default:
  *    }
  */
 #if __GNUC__ >= 7
 #define FALLTHRU __attribute__ ((fallthrough))
 #else
 #define FALLTHRU
 #endif
 
 /** always inline function */
 #define AINLINE         inline __attribute__ ((always_inline))
 
 /** never inline function */
 #define NOINLINE      __attribute__ ((noinline))
 
 /**
  * pure function (no effect on assembly code with gcc 10)
  * a pure function is one that has no side effects and whose return value reflects only
  * the function's parameters or nonvolatile global variables.
  * Any parameter or global variable access must be read-only
  */
 //#define PURE          __attribute__ ((pure))
 
 /**
  * const function (no effect on assembly code with gcc 10)
  * a const function is a pure function that cannot access global variables
  * and cannot take pointers as parameters.
  */
 //#define CONST         __attribute__ ((const))
 
 /** function that always terminate the program, the compile optimizes the caller code better */
 #define NORETURN      __attribute__ ((noreturn))
 
 /** function returning a pointer to a newly allocated buffer */
 #define AMALLOC       __attribute__ ((malloc))
 
 /** mark a function as used */
 #define USED          __attribute__ ((used))
 
 /** force alignment */
 #define ALIGN(X)      __attribute__ ((aligned, (x)))
 #define ALIGN_MAX     __attribute__ ((aligned))
 
 /** branch anotation (use profile feedback-directed optimization instead) */
 //#define likely(x)       __builtin_expect (!!(x), 1)
 //#define unlikely(x)     __builtin_expect (!!(x), 0)
 
 #else
 #define UNUSED
 #define DEPRECATED
 #define PACKED
 #define CLEANUP
 #define FALLTHRU
 #define AINLINE
 #define NOINLINE
 #define PURE
 #define CONST
 #define NORETURN
 #define AMALLOC
 #define MUST_CHECK
 #define USED
 #define ALIGN(X)
 #define ALIGN_MAX
 #define likely(x)    (x)
 #define unlikely(x)  (x)
 #endif
 
 #endif // _libsheepyH
 // vim: set expandtab ts=2 sw=2: