libsheepy.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2023 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__)
#include <immintrin.h>
#endif // #if !defined(__arm__) && !defined(__aarch64__)
#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>

// version accoring to the version package: Release.Major.minor.patch
// https://noulin.net/version/file/README.md.html
#define LIBSHEEPY_VERSION "2.2.12.1"

#ifndef SH_PREFIX
#define SH_PREFIX(NAME) NAME
#endif

// libsheepy API Header file _libsheepyH

#define internal static

#define local static

#define var __auto_type

#undef TRUE /* avoid conflict with ncurses */
extern const bool TRUE;
#undef FALSE /* avoid conflict with ncurses */
extern const bool FALSE;

#define null NULL
#define yes true
#define on true
#define no false
#define off false

#define boolS(x) x ? "TRUE" : "FALSE"

#define XSUCCESS exit(EXIT_SUCCESS);
#define XSuccess XSUCCESS

#define XFAILURE exit(EXIT_FAILURE);
#define XFailure XFAILURE

#define logXSuccess(string) MACRO(\
    logP("Success: %s", string);\
    XSuccess;\
  )

#define logXSuccessf(format, ...) MACRO(\
    logP(format, __VA_ARGS__);\
    XSuccess;\
  )

#define logXFailure(string) MACRO(\
    logC("Failed: %s", string);\
     XFailure;\
   )

#define logXFailuref(format, ...) MACRO(\
    logC(format, __VA_ARGS__);\
    XFailure;\
  )

#define logExit(exitCode, string) MACRO (\
    logI("Exit: %s", string);\
    exit(exitCode);\
  )

#define exitFailure(cond) \
  if (!cond) \
    exit(EXIT_FAILURE);


#define procbegin do{
#define procend   }while(0)
#define funcbegin ({
#define funcend  })

#define MACRO( STATEMENTS ) do { STATEMENTS } while(0)

#define FUNC( STATEMENTS) ({ STATEMENTS })

#define is =
#define equals ==
#define nequal !=
#define shr >>
#define shl <<
#define inc ++
#define dec --
#define ptr_to &
#define val_of *

#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

#define pFuncError do{ if ((libsheepyErrorMask) & logMask) { shperror(__func__);logEBtrace;} }while(0);

#define pStrError(str) do{ if ((libsheepyErrorMask) & logMask) { shperror(str);logEBtrace;} }while(0);

#define shPrintError do{ if ((libsheepyErrorMask) & logMask) { logE("Error line "stringifyExpr(__LINE__)", function %s, file "__FILE__"\n", __func__); logEBtrace;} }while(0);

#define pError(func) if (func == -1) shPrintError

#define pError0(func) if (func == 0) shPrintError

#define pErrorNot0(func) if (func != 0) shPrintError

#define pErrorNULL(func) if (func == NULL) shPrintError

#define pErrorValue(func, errorValue) if (func == errorValue) shPrintError

#define pTestError(test) if (test) shPrintError

#define pTestErrorCmd(test, cmd) if (test) { shPrintError cmd; }

#define pErrorCmd(func, test, cmd) if (func test) { shPrintError cmd; }

#define pErrorResult(result, func, test) if ((result = func) test) shPrintError

#define pErrorResultCmd(result, func, test, cmd) if ((result = func) test) { shPrintError cmd; }

#define isError(assigned, left) if (!(assigned = left))

#define maxTryThrowCount 16
extern jmp_buf tryJumpBuffers[maxTryThrowCount];

#define setJump(slot) setjmp(tryJumpBuffers[slot])

#define try(slot) if (!setjmp(tryJumpBuffers[slot]))

#define throw(slot) longjmp(tryJumpBuffers[slot], 1)

#define tryV(result, slot) if (!(result = setjmp(tryJumpBuffers[slot])))

#define throwV(slot, value) longjmp(tryJumpBuffers[slot], value)

// limited use macro - for test only
#define goNLabel(go, label) goto go; label:

#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

#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

#define EXTRACT(x, msb, lsb) ((~(0xFFFFFFFFFFFFFFFEUL << (msb)) & (x)) >> (lsb))

#define CMP(a, b) ({\
    var UNIQVAR(_a) = a;\
    var UNIQVAR(_b) = b;\
    UNIQVAR(_a) > UNIQVAR(_b) ? 1 : UNIQVAR(_a) < UNIQVAR(_b) ? -1 : 0;\
    })

#define init0Var {0}

#define ZEROVAR(name) zeroBuf(&(name), sizeof(name))

#define BUCKETS(count, divider) ((count)/(divider) + (((count) % (divider)) ? 1 : 0))

#define swapV(a, b) do{\
    var UNIQVAR(swaptmp) = a;\
    a = b;\
    b = UNIQVAR(swaptmp);\
  } while(0)

#define setMax(result, a, b) do{\
    var UNIQVAR(_a) = a;\
    var UNIQVAR(_b) = b;\
    result = MAX(UNIQVAR(_a), UNIQVAR(_b));\
  } while(0)

#define setMin(result, a, b) do{\
    var UNIQVAR(_a) = a;\
    var UNIQVAR(_b) = b;\
    result = MIN(UNIQVAR(_a), UNIQVAR(_b));\
  } while(0)

#define maxV(a, b) ({\
    var UNIQVAR(_a) = a;\
    var UNIQVAR(_b) = b;\
    MAX(UNIQVAR(_a), UNIQVAR(_b));\
  })

#define minV(a, b) ({\
    var UNIQVAR(_a) = a;\
    var UNIQVAR(_b) = b;\
    MIN(UNIQVAR(_a), UNIQVAR(_b));\
  })

#define absV(a) ({var UNIQVAR(_a) = a; ((UNIQVAR(_a)) < 0) ? -(UNIQVAR(_a)) : (UNIQVAR(_a));})

#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))

#define isIntOdd(value) (value&1)

#define isIntEven(value) (!(value&1))

#define typ typedef

#define ret return

#define elif else if

#define unless(cond) if(not(cond))

#define until(cond) while(not(cond))


#define cast(type, casted, toCast) type casted = (type) (toCast);

#define freen(ptr) do {\
    free(ptr);\
    (ptr) = NULL;\
  } while(0)

#define EVA(var, func) (var = func, var)

#define loopBreakerInit\
  uint32_t libsheepyLoopCounter = 0;\
  bool didBreak = false;

#define loopBreakerReset\
  libsheepyLoopCounter = 0;\
  didBreak = false;

#define loopBreaker(breakCount)\
  libsheepyLoopCounter++;\
  if(libsheepyLoopCounter>breakCount){didBreak=true;break;}

#define FILE_LINE __FILE__":"stringifyExpr(__LINE__)
#define PFILE_LINE puts(FILE_LINE)

#define AT pLog(LOG_DEBUG, __FILE__", %s:"stringifyExpr(__LINE__)"\n",__func__);

#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);

#define cleanCharP(name) char *name CLEANUP(cleanUpCharFree)

// free val when it is out of scope
void cleanUpListFree(char*** val);

#define cleanListP(name) char **name CLEANUP(cleanUpListFree)

// free val when it is out of scope
void cleanUpFileFree(FILE **val);

#define cleanFileP(name) FILE *name CLEANUP(cleanUpFileFree)

// close val when it is out of scope
void cleanUpFd(int *val);

#define cleanFd(name) int name CLEANUP(cleanUpFd)
#define cleanFdInit(name) int name CLEANUP(cleanUpFd) = -1

#define logVar(var, format) logD("%s=%" format, stringifyExpr(var), var);
#define logMVar(mask, var, format) logMD(mask, "%s=%" format, stringifyExpr(var), var);

#define logBoolVar(var) logVar(var, "b");
#define logMBoolVar(mask, var) logMVar(mask, var, "b");

#define logPtr(pointer) logD("%s=%p", stringifyExpr(pointer), pointer);
#define logMPtr(mask, pointer) logMD(mask, "%s=%p", stringifyExpr(pointer), pointer);

// colors and effects
#define RST "\x1B[0m"

#define BLD "\x1B[1m"

#define FNT "\x1B[2m"

#define ITL "\x1B[3m"

#define UDL "\x1B[4m"

#define BLI "\x1B[5m"

#define INV "\x1B[7m"

#define COC "\x1B[8m"

#define CRD "\x1B[9m"

// foreground
#define BLK "\x1B[30m"

#define RED "\x1B[31m"

#define GRN "\x1B[32m"

#define YLW "\x1B[33m"

#define BLU "\x1B[34m"

#define MGT "\x1B[35m"

#define CYN "\x1B[36m"

#define WHT "\x1B[37m"

// background
#define BGBLK "\x1B[40m"

#define BGRED "\x1B[41m"

#define BGGRN "\x1B[42m"

#define BGYLW "\x1B[43m"

#define BGBLU "\x1B[44m"

#define BGMGT "\x1B[45m"

#define BGCYN "\x1B[46m"

#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))

#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"

#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)

#define timeUs(func) timeDivs(func,1E3, TIMEUNITUS)

#define timeMs(func) timeDivs(func,1E6, TIMEUNITMS)

#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)

#define stopwatchLog printf(BLD GRN "time" RST ": %" PRIu64 "ns\n", shStopwatch(1))

#define stopwatchLogDivs(div, timeunit) printf(BLD GRN "time" RST ": %f"timeunit"\n", ((float)shStopwatch(1))/div)

#define stopwatchLogUs stopwatchLogDivs(1E3, TIMEUNITUS)

#define stopwatchLogMs stopwatchLogDivs(1E6, TIMEUNITMS)

#define stopwatchLogSec stopwatchLogDivs(1E9, TIMEUNITSC)

#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

#define LOG_DISABLE -1

#define LOG_VERBOSE       0

#define LOG_CONCISE       1

#define LOG_DATE          2 // default

#define LOG_FUNC          3

#define LOG_PROG          4

#define LOG_PROGNDATE     5

#define LOG_VOID          6

#define LOG_UTF8          7

#define LOG_PROGNFUNC     8

#define LOG_INVALID_MODE  9

// add a log file, maximum 15 files
FILE *SH_PREFIX(setLogFile)(char *filename);
#define openLogFile setLogFile

#ifdef __GNUC__

#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);

#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__)

#define logSY(format, string) do {\
    char *libsheepyInternalString = string;\
    logY(format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSA(format, string) do {\
    char *libsheepyInternalString = string;\
    logA(format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSC(format, string) do {\
    char *libsheepyInternalString = string;\
    logC(format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSE(format, string) do {\
    char *libsheepyInternalString = string;\
    logE(format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSW(format, string) do {\
    char *libsheepyInternalString = string;\
    logW(format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSN(format, string) do {\
    char *libsheepyInternalString = string;\
    logN(format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSP(format, string) do {\
    char *libsheepyInternalString = string;\
    logP(format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSI(format, string) do {\
    char *libsheepyInternalString = string;\
    logI(format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define  logSD(format, string) do {\
    char *libsheepyInternalString = string;\
    logD(format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)


extern uint64_t logMask;

#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)

#define logSMY(mask, format, string) do {\
    char *libsheepyInternalString = string;\
    logMY(mask, format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSMA(mask, format, string) do {\
    char *libsheepyInternalString = string;\
    logMA(mask, format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSMC(mask, format, string) do {\
    char *libsheepyInternalString = string;\
    logMC(mask, format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSME(mask, format, string) do {\
    char *libsheepyInternalString = string;\
    logME(mask, format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSMW(mask, format, string) do {\
    char *libsheepyInternalString = string;\
    logMW(mask, format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSMN(mask, format, string) do {\
    char *libsheepyInternalString = string;\
    logMN(mask, format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSMP(mask, format, string) do {\
    char *libsheepyInternalString = string;\
    logMP(mask, format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#define logSMI(mask, format, string) do {\
    char *libsheepyInternalString = string;\
    logMI(mask, format, libsheepyInternalString);\
    free(libsheepyInternalString);\
  } while(0)

#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

#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;

char *bFormatS(char *string, const char *fmt, ...) MUST_CHECK;

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;

#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;

#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];

#define codeSizeUTF8(utf8) codeSzUTF8[*(const uint8_t *)(utf8)]

#define nextCodeUTF8(utf8) ((utf8) + codeSizeUTF8(utf8))

#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;

#define orS(string, alternative) \
  !isEmptyS(string) ? (string) : (alternative)

// true when string is empty or white spaces
bool isBlankS(const char *string) MUST_CHECK;

#define orBlankS(string, alternative) \
  !isBlankS(string) ? (string) : (alternative)

#define nS(string) \
  (string) ? (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;

#define forever while(1)

#define range(index, maxCount) \
  ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
  for (size_t index = 0 ; index < UNIQVAR(maxCnt) ; index++)

#define rangeInf(index) \
  for (size_t index = 0 ;; index++)

#define rangeDown(index, maxCount) \
  for (ssize_t index = (maxCount)-1 ; index >= 0 ; index--)

#define rangeDownTo(index, maxCount, to) \
  ;ssize_t UNIQVAR(_to) = to;\
  for (ssize_t index = (maxCount)-1 ; index >= UNIQVAR(_to) ; index--)

#define rangeFrom(index, from, maxCount) \
  ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
  for (size_t index = from ; index < UNIQVAR(maxCnt) ; index++)

#define arange(index, array) range(index, ARRAY_SIZE(array))

#define arangeDown(index, array) rangeDown(index, ARRAY_SIZE(array))

#define arangeDownTo(index, array, to) rangeDownTo(index, ARRAY_SIZE(array), to)

#define arangeFrom(index, from, array) rangeFrom(index, from, ARRAY_SIZE(array))

#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)

#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)

#define rangeStep(index, maxCount, step) \
  ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
  for (size_t index = 0 ; index < UNIQVAR(maxCnt) ; index+=step)

#define rangeDownStep(index, maxCount, step) \
  for (int64_t index = (maxCount)-1 ; index >= 0 ; index-=step)

#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)


#define loop(maxCount) \
  ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
  for (size_t UNIQVAR(index) = 0 ; UNIQVAR(index) < UNIQVAR(maxCnt) ; UNIQVAR(index)++)

#define loopDownTo(maxCount, to) \
  ;ssize_t UNIQVAR(_to) = to;\
  for (ssize_t UNIQVAR(index) = (maxCount)-1 ; UNIQVAR(index) >= UNIQVAR(_to) ; UNIQVAR(index)--)

#define loopFrom(from, maxCount) \
  ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
  for (size_t UNIQVAR(index) = from ; UNIQVAR(index) < UNIQVAR(maxCnt) ; UNIQVAR(index)++)

#define loopStep(maxCount, step) \
  ;size_t UNIQVAR(maxCnt) = (size_t)(maxCount); \
  for (size_t UNIQVAR(index) = 0 ; UNIQVAR(index) < UNIQVAR(maxCnt) ; UNIQVAR(index)+=step)

#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)


#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)])

#define aEnumerate(array, index, element) \
  ; size_t index = 0 ; \
  for (typeof(&array[0]) element = &array[0] ; index < ARRAY_SIZE(array) ; index++, element = &array[index])

#define forEachCharP(list, element) \
  for (char **element=list ; *element != NULL ; element++)

#define forEachCCharP(list, element) \
  for (const char **element=list ; *element != NULL ; element++)

#define forEachS(list, element) \
  ;size_t UNIQVAR(libsheepyInternalIndex) = 0; \
  for (char *element = (list)[0]; (list)[UNIQVAR(libsheepyInternalIndex)]!= NULL ; UNIQVAR(libsheepyInternalIndex)++, element = (list)[UNIQVAR(libsheepyInternalIndex)])

#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)])

#define forEachType(type, list, element) \
  for (type **element=list ; *element != NULL ; element++)

#define enumerateCharP(list, element, index) \
  ;size_t index = 0; \
  for (char **element=list; *element != NULL ; element++, index++)

#define enumerateCCharP(list, element, index) \
  ;size_t index = 0; \
  for (const char **element=list; *element != NULL ; element++, index++)

#define enumerateS(list, element, index) \
  ;size_t index = 0; \
  for (char *element=(list)[0]; element != NULL ; index++, element = (list)[index])

#define enumerateCS(list, element, index) \
  ;size_t index = 0; \
  for (const char *element=(list)[0]; element != NULL ; index++, element = (list)[index])

#define enumerateType(type, list, element, index) \
  ;size_t index = 0; \
  for (type **element=list; *element != NULL ; element++, index++)

#define lForEach(node, startNode)\
  for(var node = startNode; node ; node = (node)->next)

#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;

#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)))

#define sliceSz 1

#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)

#define sliceInit(name) do{\
    (name)->array    = NULL;\
    (name)->count    = 0;\
  } while(0)

#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    = 0;\
  } while(0)

#define sliceCalloc(name, countInt) do{\
    var UNIQVAR(c)   = countInt;\
    (name)->array    = calloc(UNIQVAR(c), sizeof (name)->array[0]);\
    (name)->count    = 0;\
  } while(0)

#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)

#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)

#define sliceFree(name) free((name)->array)

#define sliceElemType(name) typeof((name)->array[0])

#define sliceElemPtrType(name) typeof(&(name)->array[0])

#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;\
  })

/* #define sliceAgn(to, from) do{\
    (to)->count = (from)->count;\
    (to)->array = (from)->array;\
  } while(0) */

#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;}

#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)


#define sliceData(name) (name)->array

#define sliceFrom(name, array, countInt) do{\
    var UNIQVAR(c) = countInt;\
    var UNIQVAR(a) = array;\
    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)

#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);\
  })

#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)

#define sliceMirrorFrom(name, array, countInt) do{\
  var UNIQVAR(strt) = start;\
  (name)->array     = array;\
  (name)->count     = countInt;\
  } while(0)


#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)

#define sliceEmpty(name) (name)->count = 0

#define sliceIsEmpty(name) ((name)->count == 0 || !(name)->array)

#define sliceFit(name) do{\
    sliceResize(name, (name)->count);\
  } while(0)

#define sliceCount(name) (name)->count

#define sliceElemSize(name) sizeof((name)->array[0])

#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)

#define sliceClearElem(name, index) memset(&(name)->array[index], 0, sizeof (name)->array[0])

#define slicePush(name) do {\
    sliceAlloc(name);\
    (name)->count++;\
  } while(0)

#define sliceAppend(name, v) do{\
    slicePush(name);\
    sliceLast(name) = v;\
  } while(0)


#define sliceClearPush(name) do{\
    slicePush(name);\
    sliceClearElem(name, (name)->count - 1);\
  } while(0)

#define slicePop(name) ((name)->count--, (name)->array[(name)->count])

#define sliceDelLast(name) ((name)->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)

#define sliceAt(name, index) ((name)->array[index])

#define slicePtr(name, index) ((name)->array + index)

#define sliceLast(name) ((name)->array[(name)->count-1])

#define sliceLastPtr(name) ((name)->array + (name)->count - 1)

#define sliceLastIndex(name) ((name)->count - 1)


#define sliceFirst(name) ((name)->array[0])


#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)

#define sliceWrite(name, file) fwrite((name)->array, sizeof((name)->array[0]), sliceCount(name), file)

#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)

#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)


#define forEachSc(name, index) range(index, (name)->count)

#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)))

#define sliceEnumerate(name, index, element) \
  ; size_t index = 0 ; \
  for (sliceElemPtrType(name) element = slicePtr(name, 0) ; index < (name)->count ; index++, element = slicePtr(name, index))

#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)

#define slicePrepend(name, v) do {\
    sliceInject(name, 0);\
    sliceAt(name, 0) = v;\
  } while(0)

#define sliceDequeue(name) ({\
    var r = sliceAt(name, 0);\
    sliceDelFirst(name);\
    /* return */r;\
  })

#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)


#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)

#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)

#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)

#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)

#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)

#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);

#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)

#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)

#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;\
  })

#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);\
  })

#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)

#define sliceSort(name, compareFunction) do{ \
  qsort((name)->array, sizeof (name)->array[0], compareFunction);\
  } while(0)

#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);\
  })

#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);\
  })

#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);\
  })

#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);\
  })

#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
 */

#define staticSliceT(typeName, elementType, MAXCOUNT)\
  typedef struct {\
    size_t count;\
    elementType array[MAXCOUNT];\
  } typeName

#define createStaticSlice(typeName, name) ;typeName name; staticSliceInit(&name)

#define staticSliceInit(name) do{\
    (name)->count    = 0;\
  } while(0)

#define staticSliceElemType(name) typeof((name)->array[0])

#define staticSliceElemPtrType(name) typeof(&(name)->array[0])

#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)


#define staticSliceData sliceData

#define staticSliceFrom(name, array, countInt) do{\
    var UNIQVAR(c) = countInt;\
    var UNIQVAR(a) = array;\
    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)


#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])

#define staticSliceEmpty sliceEmpty

#define staticSliceIsEmpty(name) ((name)->count == 0)

#define staticSliceCount sliceCount

#define staticSliceElemSize sliceElemSize

#define staticSliceClearElem sliceClearElem

#define staticSlicePush(name)  (name)->count++

#define staticSliceAppend(name, v) do{\
    staticSlicePush(name);\
    staticSliceLast(name) = v;\
  } while(0)


#define staticSliceClearPush(name) do{\
    staticSlicePush(name);\
    staticSliceClearElem(name, (name)->count - 1);\
  } while(0)

#define staticSlicePop slicePop

#define staticSliceDelLast sliceDelLast

#define staticSliceAt sliceAt

#define staticSlicePtr slicePtr

#define staticSliceLast sliceLast

#define staticSliceLastPtr sliceLastPtr

#define staticSliceLastIndex sliceLastIndex


#define staticSliceFirst sliceFirst


#define staticSliceWriteFilename sliceWriteFilename

#define staticSliceWrite sliceWrite

#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)

#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)


#define forEachSSc forEachSc

#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)))

#define staticSliceEnumerate(name, index, element) \
  ; size_t index = 0 ; \
  for (staticSliceElemPtrType(name) element = staticSlicePtr(name, 0) ; index < (name)->count ; index++, element = staticSlicePtr(name, index))

#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)

#define staticSlicePrepend(name, v) do {\
    staticSliceInject(name, 0);\
    staticSliceAt(name, 0) = v;\
  } while(0)

#define staticSliceDequeue sliceDequeue

#define staticSliceDelFirst sliceDelFirst


#define staticSliceDelElem sliceDelElem

#define staticSliceDel sliceDel

#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)

#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)

#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)

#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);

#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)

#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)

#define staticSliceSlice sliceSlice

#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)

#define staticSliceSort sliceSort

#define staticSliceEq sliceEq

#define staticSliceHas sliceHas

#define staticSliceIndexOf sliceIndexOf

#define staticSliceBinarySearch sliceBinarySearch

#define staticSliceUniq sliceUniq

/*
 * end staticSlice
 */

#define vectorSz 1

#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)

#define vectorInit(name) do{\
    (name)->array    = NULL;\
    (name)->count    = 0;\
    (name)->maxCount = 0;\
  } while(0)

#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)

#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)

#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)

#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)

#define vectorFree sliceFree

#define vectorElemType(name) typeof((name)->array[0])

#define vectorElemPtrType(name) typeof(&(name)->array[0])

#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;\
  })

#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;}

#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)

#define vectorData sliceData

#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)

#define vectorClear sliceClear

#define vectorClearRange sliceClearRange

#define vectorEmpty sliceEmpty

#define vectorIsEmpty sliceIsEmpty

#define vectorFit(name) do{\
    if ((name)->maxCount > (name)->count) {\
      vectorResize(name, (name)->count);\
    }\
  } while(0)

#define vectorCount sliceCount

#define vectorMaxCount(name) (name)->maxCount

#define vectorElemSize sliceElemSize

#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)

#define vectorClearElem sliceClearElem

#define vectorPush(name) do {\
    vectorAlloc(name);\
    (name)->count++;\
  } while(0)

#define vectorAppend(name, v) do{\
    vectorPush(name);\
    vectorLast(name) = v;\
  } while(0)


#define vectorClearPush(name) do{\
    vectorPush(name);\
    vectorClearElem(name, (name)->count - 1);\
  } while(0)

#define vectorPop slicePop

#define vectorDelLast sliceDelLast

#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


#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)

#define vectorAt sliceAt

#define vectorPtr slicePtr

#define vectorLast sliceLast

#define vectorLastPtr sliceLastPtr

#define vectorLastIndex sliceLastIndex


#define vectorFirst sliceFirst


#define vectorWriteFilename sliceWriteFilename

#define vectorWrite sliceWrite

#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)

#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)


#define forEachV forEachSc

#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)))

#define vectorEnumerate(name, index, element) \
  ; size_t index = 0 ; \
  for (vectorElemPtrType(name) element = vectorPtr(name, 0) ; index < (name)->count ; index++, element = vectorPtr(name, index))

#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)

#define vectorPrepend(name, v) do {\
    vectorInject(name, 0);\
    vectorAt(name, 0) = v;\
  } while(0)

#define vectorDequeue sliceDequeue

#define vectorDelFirst sliceDelFirst


#define vectorDelElem sliceDelElem

#define vectorDel sliceDel

#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)

#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)

#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)

#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);

#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)

#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)

#define vectorSlice sliceSlice

#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);\
  })

#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)

#define vectorSort sliceSort

#define vectorEq sliceEq

#define vectorHas sliceHas

#define vectorIndexOf sliceIndexOf

#define vectorBinarySearch sliceBinarySearch

#define vectorUniq sliceUniq

/*
 * end vector
 */


// user parameters
#define dVectorBits 6
// user parameters end

#define dVectorSz   (1<<dVectorBits)
#define dVectorMask (dVectorSz-1)

#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)

#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)


#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)

#define dVectorFree(a) do{\
    range(UNIQVAR(i), (size_t)(a)->maxCount) {\
      free((a)->buffers[UNIQVAR(i)]);\
    }\
    free((a)->buffers);\
  }while(0)

#define dVectorElemType(name) typeof((name)->element)

#define dVectorElemPtrType(name) typeof(&(name)->element)

#define dVectorEmpty(name) (name)->count = 0

#define dVectorIsEmpty(name) ((name)->count == 0)

#define dVectorCount(name) (name)->count

#define dVectorMaxCount(name) ((name)->maxCount * dVectorSz)

#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)

#define dVectorPush(a) do{\
    dVectorAlloc(a);\
    (a)->count++;\
  }while(0)

#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)

#define dVectorPop(a) ((a)->count--, *((typeof((a)->element)*)((a)->buffers[((a)->count)>>dVectorBits])+(((a)->count)&dVectorMask)))

#define dVectorDelLast(a) ((a)->count--)

// TODO poor perfomance #define dVectorPrepend(a, v)

// TODO poor perfomance #define dVectorDequeue(a)

// TODO poor perfomance #define dVectorDelFirst(a)

#define dVectorAt(a, index) (*((typeof((a)->element)*)((a)->buffers[(index)>>dVectorBits])+((index)&dVectorMask)))

#define dVectorPtr(a, index) ((typeof((a)->element)*)((a)->buffers[(index)>>dVectorBits])+((index)&dVectorMask))

#define dVectorLast(a) (*((typeof((a)->element)*)((a)->buffers[((a)->count-1)>>dVectorBits])+(((a)->count-1)&dVectorMask)))

#define dVectorLastPtr(a) ((typeof((a)->element)*)((a)->buffers[((a)->count-1)>>dVectorBits])+(((a)->count-1)&dVectorMask))

#define dVectorLastIndex(a) ((a)->count-1)

#define dVectorFirst(a) (*((typeof((a)->element)*)((a)->buffers[0])))

#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)

#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)

#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)

#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)

#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)))

#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
 */


//
// TODO add print elements func
// TODO check boundaries

typedef struct {
  i64 last; // last element
  i64 head;
  i64 maxCount;
  bool isEmpty;
} staticArrayBase;

#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)

#define staticArrayInit(name)\
  do{\
    (name).last = (name).head = 0;\
    (name).maxCount = COUNT_ELEMENTS((name).list);\
    (name).isEmpty = true;\
  } while(0);

#define staticArrayElemType(name) typeof((name).list[0])

#define staticArrayElemPtrType(name) typeof(&(name).list[0])

#define staticArrayEmpty(name)\
  do{\
    (name).last = (name).head = 0;\
    (name).isEmpty = true;\
  } while(0);

#define staticArrayIsEmpty(name) ((name).isEmpty)

#define staticArrayIsFull(name) ((name).isEmpty ? 0 : ((((name).last+1) % (name).maxCount) == (name).head))

#define staticArrayCount(name) ((name).isEmpty ? 0 : ((((name).last) >= ((name).head)) ? ((name).last-(name).head+1) : (((name).maxCount-(name).head + (name).last+1))) )

#define staticArrayPush(name)\
  do{\
    if ((name).isEmpty) {\
      (name).isEmpty = false;\
    }\
    else {\
      (name).last++;\
      (name).last %= (name).maxCount;\
    }\
  } while(0);

#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

#define staticArrayPrepend(name)\
  do{\
    if ((name).isEmpty) {\
      (name).isEmpty = false;\
    }\
    else {\
      if ((name).head)\
        (name).head--;\
      else\
        (name).head+=(name).maxCount-1;\
    }\
  } while(0);

#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

#define staticArrayGet(name, index) (name).list[(((index) >= 0) ? (index) : staticArrayCount(name) + (index) )]
#define staticArrayAt staticArrayGet

#define staticArrayGetIndex(name, index) ((((index) >= 0) ? (index) : staticArrayCount(name) + (index) ))

#define staticArrayRef(name, index) (name).list[((((index) >= 0) ? (index) : staticArrayCount(name) + (index) ) + name.head) % name.maxCount]

#define staticArrayRefIndex(name, index) (((((index) >= 0) ? (index) : staticArrayCount(name) + (index) ) + name.head) % name.maxCount)

#define staticArrayLast(name) (name).list[(name).last]

#define staticArrayLastIndex(name) (name).last

#define staticArrayFirst(name) (name).list[(name).head]

#define staticArrayFirstIndex(name) (name).head

#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)

#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)

#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)

#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)

#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)

#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)))

#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))

#define indexer staticArrayBase

#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)

#define indexerInit(name, MAXCOUNT)\
  do{\
    (name).last = (name).head = 0;\
    (name).maxCount = MAXCOUNT;\
    (name).isEmpty = true;\
  } while(0);

#define indexerPInit ringInit

#define indexerEmpty staticArrayEmpty
#define indexerPEmpty ringEmpty

#define indexerIsEmpty staticArrayIsEmpty
#define indexerPIsEmpty ringIsEmpty

#define indexerIsFull staticArrayIsFull
#define indexerPIsFull ringIsFull

#define indexerCount staticArrayCount
#define indexerPCount ringCount

#define indexerPush staticArrayPush
#define indexerPPush ringPush

#define indexerPop staticArrayPop
#define indexerPPop ringPop

#define indexerPrepend staticArrayPrepend
#define indexerPPrepend ringPrepend

#define indexerDequeue staticArrayDequeue
#define indexerPDequeue ringDequeue

#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)

#define indexerLast(name) name.last
#define indexerPLast(name) (name)->last

#define indexerFirst(name) (name.head)
#define indexerPFirst(name) (name)->head


#define ringBase staticArrayBase

#define ringMake staticArrayT

#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);

#define ringGet(name, index) (name)->list[(((index) >= 0) ? (index) : ringCount(name) + (index) )]

#define ringRef(name, index) (name)->list[((((index) >= 0) ? (index) : ringCount(name) + (index) ) + name->head) % name->maxCount]

#define ringLast(name) (name)->list[(name)->last]

#define ringLastIndex(name) (name)->last

#define ringFirst(name) (name)->list[(name)->head]


#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);


#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);

// schedule fibers
void scheduler(void);

// the scheduler takes slot 0
// the system can handle tCount-1 fibers
#define tCount 10

typedef struct {int slot;} fiberBaseT;

staticArrayT(fiberLT, int, tCount);

typedef struct {
  jmp_buf jumpBuffers[tCount];
  fiberLT L;
  fiberLT startL;
  void *context[tCount];
  void (*F[tCount])(int thisSlot);
} fibersT;

extern fibersT fibers;

#define fiberCtx(thisSlot) fibers.context[thisSlot]

typedef void (*fiberFT)(int);

bool fiberAdd(void *ctx, int thisSlot, fiberFT func);

bool fiberPrepend(void *ctx, int thisSlot, fiberFT func);

#define startJump(func)\
  if (!setjmp(fibers.jumpBuffers[0])) {\
      func;\
  }

#if !__sun__

#define yield(slotValue, slot)\
  if (!(slotValue = setjmp(fibers.jumpBuffers[slot]))) {\
    staticArrayPush(fibers.L);\
    staticArrayLast(fibers.L) = slot;\
    longjmp(fibers.jumpBuffers[0], 1);\
  }
#endif

#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);\
  }



// user parameters
#define dArrayBits 6
// user parameters end

#define dArraySz   (1<<dArrayBits)
#define dArrayMask (dArraySz-1)

#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)

#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)

#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)

#define dArrayFree dVectorFree

#define dArrayElemType(a) typeof((a)->element)

#define dArrayElemPtrType(a) typeof(&(a)->element)

#define dArrayEmpty(name) do{\
    (name)->last = (name)->head = 0;\
  } while(0);

#define dArrayIsEmpty(name) ((name)->head == (name)->last)

#define dArrayCount(name) ((name)->last - (name)->head)

#define dArrayMaxCount(name) ((name)->maxCount * dArraySz)

#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)

#define dArrayPush(a) do{\
    dArrayAlloc(a);\
    (a)->last++;\
  }while(0)

#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)

#define dArrayPop(a) ((a)->last--, *((typeof((a)->element)*)((a)->buffers[((a)->last)>>dArrayBits])+(((a)->last)&dArrayMask)))

#define dArrayDelLast(a) ((a)->last--)

#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)

#define dArrayDequeue(a) ((a)->head++, *((typeof((a)->element)*)((a)->buffers[((a)->head-1)>>dArrayBits])+(((a)->head-1)&dArrayMask)))

#define dArrayDelFirst(a) ((a)->head++)

#define dArrayAt(a, index) (*((typeof((a)->element)*)((a)->buffers[(index)>>dArrayBits])+((index)&dArrayMask)))

#define dArrayPtr(a, index) ((typeof((a)->element)*)((a)->buffers[(index)>>dArrayBits])+((index)&dArrayMask))

#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)

#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)

#define dArrayLast(a) (*((typeof((a)->element)*)((a)->buffers[((a)->last-1)>>dArrayBits])+(((a)->last-1)&dArrayMask)))

#define dArrayLastPtr(a) ((typeof((a)->element)*)((a)->buffers[((a)->last-1)>>dArrayBits])+(((a)->last-1)&dArrayMask))

#define dArrayLastIndex(a) ((a)->last-1)

#define dArrayLastIndexVar(a) ((a)->last)

#define dArrayFirst(a) (*((typeof((a)->element)*)((a)->buffers[((a)->head)>>dArrayBits])+((a)->head)&dArrayMask))

#define dArrayFirstIndex(a) ((a)->head)

#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)

#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)

#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)

#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)

#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)))

#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
 */


#define slabSz 64

#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)

#define slabInit(a) do{\
    (a)->last = (a)->head = 0;\
    (a)->array            = malloc(sizeof(*((a)->array)) * slabSz);\
    (a)->maxCount         = slabSz;\
  }while(0)


#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)

#define slabFree sliceFree

#define slabElemType(name) typeof((name)->array[0])

#define slabElemPtrType(name) typeof(&(name)->array[0])

#define slabEmpty(name) do{\
    (name)->last = (name)->head = 0;\
  } while(0);

#define slabIsEmpty(name) ((name)->head == (name)->last)

#define slabCount(name) ((name)->last - (name)->head)

#define slabMaxCount vectorMaxCount

#define slabAlloc(a) do{\
    if ((a)->last == slabMaxCount(a)) {\
      (a)->maxCount += slabSz;\
      slabResize(a, (a)->maxCount);\
    }\
  }while(0)

#define slabPush(a) do{\
    slabAlloc(a);\
    (a)->last++;\
  }while(0)

#define slabAppend(a, v) do{\
    slabAlloc(a);\
    if ((a)->last < slabMaxCount(a)) {\
      *( (a)->array + (a)->last ) = v;\
      (a)->last++;\
    }\
  }while(0)

#define slabPop(a) ((a)->last--, *((a)->array + (a)->last))

#define slabDelLast(a) ((a)->last--)

#define slabPrepend(a, v) do{\
    if ((a)->head > 0) {\
      (a)->head--;\
      *( (a)->array + (a)->head ) = v;\
    }\
  }while(0)

#define slabDequeue(a) ((a)->head++, *((a)->array + (a)->head -1))

#define slabDelFirst(a) ((a)->head++)

#define slabAt sliceAt

#define slabPtr slicePtr

#define slabLast(a) (*((a)->array + (a)->last -1))

#define slabLastPtr(a) ((a)->array + (a)->last -1)

#define slabLastIndex(a) ((a)->last-1)

#define slabLastIndexVar(a) ((a)->last)

#define slabFirst(a) (*((a)->array + (a)->head))

#define slabFirstIndex(a) ((a)->head)

#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)

#define slabWrite(a, file) fwrite((a)->array + (a)->head, 1, sizeof(*((a)->array)) * slabCount(a), file)

#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)

#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)

#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)))

#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
 */


#define staticBitsetT(typeName, containerType, count)\
  typedef struct {containerType map[BUCKETS(count, 8 * sizeof(containerType))];} typeName;

#define staticBitsetInit staticBitsetClear

#define staticBitsetCount(name) (sizeof((name)->map) * 8)

#define staticBitsetClear(name) memset(name, 0, sizeof(*(name)));

#define staticBitsetBucket(name, index) (name)->map[index / (8 * sizeof((name)->map[0]))]

#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)

#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)

#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)

#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)

#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;\
  })

#define bitsetModulo 8

#define bitsetBucket(name, index) (name)->map[index / (bitsetModulo)]

#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)

#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)

#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)

#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)

#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;\
  })

#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

#define FIELD_SETL(dst, index, val, len) FIELD_SET(dst, val, ((index)+1)*(len)-1, (index)*(len))

#define BITFIELD_SET(array, index, val, len) FIELD_SET((array)[((index)*(len))/64], val, ((index)*(len))%64+(len)-1, ((index)*(len))%64)

#define BITFIELD_GET(array, index, len) EXTRACT((array)[((index)*(len))/64], ((index)*(len))%64+(len)-1, ((index)*(len))%64)

#define BITFIELD_SIZE(count, len, containerType) BUCKETS((count)*(len), 8 * sizeof(containerType))

#define BITFIELD_VAR(array, count, len) u64 array[BITFIELD_SIZE(count, len, u64)]

// 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))

#define nanoSleep(time) pError0(nanoSleepF(time))

#define nanoSleepE(time, cmd) pErrorCmd(nanoSleepF(time), == 0, cmd)

#define usSleep(time) pError0(nanoSleepF(1000 * (uint64_t)time))

#define msSleep(time) pError0(nanoSleepF(1000000 * (uint64_t)time))


#ifdef __GNUC__
#define UNUSED __attribute__ ((unused))
#define DEPRECATED __attribute__ ((deprecated))
#define PACKED __attribute__((__packed__))

#define CLEANUP(func) __attribute__((cleanup(func)))

#if __GNUC__ >= 7
#define FALLTHRU __attribute__ ((fallthrough))
#else
#define FALLTHRU
#endif

#define AINLINE         inline __attribute__ ((always_inline))

#define NOINLINE      __attribute__ ((noinline))

//#define PURE          __attribute__ ((pure))

//#define CONST         __attribute__ ((const))

#define NORETURN      __attribute__ ((noreturn))

#define AMALLOC       __attribute__ ((malloc))

#define USED          __attribute__ ((used))

#define ALIGN(X)      __attribute__ ((aligned, (x)))
#define ALIGN_MAX     __attribute__ ((aligned))

//#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: