From 3ce3bffda8015171c23893777f4b647de1f61543 Mon Sep 17 00:00:00 2001
From: fanasina <rafanasin@gmail.com>
Date: Wed, 16 Aug 2023 00:50:38 +0200
Subject: [PATCH] add timestamp log in test

---
 Elif                  | 5153 ++++++++++++++++++++++++++++++++++++++++-
 isgood                |  Bin 42688 -> 43064 bytes
 src/test_t/is_good.c  |   24 +-
 src/test_t/test_t.c   |  158 +-
 src/test_t/test_t.h   |   75 +-
 src/tools_t/tools_t.c |   13 +
 src/tools_t/tools_t.h |   15 +-
 7 files changed, 5254 insertions(+), 184 deletions(-)

diff --git a/Elif b/Elif
index ad39b52..f29ab85 100644
--- a/Elif
+++ b/Elif
@@ -1825,6 +1825,1252 @@ extern int getloadavg (double __loadavg[], int __nelem)
 # 1035 "/usr/include/stdlib.h" 3 4
 
 # 3 "src/test_t/is_good.c" 2
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdbool.h" 1 3 4
+# 4 "src/test_t/is_good.c" 2
+
+# 1 "/usr/include/unistd.h" 1 3 4
+# 27 "/usr/include/unistd.h" 3 4
+
+# 202 "/usr/include/unistd.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/posix_opt.h" 1 3 4
+# 203 "/usr/include/unistd.h" 2 3 4
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/environments.h" 1 3 4
+# 22 "/usr/include/x86_64-linux-gnu/bits/environments.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
+# 23 "/usr/include/x86_64-linux-gnu/bits/environments.h" 2 3 4
+# 207 "/usr/include/unistd.h" 2 3 4
+# 226 "/usr/include/unistd.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4
+# 227 "/usr/include/unistd.h" 2 3 4
+# 255 "/usr/include/unistd.h" 3 4
+typedef __useconds_t useconds_t;
+# 267 "/usr/include/unistd.h" 3 4
+typedef __intptr_t intptr_t;
+
+
+
+
+
+
+typedef __socklen_t socklen_t;
+# 287 "/usr/include/unistd.h" 3 4
+extern int access (const char *__name, int __type) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+# 309 "/usr/include/unistd.h" 3 4
+extern int faccessat (int __fd, const char *__file, int __type, int __flag)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) ;
+# 339 "/usr/include/unistd.h" 3 4
+extern __off_t lseek (int __fd, __off_t __offset, int __whence) __attribute__ ((__nothrow__ , __leaf__));
+# 358 "/usr/include/unistd.h" 3 4
+extern int close (int __fd);
+
+
+
+
+extern void closefrom (int __lowfd) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+
+extern ssize_t read (int __fd, void *__buf, size_t __nbytes)
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+
+extern ssize_t write (int __fd, const void *__buf, size_t __n)
+    __attribute__ ((__access__ (__read_only__, 2, 3)));
+# 389 "/usr/include/unistd.h" 3 4
+extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
+        __off_t __offset)
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+
+
+extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
+         __off_t __offset)
+    __attribute__ ((__access__ (__read_only__, 2, 3)));
+# 437 "/usr/include/unistd.h" 3 4
+extern int pipe (int __pipedes[2]) __attribute__ ((__nothrow__ , __leaf__)) ;
+# 452 "/usr/include/unistd.h" 3 4
+extern unsigned int alarm (unsigned int __seconds) __attribute__ ((__nothrow__ , __leaf__));
+# 464 "/usr/include/unistd.h" 3 4
+extern unsigned int sleep (unsigned int __seconds);
+
+
+
+
+
+
+
+extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
+     __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+extern int usleep (__useconds_t __useconds);
+# 489 "/usr/include/unistd.h" 3 4
+extern int pause (void);
+
+
+
+extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern int fchown (int __fd, __uid_t __owner, __gid_t __group) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+extern int fchownat (int __fd, const char *__file, __uid_t __owner,
+       __gid_t __group, int __flag)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) ;
+
+
+
+extern int chdir (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern int fchdir (int __fd) __attribute__ ((__nothrow__ , __leaf__)) ;
+# 531 "/usr/include/unistd.h" 3 4
+extern char *getcwd (char *__buf, size_t __size) __attribute__ ((__nothrow__ , __leaf__)) ;
+# 545 "/usr/include/unistd.h" 3 4
+extern char *getwd (char *__buf)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__))
+    __attribute__ ((__access__ (__write_only__, 1)));
+
+
+
+
+extern int dup (int __fd) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+extern int dup2 (int __fd, int __fd2) __attribute__ ((__nothrow__ , __leaf__));
+# 564 "/usr/include/unistd.h" 3 4
+extern char **__environ;
+
+
+
+
+
+
+
+extern int execve (const char *__path, char *const __argv[],
+     char *const __envp[]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern int execv (const char *__path, char *const __argv[])
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int execle (const char *__path, const char *__arg, ...)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int execl (const char *__path, const char *__arg, ...)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int execvp (const char *__file, char *const __argv[])
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int execlp (const char *__file, const char *__arg, ...)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+# 619 "/usr/include/unistd.h" 3 4
+extern int nice (int __inc) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+extern void _exit (int __status) __attribute__ ((__noreturn__));
+
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/confname.h" 1 3 4
+# 24 "/usr/include/x86_64-linux-gnu/bits/confname.h" 3 4
+enum
+  {
+    _PC_LINK_MAX,
+
+    _PC_MAX_CANON,
+
+    _PC_MAX_INPUT,
+
+    _PC_NAME_MAX,
+
+    _PC_PATH_MAX,
+
+    _PC_PIPE_BUF,
+
+    _PC_CHOWN_RESTRICTED,
+
+    _PC_NO_TRUNC,
+
+    _PC_VDISABLE,
+
+    _PC_SYNC_IO,
+
+    _PC_ASYNC_IO,
+
+    _PC_PRIO_IO,
+
+    _PC_SOCK_MAXBUF,
+
+    _PC_FILESIZEBITS,
+
+    _PC_REC_INCR_XFER_SIZE,
+
+    _PC_REC_MAX_XFER_SIZE,
+
+    _PC_REC_MIN_XFER_SIZE,
+
+    _PC_REC_XFER_ALIGN,
+
+    _PC_ALLOC_SIZE_MIN,
+
+    _PC_SYMLINK_MAX,
+
+    _PC_2_SYMLINKS
+
+  };
+
+
+enum
+  {
+    _SC_ARG_MAX,
+
+    _SC_CHILD_MAX,
+
+    _SC_CLK_TCK,
+
+    _SC_NGROUPS_MAX,
+
+    _SC_OPEN_MAX,
+
+    _SC_STREAM_MAX,
+
+    _SC_TZNAME_MAX,
+
+    _SC_JOB_CONTROL,
+
+    _SC_SAVED_IDS,
+
+    _SC_REALTIME_SIGNALS,
+
+    _SC_PRIORITY_SCHEDULING,
+
+    _SC_TIMERS,
+
+    _SC_ASYNCHRONOUS_IO,
+
+    _SC_PRIORITIZED_IO,
+
+    _SC_SYNCHRONIZED_IO,
+
+    _SC_FSYNC,
+
+    _SC_MAPPED_FILES,
+
+    _SC_MEMLOCK,
+
+    _SC_MEMLOCK_RANGE,
+
+    _SC_MEMORY_PROTECTION,
+
+    _SC_MESSAGE_PASSING,
+
+    _SC_SEMAPHORES,
+
+    _SC_SHARED_MEMORY_OBJECTS,
+
+    _SC_AIO_LISTIO_MAX,
+
+    _SC_AIO_MAX,
+
+    _SC_AIO_PRIO_DELTA_MAX,
+
+    _SC_DELAYTIMER_MAX,
+
+    _SC_MQ_OPEN_MAX,
+
+    _SC_MQ_PRIO_MAX,
+
+    _SC_VERSION,
+
+    _SC_PAGESIZE,
+
+
+    _SC_RTSIG_MAX,
+
+    _SC_SEM_NSEMS_MAX,
+
+    _SC_SEM_VALUE_MAX,
+
+    _SC_SIGQUEUE_MAX,
+
+    _SC_TIMER_MAX,
+
+
+
+
+    _SC_BC_BASE_MAX,
+
+    _SC_BC_DIM_MAX,
+
+    _SC_BC_SCALE_MAX,
+
+    _SC_BC_STRING_MAX,
+
+    _SC_COLL_WEIGHTS_MAX,
+
+    _SC_EQUIV_CLASS_MAX,
+
+    _SC_EXPR_NEST_MAX,
+
+    _SC_LINE_MAX,
+
+    _SC_RE_DUP_MAX,
+
+    _SC_CHARCLASS_NAME_MAX,
+
+
+    _SC_2_VERSION,
+
+    _SC_2_C_BIND,
+
+    _SC_2_C_DEV,
+
+    _SC_2_FORT_DEV,
+
+    _SC_2_FORT_RUN,
+
+    _SC_2_SW_DEV,
+
+    _SC_2_LOCALEDEF,
+
+
+    _SC_PII,
+
+    _SC_PII_XTI,
+
+    _SC_PII_SOCKET,
+
+    _SC_PII_INTERNET,
+
+    _SC_PII_OSI,
+
+    _SC_POLL,
+
+    _SC_SELECT,
+
+    _SC_UIO_MAXIOV,
+
+    _SC_IOV_MAX = _SC_UIO_MAXIOV,
+
+    _SC_PII_INTERNET_STREAM,
+
+    _SC_PII_INTERNET_DGRAM,
+
+    _SC_PII_OSI_COTS,
+
+    _SC_PII_OSI_CLTS,
+
+    _SC_PII_OSI_M,
+
+    _SC_T_IOV_MAX,
+
+
+
+    _SC_THREADS,
+
+    _SC_THREAD_SAFE_FUNCTIONS,
+
+    _SC_GETGR_R_SIZE_MAX,
+
+    _SC_GETPW_R_SIZE_MAX,
+
+    _SC_LOGIN_NAME_MAX,
+
+    _SC_TTY_NAME_MAX,
+
+    _SC_THREAD_DESTRUCTOR_ITERATIONS,
+
+    _SC_THREAD_KEYS_MAX,
+
+    _SC_THREAD_STACK_MIN,
+
+    _SC_THREAD_THREADS_MAX,
+
+    _SC_THREAD_ATTR_STACKADDR,
+
+    _SC_THREAD_ATTR_STACKSIZE,
+
+    _SC_THREAD_PRIORITY_SCHEDULING,
+
+    _SC_THREAD_PRIO_INHERIT,
+
+    _SC_THREAD_PRIO_PROTECT,
+
+    _SC_THREAD_PROCESS_SHARED,
+
+
+    _SC_NPROCESSORS_CONF,
+
+    _SC_NPROCESSORS_ONLN,
+
+    _SC_PHYS_PAGES,
+
+    _SC_AVPHYS_PAGES,
+
+    _SC_ATEXIT_MAX,
+
+    _SC_PASS_MAX,
+
+
+    _SC_XOPEN_VERSION,
+
+    _SC_XOPEN_XCU_VERSION,
+
+    _SC_XOPEN_UNIX,
+
+    _SC_XOPEN_CRYPT,
+
+    _SC_XOPEN_ENH_I18N,
+
+    _SC_XOPEN_SHM,
+
+
+    _SC_2_CHAR_TERM,
+
+    _SC_2_C_VERSION,
+
+    _SC_2_UPE,
+
+
+    _SC_XOPEN_XPG2,
+
+    _SC_XOPEN_XPG3,
+
+    _SC_XOPEN_XPG4,
+
+
+    _SC_CHAR_BIT,
+
+    _SC_CHAR_MAX,
+
+    _SC_CHAR_MIN,
+
+    _SC_INT_MAX,
+
+    _SC_INT_MIN,
+
+    _SC_LONG_BIT,
+
+    _SC_WORD_BIT,
+
+    _SC_MB_LEN_MAX,
+
+    _SC_NZERO,
+
+    _SC_SSIZE_MAX,
+
+    _SC_SCHAR_MAX,
+
+    _SC_SCHAR_MIN,
+
+    _SC_SHRT_MAX,
+
+    _SC_SHRT_MIN,
+
+    _SC_UCHAR_MAX,
+
+    _SC_UINT_MAX,
+
+    _SC_ULONG_MAX,
+
+    _SC_USHRT_MAX,
+
+
+    _SC_NL_ARGMAX,
+
+    _SC_NL_LANGMAX,
+
+    _SC_NL_MSGMAX,
+
+    _SC_NL_NMAX,
+
+    _SC_NL_SETMAX,
+
+    _SC_NL_TEXTMAX,
+
+
+    _SC_XBS5_ILP32_OFF32,
+
+    _SC_XBS5_ILP32_OFFBIG,
+
+    _SC_XBS5_LP64_OFF64,
+
+    _SC_XBS5_LPBIG_OFFBIG,
+
+
+    _SC_XOPEN_LEGACY,
+
+    _SC_XOPEN_REALTIME,
+
+    _SC_XOPEN_REALTIME_THREADS,
+
+
+    _SC_ADVISORY_INFO,
+
+    _SC_BARRIERS,
+
+    _SC_BASE,
+
+    _SC_C_LANG_SUPPORT,
+
+    _SC_C_LANG_SUPPORT_R,
+
+    _SC_CLOCK_SELECTION,
+
+    _SC_CPUTIME,
+
+    _SC_THREAD_CPUTIME,
+
+    _SC_DEVICE_IO,
+
+    _SC_DEVICE_SPECIFIC,
+
+    _SC_DEVICE_SPECIFIC_R,
+
+    _SC_FD_MGMT,
+
+    _SC_FIFO,
+
+    _SC_PIPE,
+
+    _SC_FILE_ATTRIBUTES,
+
+    _SC_FILE_LOCKING,
+
+    _SC_FILE_SYSTEM,
+
+    _SC_MONOTONIC_CLOCK,
+
+    _SC_MULTI_PROCESS,
+
+    _SC_SINGLE_PROCESS,
+
+    _SC_NETWORKING,
+
+    _SC_READER_WRITER_LOCKS,
+
+    _SC_SPIN_LOCKS,
+
+    _SC_REGEXP,
+
+    _SC_REGEX_VERSION,
+
+    _SC_SHELL,
+
+    _SC_SIGNALS,
+
+    _SC_SPAWN,
+
+    _SC_SPORADIC_SERVER,
+
+    _SC_THREAD_SPORADIC_SERVER,
+
+    _SC_SYSTEM_DATABASE,
+
+    _SC_SYSTEM_DATABASE_R,
+
+    _SC_TIMEOUTS,
+
+    _SC_TYPED_MEMORY_OBJECTS,
+
+    _SC_USER_GROUPS,
+
+    _SC_USER_GROUPS_R,
+
+    _SC_2_PBS,
+
+    _SC_2_PBS_ACCOUNTING,
+
+    _SC_2_PBS_LOCATE,
+
+    _SC_2_PBS_MESSAGE,
+
+    _SC_2_PBS_TRACK,
+
+    _SC_SYMLOOP_MAX,
+
+    _SC_STREAMS,
+
+    _SC_2_PBS_CHECKPOINT,
+
+
+    _SC_V6_ILP32_OFF32,
+
+    _SC_V6_ILP32_OFFBIG,
+
+    _SC_V6_LP64_OFF64,
+
+    _SC_V6_LPBIG_OFFBIG,
+
+
+    _SC_HOST_NAME_MAX,
+
+    _SC_TRACE,
+
+    _SC_TRACE_EVENT_FILTER,
+
+    _SC_TRACE_INHERIT,
+
+    _SC_TRACE_LOG,
+
+
+    _SC_LEVEL1_ICACHE_SIZE,
+
+    _SC_LEVEL1_ICACHE_ASSOC,
+
+    _SC_LEVEL1_ICACHE_LINESIZE,
+
+    _SC_LEVEL1_DCACHE_SIZE,
+
+    _SC_LEVEL1_DCACHE_ASSOC,
+
+    _SC_LEVEL1_DCACHE_LINESIZE,
+
+    _SC_LEVEL2_CACHE_SIZE,
+
+    _SC_LEVEL2_CACHE_ASSOC,
+
+    _SC_LEVEL2_CACHE_LINESIZE,
+
+    _SC_LEVEL3_CACHE_SIZE,
+
+    _SC_LEVEL3_CACHE_ASSOC,
+
+    _SC_LEVEL3_CACHE_LINESIZE,
+
+    _SC_LEVEL4_CACHE_SIZE,
+
+    _SC_LEVEL4_CACHE_ASSOC,
+
+    _SC_LEVEL4_CACHE_LINESIZE,
+
+
+
+    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
+
+    _SC_RAW_SOCKETS,
+
+
+    _SC_V7_ILP32_OFF32,
+
+    _SC_V7_ILP32_OFFBIG,
+
+    _SC_V7_LP64_OFF64,
+
+    _SC_V7_LPBIG_OFFBIG,
+
+
+    _SC_SS_REPL_MAX,
+
+
+    _SC_TRACE_EVENT_NAME_MAX,
+
+    _SC_TRACE_NAME_MAX,
+
+    _SC_TRACE_SYS_MAX,
+
+    _SC_TRACE_USER_EVENT_MAX,
+
+
+    _SC_XOPEN_STREAMS,
+
+
+    _SC_THREAD_ROBUST_PRIO_INHERIT,
+
+    _SC_THREAD_ROBUST_PRIO_PROTECT,
+
+
+    _SC_MINSIGSTKSZ,
+
+
+    _SC_SIGSTKSZ
+
+  };
+
+
+enum
+  {
+    _CS_PATH,
+
+
+    _CS_V6_WIDTH_RESTRICTED_ENVS,
+
+
+
+    _CS_GNU_LIBC_VERSION,
+
+    _CS_GNU_LIBPTHREAD_VERSION,
+
+
+    _CS_V5_WIDTH_RESTRICTED_ENVS,
+
+
+
+    _CS_V7_WIDTH_RESTRICTED_ENVS,
+
+
+
+    _CS_LFS_CFLAGS = 1000,
+
+    _CS_LFS_LDFLAGS,
+
+    _CS_LFS_LIBS,
+
+    _CS_LFS_LINTFLAGS,
+
+    _CS_LFS64_CFLAGS,
+
+    _CS_LFS64_LDFLAGS,
+
+    _CS_LFS64_LIBS,
+
+    _CS_LFS64_LINTFLAGS,
+
+
+    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
+
+    _CS_XBS5_ILP32_OFF32_LDFLAGS,
+
+    _CS_XBS5_ILP32_OFF32_LIBS,
+
+    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
+
+    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
+
+    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
+
+    _CS_XBS5_ILP32_OFFBIG_LIBS,
+
+    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
+
+    _CS_XBS5_LP64_OFF64_CFLAGS,
+
+    _CS_XBS5_LP64_OFF64_LDFLAGS,
+
+    _CS_XBS5_LP64_OFF64_LIBS,
+
+    _CS_XBS5_LP64_OFF64_LINTFLAGS,
+
+    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
+
+    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
+
+    _CS_XBS5_LPBIG_OFFBIG_LIBS,
+
+    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
+
+
+    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFF32_LIBS,
+
+    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
+
+    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
+
+    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
+
+    _CS_POSIX_V6_LP64_OFF64_LIBS,
+
+    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
+
+
+    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFF32_LIBS,
+
+    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
+
+    _CS_POSIX_V7_LP64_OFF64_CFLAGS,
+
+    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
+
+    _CS_POSIX_V7_LP64_OFF64_LIBS,
+
+    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
+
+
+    _CS_V6_ENV,
+
+    _CS_V7_ENV
+
+  };
+# 631 "/usr/include/unistd.h" 2 3 4
+
+
+extern long int pathconf (const char *__path, int __name)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern long int fpathconf (int __fd, int __name) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern long int sysconf (int __name) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern size_t confstr (int __name, char *__buf, size_t __len) __attribute__ ((__nothrow__ , __leaf__))
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+extern __pid_t getpid (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern __pid_t getppid (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern __pid_t getpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern __pid_t __getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
+
+extern __pid_t getpgid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+extern int setpgid (__pid_t __pid, __pid_t __pgid) __attribute__ ((__nothrow__ , __leaf__));
+# 682 "/usr/include/unistd.h" 3 4
+extern int setpgrp (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+extern __pid_t setsid (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern __pid_t getsid (__pid_t __pid) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern __uid_t getuid (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern __uid_t geteuid (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern __gid_t getgid (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern __gid_t getegid (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+extern int getgroups (int __size, __gid_t __list[]) __attribute__ ((__nothrow__ , __leaf__))
+    __attribute__ ((__access__ (__write_only__, 2, 1)));
+# 722 "/usr/include/unistd.h" 3 4
+extern int setuid (__uid_t __uid) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+extern int setreuid (__uid_t __ruid, __uid_t __euid) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+extern int seteuid (__uid_t __uid) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+
+
+extern int setgid (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+extern int setregid (__gid_t __rgid, __gid_t __egid) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+extern int setegid (__gid_t __gid) __attribute__ ((__nothrow__ , __leaf__)) ;
+# 778 "/usr/include/unistd.h" 3 4
+extern __pid_t fork (void) __attribute__ ((__nothrow__));
+
+
+
+
+
+
+
+extern __pid_t vfork (void) __attribute__ ((__nothrow__ , __leaf__));
+# 799 "/usr/include/unistd.h" 3 4
+extern char *ttyname (int __fd) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)))
+     __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+extern int isatty (int __fd) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+extern int ttyslot (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+extern int link (const char *__from, const char *__to)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) ;
+
+
+
+
+extern int linkat (int __fromfd, const char *__from, int __tofd,
+     const char *__to, int __flags)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4))) ;
+
+
+
+
+extern int symlink (const char *__from, const char *__to)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) ;
+
+
+
+
+extern ssize_t readlink (const char *__restrict __path,
+    char *__restrict __buf, size_t __len)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)))
+     __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+
+extern int symlinkat (const char *__from, int __tofd,
+        const char *__to) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 3))) ;
+
+
+extern ssize_t readlinkat (int __fd, const char *__restrict __path,
+      char *__restrict __buf, size_t __len)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)))
+     __attribute__ ((__access__ (__write_only__, 3, 4)));
+
+
+
+extern int unlink (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int unlinkat (int __fd, const char *__name, int __flag)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern int rmdir (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern __pid_t tcgetpgrp (int __fd) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+extern char *getlogin (void);
+
+
+
+
+
+
+
+extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+extern int setlogin (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 1 3 4
+# 27 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 1 3 4
+# 28 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 3 4
+
+
+
+
+
+
+
+
+extern char *optarg;
+# 50 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 3 4
+extern int optind;
+
+
+
+
+extern int opterr;
+
+
+
+extern int optopt;
+# 91 "/usr/include/x86_64-linux-gnu/bits/getopt_core.h" 3 4
+extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
+       __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
+
+
+# 28 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 2 3 4
+
+
+# 49 "/usr/include/x86_64-linux-gnu/bits/getopt_posix.h" 3 4
+
+# 904 "/usr/include/unistd.h" 2 3 4
+
+
+
+
+
+
+
+extern int gethostname (char *__name, size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+
+
+extern int sethostname (const char *__name, size_t __len)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__read_only__, 1, 2)));
+
+
+
+extern int sethostid (long int __id) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+
+extern int getdomainname (char *__name, size_t __len)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)))
+     __attribute__ ((__access__ (__write_only__, 1, 2)));
+extern int setdomainname (const char *__name, size_t __len)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__read_only__, 1, 2)));
+
+
+
+
+extern int vhangup (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int revoke (const char *__file) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+
+extern int profil (unsigned short int *__sample_buffer, size_t __size,
+     size_t __offset, unsigned int __scale)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int acct (const char *__name) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern char *getusershell (void) __attribute__ ((__nothrow__ , __leaf__));
+extern void endusershell (void) __attribute__ ((__nothrow__ , __leaf__));
+extern void setusershell (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+extern int daemon (int __nochdir, int __noclose) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+
+
+extern int chroot (const char *__path) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int fsync (int __fd);
+# 1002 "/usr/include/unistd.h" 3 4
+extern long int gethostid (void);
+
+
+extern void sync (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+extern int getpagesize (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
+
+
+
+
+extern int getdtablesize (void) __attribute__ ((__nothrow__ , __leaf__));
+# 1026 "/usr/include/unistd.h" 3 4
+extern int truncate (const char *__file, __off_t __length)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+# 1049 "/usr/include/unistd.h" 3 4
+extern int ftruncate (int __fd, __off_t __length) __attribute__ ((__nothrow__ , __leaf__)) ;
+# 1070 "/usr/include/unistd.h" 3 4
+extern int brk (void *__addr) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+
+extern void *sbrk (intptr_t __delta) __attribute__ ((__nothrow__ , __leaf__));
+# 1091 "/usr/include/unistd.h" 3 4
+extern long int syscall (long int __sysno, ...) __attribute__ ((__nothrow__ , __leaf__));
+# 1114 "/usr/include/unistd.h" 3 4
+extern int lockf (int __fd, int __cmd, __off_t __len) ;
+# 1150 "/usr/include/unistd.h" 3 4
+extern int fdatasync (int __fildes);
+# 1159 "/usr/include/unistd.h" 3 4
+extern char *crypt (const char *__key, const char *__salt)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+# 1198 "/usr/include/unistd.h" 3 4
+int getentropy (void *__buffer, size_t __length)
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+# 1218 "/usr/include/unistd.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/unistd_ext.h" 1 3 4
+# 1219 "/usr/include/unistd.h" 2 3 4
+
+
+# 6 "src/test_t/is_good.c" 2
+
+
+
 
 # 1 "./src/test_t/test_t.h" 1
 
@@ -2119,31 +3365,211 @@ extern char *stpncpy (char *__restrict __dest,
 # 7 "./src/test_t/test_t.h" 2
 # 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h" 1 3 4
 # 8 "./src/test_t/test_t.h" 2
+# 1 "/usr/include/time.h" 1 3 4
+# 29 "/usr/include/time.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4
+# 30 "/usr/include/time.h" 2 3 4
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
+# 34 "/usr/include/time.h" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 3 4
+
+
+
+
+
+
+struct tm
+{
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+
+
+  long int tm_gmtoff;
+  const char *tm_zone;
+
+
+
+
+};
+# 40 "/usr/include/time.h" 2 3 4
+# 48 "/usr/include/time.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4
+
+
+
+
+
+
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+# 49 "/usr/include/time.h" 2 3 4
+struct sigevent;
+# 68 "/usr/include/time.h" 3 4
+
+
+
+
+extern clock_t clock (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern time_t time (time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern double difftime (time_t __time1, time_t __time0)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
+
+
+extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
+# 100 "/usr/include/time.h" 3 4
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+   const char *__restrict __format,
+   const struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
+# 116 "/usr/include/time.h" 3 4
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+     const char *__restrict __format,
+     const struct tm *__restrict __tp,
+     locale_t __loc) __attribute__ ((__nothrow__ , __leaf__));
+# 132 "/usr/include/time.h" 3 4
+extern struct tm *gmtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern struct tm *localtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
+# 154 "/usr/include/time.h" 3 4
+extern struct tm *gmtime_r (const time_t *__restrict __timer,
+       struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern struct tm *localtime_r (const time_t *__restrict __timer,
+          struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
+# 179 "/usr/include/time.h" 3 4
+extern char *asctime (const struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern char *ctime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
+# 197 "/usr/include/time.h" 3 4
+extern char *asctime_r (const struct tm *__restrict __tp,
+   char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern char *ctime_r (const time_t *__restrict __timer,
+        char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
+# 217 "/usr/include/time.h" 3 4
+extern char *__tzname[2];
+extern int __daylight;
+extern long int __timezone;
+
+
+
+
+extern char *tzname[2];
+
+
+
+extern void tzset (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern int daylight;
+extern long int timezone;
+# 249 "/usr/include/time.h" 3 4
+extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
+
+extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
+# 262 "/usr/include/time.h" 3 4
+extern int dysize (int __year) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
+# 272 "/usr/include/time.h" 3 4
+extern int nanosleep (const struct timespec *__requested_time,
+        struct timespec *__remaining);
+
+
+extern int clock_getres (clockid_t __clock_id, struct timespec *__res) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
+     __attribute__ ((__nothrow__ , __leaf__));
+# 311 "/usr/include/time.h" 3 4
+extern int clock_nanosleep (clockid_t __clock_id, int __flags,
+       const struct timespec *__req,
+       struct timespec *__rem);
+# 326 "/usr/include/time.h" 3 4
+extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+extern int timer_create (clockid_t __clock_id,
+    struct sigevent *__restrict __evp,
+    timer_t *__restrict __timerid) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern int timer_settime (timer_t __timerid, int __flags,
+     const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     __attribute__ ((__nothrow__ , __leaf__));
+# 364 "/usr/include/time.h" 3 4
+extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+extern int timespec_get (struct timespec *__ts, int __base)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+# 440 "/usr/include/time.h" 3 4
+
+# 9 "./src/test_t/test_t.h" 2
 
 # 1 "./src/tools_t/tools_t.h" 1
+# 49 "./src/tools_t/tools_t.h"
 
-
-
-
-
-
-# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdbool.h" 1 3 4
-# 8 "./src/tools_t/tools_t.h" 2
-# 36 "./src/tools_t/tools_t.h"
-
-# 36 "./src/tools_t/tools_t.h"
-int COMPARE_N_TYPE_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_CHAR(char* dst, const char* src, size_t size); char MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); char MIN_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_CHAR(const char *array, size_t size);
-int COMPARE_N_TYPE_U_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_U_CHAR(unsigned char* dst, const unsigned char* src, size_t size); unsigned char MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); unsigned char MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size);
-int COMPARE_N_TYPE_INT(const void *,const void*); void COPY_ARRAY_TYPE_INT(int* dst, const int* src, size_t size); int MAX_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_INT(const int *array, size_t size); int MIN_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_INT(const int *array, size_t size);
-int COMPARE_N_TYPE_U_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_INT(unsigned int* dst, const unsigned int* src, size_t size); unsigned int MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); unsigned int MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size);
-int COMPARE_N_TYPE_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_L_INT(long int* dst, const long int* src, size_t size); long int MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); long int MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size);
-int COMPARE_N_TYPE_U_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_L_INT(unsigned long int* dst, const unsigned long int* src, size_t size); unsigned long int MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); unsigned long int MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size);
-int COMPARE_N_TYPE_SIZE_T(const void *,const void*); void COPY_ARRAY_TYPE_SIZE_T(size_t* dst, const size_t* src, size_t size); size_t MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size);
-int COMPARE_N_TYPE_FLOAT(const void *,const void*); void COPY_ARRAY_TYPE_FLOAT(float* dst, const float* src, size_t size); float MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); float MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size);
-int COMPARE_N_TYPE_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_DOUBLE(double* dst, const double* src, size_t size); double MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); double MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size);
-int COMPARE_N_TYPE_L_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_L_DOUBLE(long double* dst, const long double* src, size_t size); long double MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); long double MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size);
-int COMPARE_N_TYPE_STRING(const void *,const void*); void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size); char* MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); char* MIN_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_STRING(const char* *array, size_t size);
-# 10 "./src/test_t/test_t.h" 2
+# 49 "./src/tools_t/tools_t.h"
+int COMPARE_N_TYPE_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_CHAR(char* dst, const char* src, size_t size); char MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); char MIN_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_CHAR(const char *array, size_t size); char* TYPE_CHAR_TO_STR(char var);
+int COMPARE_N_TYPE_U_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_U_CHAR(unsigned char* dst, const unsigned char* src, size_t size); unsigned char MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); unsigned char MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); char* TYPE_U_CHAR_TO_STR(unsigned char var);
+int COMPARE_N_TYPE_INT(const void *,const void*); void COPY_ARRAY_TYPE_INT(int* dst, const int* src, size_t size); int MAX_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_INT(const int *array, size_t size); int MIN_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_INT(const int *array, size_t size); char* TYPE_INT_TO_STR(int var);
+int COMPARE_N_TYPE_U_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_INT(unsigned int* dst, const unsigned int* src, size_t size); unsigned int MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); unsigned int MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); char* TYPE_U_INT_TO_STR(unsigned int var);
+int COMPARE_N_TYPE_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_L_INT(long int* dst, const long int* src, size_t size); long int MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); long int MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size); char* TYPE_L_INT_TO_STR(long int var);
+int COMPARE_N_TYPE_U_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_L_INT(unsigned long int* dst, const unsigned long int* src, size_t size); unsigned long int MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); unsigned long int MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); char* TYPE_U_L_INT_TO_STR(unsigned long int var);
+int COMPARE_N_TYPE_SIZE_T(const void *,const void*); void COPY_ARRAY_TYPE_SIZE_T(size_t* dst, const size_t* src, size_t size); size_t MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); char* TYPE_SIZE_T_TO_STR(size_t var);
+int COMPARE_N_TYPE_FLOAT(const void *,const void*); void COPY_ARRAY_TYPE_FLOAT(float* dst, const float* src, size_t size); float MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); float MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size); char* TYPE_FLOAT_TO_STR(float var);
+int COMPARE_N_TYPE_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_DOUBLE(double* dst, const double* src, size_t size); double MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); double MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size); char* TYPE_DOUBLE_TO_STR(double var);
+int COMPARE_N_TYPE_L_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_L_DOUBLE(long double* dst, const long double* src, size_t size); long double MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); long double MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); char* TYPE_L_DOUBLE_TO_STR(long double var);
+int COMPARE_N_TYPE_STRING(const void *,const void*); void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size); char* MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); char* MIN_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_STRING(const char* *array, size_t size); char* TYPE_STRING_TO_STR(char* var);
+# 11 "./src/test_t/test_t.h" 2
 
 
 struct func {
@@ -2157,19 +3583,35 @@ struct func {
 
 void vprintf_colored(char *color, char * format, ...);
 
-void run_all_test();
+void run_all_tests();
 void execute_all(struct func *fun);
 void append_func(void (*run)(void), char *name);
 void clear_all_func();
-
-
-void init_test();
-# 5 "src/test_t/is_good.c" 2
+void run_some_tests(size_t cnt, ... );
+void run_all_tests_exept(size_t cnt, ... );
+void run_some_tests_ordered(size_t cnt, ... );
 
 
 
-void test_size_permutation0(void); __attribute__((constructor)) void append_test_size_permutation0(void){ append_func(test_size_permutation0,"size_permutation test 0"); } void testsize_permutation0(void)
-{
+
+
+# 35 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 35 "./src/test_t/test_t.h"
+    expected_true_f(
+# 35 "./src/test_t/test_t.h" 3 4
+                    _Bool 
+# 35 "./src/test_t/test_t.h"
+                         val, const char* var_name, const char * func_name);
+
+# 36 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 36 "./src/test_t/test_t.h"
+    expected_false_f(
+# 36 "./src/test_t/test_t.h" 3 4
+                     _Bool 
+# 36 "./src/test_t/test_t.h"
+                          val, const char* var_name, const char * func_name);
 
 
 
@@ -2177,26 +3619,258 @@ void test_size_permutation0(void); __attribute__((constructor)) void append_test
 
 
 
-  printf("test size_permutation2\n");
-}
-void test_size_permutation21(void); __attribute__((constructor)) void append_test_size_permutation21(void){ append_func(test_size_permutation21,"size_permutation2 test 1"); } void testsize_permutation21(void)
-{
-  printf("test size_permutation2\n");
+# 43 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 43 "./src/test_t/test_t.h"
+expected_eq_TYPE_CHAR(char var1, char var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 44 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 44 "./src/test_t/test_t.h"
+expected_eq_TYPE_U_CHAR(unsigned char var1, unsigned char var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 45 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 45 "./src/test_t/test_t.h"
+expected_eq_TYPE_INT(int var1, int var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 46 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 46 "./src/test_t/test_t.h"
+expected_eq_TYPE_U_INT(unsigned int var1, unsigned int var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 47 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 47 "./src/test_t/test_t.h"
+expected_eq_TYPE_L_INT(long int var1, long int var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 48 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 48 "./src/test_t/test_t.h"
+expected_eq_TYPE_U_L_INT(unsigned long int var1, unsigned long int var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 49 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 49 "./src/test_t/test_t.h"
+expected_eq_TYPE_SIZE_T(size_t var1, size_t var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 50 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 50 "./src/test_t/test_t.h"
+expected_eq_TYPE_FLOAT(float var1, float var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 51 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 51 "./src/test_t/test_t.h"
+expected_eq_TYPE_DOUBLE(double var1, double var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 52 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 52 "./src/test_t/test_t.h"
+expected_eq_TYPE_L_DOUBLE(long double var1, long double var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 53 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 53 "./src/test_t/test_t.h"
+expected_eq_TYPE_STRING(char* var1, char* var2, const char *var1_name, const char *var2_name, const char *func_name);
+# 11 "src/test_t/is_good.c" 2
 
 
-
-
-
-
-
-}
-void test_size_permutation22(void); __attribute__((constructor)) void append_test_size_permutation22(void){ append_func(test_size_permutation22,"size_permutation2 test 2"); } void testsize_permutation22(void){
-  printf("another size_permutation2\n");
-}
-void test_size_permutation23(void); __attribute__((constructor)) void append_test_size_permutation23(void){ append_func(test_size_permutation23,"size_permutation2 test 3"); } void testsize_permutation23(void){
+void test_size_permutation2____0(void); __attribute__((constructor)) void append_test_size_permutation20(void){ append_func(test_size_permutation2____0,"size_permutation2 test 0"); } void test_size_permutation2____0(void){
   printf("another size_permutation2 again\n");
+  if(expected_true_f(
+# 15 "src/test_t/is_good.c" 3 4
+ 0
+# 15 "src/test_t/is_good.c"
+ ,"false",__func__) == 
+# 15 "src/test_t/is_good.c" 3 4
+ 0
+# 15 "src/test_t/is_good.c"
+ ) return;;
 }
 
+void test_size_permutation____1(void); __attribute__((constructor)) void append_test_size_permutation1(void){ append_func(test_size_permutation____1,"size_permutation test 1"); } void test_size_permutation____1(void)
+{
+
+
+
+
+
+
+
+  printf("test size_permutation2\n");
+}
+void test_size_permutation2____2(void); __attribute__((constructor)) void append_test_size_permutation22(void){ append_func(test_size_permutation2____2,"size_permutation2 test 2"); } void test_size_permutation2____2(void){
+  printf("another size_permutation2 again false\n");
+  
+# 31 "src/test_t/is_good.c" 3 4
+ _Bool 
+# 31 "src/test_t/is_good.c"
+      val_bool = 
+# 31 "src/test_t/is_good.c" 3 4
+                 0
+# 31 "src/test_t/is_good.c"
+                      ;
+  if(expected_true_f(val_bool,"val_bool",__func__) == 
+# 32 "src/test_t/is_good.c" 3 4
+ 0
+# 32 "src/test_t/is_good.c"
+ ) return;;
+}
+void test_size_permutation2____3(void); __attribute__((constructor)) void append_test_size_permutation23(void){ append_func(test_size_permutation2____3,"size_permutation2 test 3"); } void test_size_permutation2____3(void)
+{
+  printf("test size_permutation2\n");
+  
+# 37 "src/test_t/is_good.c" 3 4
+ _Bool 
+# 37 "src/test_t/is_good.c"
+      val_bool = 
+# 37 "src/test_t/is_good.c" 3 4
+                 1
+# 37 "src/test_t/is_good.c"
+                     ;
+  if(expected_false_f(val_bool,"val_bool",__func__) == 
+# 38 "src/test_t/is_good.c" 3 4
+ 0
+# 38 "src/test_t/is_good.c"
+ ) return;;
+
+
+
+
+
+
+
+}
+void test_float_equal____4(void); __attribute__((constructor)) void append_test_float_equal4(void){ append_func(test_float_equal____4,"float_equal test 4"); } void test_float_equal____4(void){
+  printf("another size_permutation2 float\n");
+  if(expected_true_f(
+# 49 "src/test_t/is_good.c" 3 4
+ 1
+# 49 "src/test_t/is_good.c"
+ ,"true",__func__) == 
+# 49 "src/test_t/is_good.c" 3 4
+ 0
+# 49 "src/test_t/is_good.c"
+ ) return;;
+  float a = 1.00001f;
+  float b = 1.00001f;
+  do{ if(expected_eq_TYPE_FLOAT(a, b, "a", "b", __func__) == 
+# 52 "src/test_t/is_good.c" 3 4
+ 0
+# 52 "src/test_t/is_good.c"
+ ) return ;} while(0);
+  b=1.0000101f;
+  do{ if(expected_eq_TYPE_FLOAT(a, b, "a", "b", __func__) == 
+# 54 "src/test_t/is_good.c" 3 4
+ 0
+# 54 "src/test_t/is_good.c"
+ ) return ;} while(0);
+  do{ if(expected_eq_TYPE_FLOAT(1.0000102f, b, "1.0000102f", "b", __func__) == 
+# 55 "src/test_t/is_good.c" 3 4
+ 0
+# 55 "src/test_t/is_good.c"
+ ) return ;} while(0);
+}
+void test_double_equal____5(void); __attribute__((constructor)) void append_test_double_equal5(void){ append_func(test_double_equal____5,"double_equal test 5"); } void test_double_equal____5(void){
+  printf("another size_permutation2 double\n");
+  if(expected_true_f(
+# 59 "src/test_t/is_good.c" 3 4
+ 1
+# 59 "src/test_t/is_good.c"
+ ,"true",__func__) == 
+# 59 "src/test_t/is_good.c" 3 4
+ 0
+# 59 "src/test_t/is_good.c"
+ ) return;;
+  double a = 1.00000001;
+  double b = 1.00000001;
+  do{ if(expected_eq_TYPE_DOUBLE(a, b, "a", "b", __func__) == 
+# 62 "src/test_t/is_good.c" 3 4
+ 0
+# 62 "src/test_t/is_good.c"
+ ) return ;} while(0);
+  b=1.00000001000000001;
+  do{ if(expected_eq_TYPE_DOUBLE(a, b, "a", "b", __func__) == 
+# 64 "src/test_t/is_good.c" 3 4
+ 0
+# 64 "src/test_t/is_good.c"
+ ) return ;} while(0);
+  do{ if(expected_eq_TYPE_DOUBLE(1.0000000100000002, b, "1.0000000100000002", "b", __func__) == 
+# 65 "src/test_t/is_good.c" 3 4
+ 0
+# 65 "src/test_t/is_good.c"
+ ) return ;} while(0);
+}
+
+void test_____6(void); __attribute__((constructor)) void append_test_6(void){ append_func(test_____6,"test 6"); } void test_____6(void){
+  unsigned char c = 'a';
+
+  do { if (0) fprintf(
+# 71 "src/test_t/is_good.c" 3 4
+ stderr
+# 71 "src/test_t/is_good.c"
+ , "%s:%d:%s(): " "another size_permutation2, a = %c\n", "src/test_t/is_good.c", 71, __func__, c); } while (0);
+  if(expected_false_f(
+# 72 "src/test_t/is_good.c" 3 4
+ 1
+# 72 "src/test_t/is_good.c"
+ ,"true",__func__) == 
+# 72 "src/test_t/is_good.c" 3 4
+ 0
+# 72 "src/test_t/is_good.c"
+ ) return;;
+  if(expected_true_f(
+# 73 "src/test_t/is_good.c" 3 4
+ 1
+# 73 "src/test_t/is_good.c"
+ ,"true",__func__) == 
+# 73 "src/test_t/is_good.c" 3 4
+ 0
+# 73 "src/test_t/is_good.c"
+ ) return;;
+  if(expected_true_f(
+# 74 "src/test_t/is_good.c" 3 4
+ 1
+# 74 "src/test_t/is_good.c"
+ ,"true",__func__) == 
+# 74 "src/test_t/is_good.c" 3 4
+ 0
+# 74 "src/test_t/is_good.c"
+ ) return;;
+}
+
+void test_____7(void); __attribute__((constructor)) void append_test_7(void){ append_func(test_____7,"test 7"); } void test_____7(void){
+  sleep(3);
+  int a = 5;
+  long b = 5;
+  do{ if(expected_eq_TYPE_L_INT(a, b, "a", "b", __func__) == 
+# 81 "src/test_t/is_good.c" 3 4
+ 0
+# 81 "src/test_t/is_good.c"
+ ) return ;} while(0);
+  a=4;
+  do{ if(expected_eq_TYPE_L_INT(a, b, "a", "b", __func__) == 
+# 83 "src/test_t/is_good.c" 3 4
+ 0
+# 83 "src/test_t/is_good.c"
+ ) return ;} while(0);
+
+}
+
+void test_expect____8(void); __attribute__((constructor)) void append_test_expect8(void){ append_func(test_expect____8,"expect test 8"); } void test_expect____8(void){
+  sleep(2);
+  int a = 5;
+  int b = 6;
+  expected_eq_TYPE_L_INT(a, b, "a", "b", __func__) ;;
+  expected_eq_TYPE_STRING("hello", "hello", "\"hello\"", "\"hello\"", __func__) ;;
+  float f1 = 1.00019999, f2=1.00019999;
+  expected_eq_TYPE_FLOAT(f1, f2, "f1", "f2", __func__) ;;
+
+
+}
+
+
 
 
 
@@ -2204,7 +3878,13 @@ void test_size_permutation23(void); __attribute__((constructor)) void append_tes
 int main(){
 
 
-  run_all_test();
+
+  run_all_tests();
+
+
+
+
+
   return 0;
 }
 # 0 "src/test_t/test_t.c"
@@ -4325,6 +6005,194 @@ extern char *stpncpy (char *__restrict __dest,
 # 7 "./src/test_t/test_t.h" 2
 # 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h" 1 3 4
 # 8 "./src/test_t/test_t.h" 2
+# 1 "/usr/include/time.h" 1 3 4
+# 29 "/usr/include/time.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4
+# 30 "/usr/include/time.h" 2 3 4
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
+# 34 "/usr/include/time.h" 2 3 4
+
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h" 1 3 4
+
+
+
+
+
+
+struct tm
+{
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+
+
+  long int tm_gmtoff;
+  const char *tm_zone;
+
+
+
+
+};
+# 40 "/usr/include/time.h" 2 3 4
+# 48 "/usr/include/time.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h" 1 3 4
+
+
+
+
+
+
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+# 49 "/usr/include/time.h" 2 3 4
+struct sigevent;
+# 68 "/usr/include/time.h" 3 4
+
+
+
+
+extern clock_t clock (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern time_t time (time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern double difftime (time_t __time1, time_t __time0)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
+
+
+extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
+# 100 "/usr/include/time.h" 3 4
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+   const char *__restrict __format,
+   const struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
+# 116 "/usr/include/time.h" 3 4
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+     const char *__restrict __format,
+     const struct tm *__restrict __tp,
+     locale_t __loc) __attribute__ ((__nothrow__ , __leaf__));
+# 132 "/usr/include/time.h" 3 4
+extern struct tm *gmtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern struct tm *localtime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
+# 154 "/usr/include/time.h" 3 4
+extern struct tm *gmtime_r (const time_t *__restrict __timer,
+       struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern struct tm *localtime_r (const time_t *__restrict __timer,
+          struct tm *__restrict __tp) __attribute__ ((__nothrow__ , __leaf__));
+# 179 "/usr/include/time.h" 3 4
+extern char *asctime (const struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern char *ctime (const time_t *__timer) __attribute__ ((__nothrow__ , __leaf__));
+# 197 "/usr/include/time.h" 3 4
+extern char *asctime_r (const struct tm *__restrict __tp,
+   char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern char *ctime_r (const time_t *__restrict __timer,
+        char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
+# 217 "/usr/include/time.h" 3 4
+extern char *__tzname[2];
+extern int __daylight;
+extern long int __timezone;
+
+
+
+
+extern char *tzname[2];
+
+
+
+extern void tzset (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern int daylight;
+extern long int timezone;
+# 249 "/usr/include/time.h" 3 4
+extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
+
+extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__ , __leaf__));
+# 262 "/usr/include/time.h" 3 4
+extern int dysize (int __year) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
+# 272 "/usr/include/time.h" 3 4
+extern int nanosleep (const struct timespec *__requested_time,
+        struct timespec *__remaining);
+
+
+extern int clock_getres (clockid_t __clock_id, struct timespec *__res) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
+     __attribute__ ((__nothrow__ , __leaf__));
+# 311 "/usr/include/time.h" 3 4
+extern int clock_nanosleep (clockid_t __clock_id, int __flags,
+       const struct timespec *__req,
+       struct timespec *__rem);
+# 326 "/usr/include/time.h" 3 4
+extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+extern int timer_create (clockid_t __clock_id,
+    struct sigevent *__restrict __evp,
+    timer_t *__restrict __timerid) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern int timer_settime (timer_t __timerid, int __flags,
+     const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     __attribute__ ((__nothrow__ , __leaf__));
+# 364 "/usr/include/time.h" 3 4
+extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+extern int timespec_get (struct timespec *__ts, int __base)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+# 440 "/usr/include/time.h" 3 4
+
+# 9 "./src/test_t/test_t.h" 2
 
 # 1 "./src/tools_t/tools_t.h" 1
 
@@ -4335,21 +6203,21 @@ extern char *stpncpy (char *__restrict __dest,
 
 # 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdbool.h" 1 3 4
 # 8 "./src/tools_t/tools_t.h" 2
-# 36 "./src/tools_t/tools_t.h"
+# 49 "./src/tools_t/tools_t.h"
 
-# 36 "./src/tools_t/tools_t.h"
-int COMPARE_N_TYPE_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_CHAR(char* dst, const char* src, size_t size); char MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); char MIN_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_CHAR(const char *array, size_t size);
-int COMPARE_N_TYPE_U_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_U_CHAR(unsigned char* dst, const unsigned char* src, size_t size); unsigned char MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); unsigned char MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size);
-int COMPARE_N_TYPE_INT(const void *,const void*); void COPY_ARRAY_TYPE_INT(int* dst, const int* src, size_t size); int MAX_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_INT(const int *array, size_t size); int MIN_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_INT(const int *array, size_t size);
-int COMPARE_N_TYPE_U_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_INT(unsigned int* dst, const unsigned int* src, size_t size); unsigned int MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); unsigned int MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size);
-int COMPARE_N_TYPE_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_L_INT(long int* dst, const long int* src, size_t size); long int MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); long int MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size);
-int COMPARE_N_TYPE_U_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_L_INT(unsigned long int* dst, const unsigned long int* src, size_t size); unsigned long int MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); unsigned long int MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size);
-int COMPARE_N_TYPE_SIZE_T(const void *,const void*); void COPY_ARRAY_TYPE_SIZE_T(size_t* dst, const size_t* src, size_t size); size_t MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size);
-int COMPARE_N_TYPE_FLOAT(const void *,const void*); void COPY_ARRAY_TYPE_FLOAT(float* dst, const float* src, size_t size); float MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); float MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size);
-int COMPARE_N_TYPE_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_DOUBLE(double* dst, const double* src, size_t size); double MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); double MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size);
-int COMPARE_N_TYPE_L_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_L_DOUBLE(long double* dst, const long double* src, size_t size); long double MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); long double MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size);
-int COMPARE_N_TYPE_STRING(const void *,const void*); void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size); char* MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); char* MIN_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_STRING(const char* *array, size_t size);
-# 10 "./src/test_t/test_t.h" 2
+# 49 "./src/tools_t/tools_t.h"
+int COMPARE_N_TYPE_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_CHAR(char* dst, const char* src, size_t size); char MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); char MIN_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_CHAR(const char *array, size_t size); char* TYPE_CHAR_TO_STR(char var);
+int COMPARE_N_TYPE_U_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_U_CHAR(unsigned char* dst, const unsigned char* src, size_t size); unsigned char MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); unsigned char MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); char* TYPE_U_CHAR_TO_STR(unsigned char var);
+int COMPARE_N_TYPE_INT(const void *,const void*); void COPY_ARRAY_TYPE_INT(int* dst, const int* src, size_t size); int MAX_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_INT(const int *array, size_t size); int MIN_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_INT(const int *array, size_t size); char* TYPE_INT_TO_STR(int var);
+int COMPARE_N_TYPE_U_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_INT(unsigned int* dst, const unsigned int* src, size_t size); unsigned int MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); unsigned int MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); char* TYPE_U_INT_TO_STR(unsigned int var);
+int COMPARE_N_TYPE_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_L_INT(long int* dst, const long int* src, size_t size); long int MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); long int MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size); char* TYPE_L_INT_TO_STR(long int var);
+int COMPARE_N_TYPE_U_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_L_INT(unsigned long int* dst, const unsigned long int* src, size_t size); unsigned long int MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); unsigned long int MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); char* TYPE_U_L_INT_TO_STR(unsigned long int var);
+int COMPARE_N_TYPE_SIZE_T(const void *,const void*); void COPY_ARRAY_TYPE_SIZE_T(size_t* dst, const size_t* src, size_t size); size_t MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); char* TYPE_SIZE_T_TO_STR(size_t var);
+int COMPARE_N_TYPE_FLOAT(const void *,const void*); void COPY_ARRAY_TYPE_FLOAT(float* dst, const float* src, size_t size); float MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); float MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size); char* TYPE_FLOAT_TO_STR(float var);
+int COMPARE_N_TYPE_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_DOUBLE(double* dst, const double* src, size_t size); double MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); double MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size); char* TYPE_DOUBLE_TO_STR(double var);
+int COMPARE_N_TYPE_L_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_L_DOUBLE(long double* dst, const long double* src, size_t size); long double MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); long double MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); char* TYPE_L_DOUBLE_TO_STR(long double var);
+int COMPARE_N_TYPE_STRING(const void *,const void*); void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size); char* MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); char* MIN_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_STRING(const char* *array, size_t size); char* TYPE_STRING_TO_STR(char* var);
+# 11 "./src/test_t/test_t.h" 2
 
 
 struct func {
@@ -4363,99 +6231,3182 @@ struct func {
 
 void vprintf_colored(char *color, char * format, ...);
 
-void run_all_test();
+void run_all_tests();
 void execute_all(struct func *fun);
 void append_func(void (*run)(void), char *name);
 void clear_all_func();
+void run_some_tests(size_t cnt, ... );
+void run_all_tests_exept(size_t cnt, ... );
+void run_some_tests_ordered(size_t cnt, ... );
 
 
-void init_test();
+
+
+
+# 35 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 35 "./src/test_t/test_t.h"
+    expected_true_f(
+# 35 "./src/test_t/test_t.h" 3 4
+                    _Bool 
+# 35 "./src/test_t/test_t.h"
+                         val, const char* var_name, const char * func_name);
+
+# 36 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 36 "./src/test_t/test_t.h"
+    expected_false_f(
+# 36 "./src/test_t/test_t.h" 3 4
+                     _Bool 
+# 36 "./src/test_t/test_t.h"
+                          val, const char* var_name, const char * func_name);
+
+
+
+
+
+
+
+# 43 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 43 "./src/test_t/test_t.h"
+expected_eq_TYPE_CHAR(char var1, char var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 44 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 44 "./src/test_t/test_t.h"
+expected_eq_TYPE_U_CHAR(unsigned char var1, unsigned char var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 45 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 45 "./src/test_t/test_t.h"
+expected_eq_TYPE_INT(int var1, int var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 46 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 46 "./src/test_t/test_t.h"
+expected_eq_TYPE_U_INT(unsigned int var1, unsigned int var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 47 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 47 "./src/test_t/test_t.h"
+expected_eq_TYPE_L_INT(long int var1, long int var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 48 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 48 "./src/test_t/test_t.h"
+expected_eq_TYPE_U_L_INT(unsigned long int var1, unsigned long int var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 49 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 49 "./src/test_t/test_t.h"
+expected_eq_TYPE_SIZE_T(size_t var1, size_t var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 50 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 50 "./src/test_t/test_t.h"
+expected_eq_TYPE_FLOAT(float var1, float var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 51 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 51 "./src/test_t/test_t.h"
+expected_eq_TYPE_DOUBLE(double var1, double var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 52 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 52 "./src/test_t/test_t.h"
+expected_eq_TYPE_L_DOUBLE(long double var1, long double var2, const char *var1_name, const char *var2_name, const char *func_name);
+
+# 53 "./src/test_t/test_t.h" 3 4
+_Bool 
+# 53 "./src/test_t/test_t.h"
+expected_eq_TYPE_STRING(char* var1, char* var2, const char *var1_name, const char *var2_name, const char *func_name);
 # 2 "src/test_t/test_t.c" 2
-# 13 "src/test_t/test_t.c"
-void begin_f(){
-  printf("begin test_f\n");
+# 33 "src/test_t/test_t.c"
+struct failed_lists{
+  char *name;
+  struct failed_lists *next;
+} *failed_l = 
+# 36 "src/test_t/test_t.c" 3 4
+             ((void *)0)
+# 36 "src/test_t/test_t.c"
+                 ;
+
+void append_failed_list(const char *name_failed){
+  static struct failed_lists *failed_static = 
+# 39 "src/test_t/test_t.c" 3 4
+                                             ((void *)0)
+# 39 "src/test_t/test_t.c"
+                                                 ;
+  if(failed_static == 
+# 40 "src/test_t/test_t.c" 3 4
+                     ((void *)0)
+# 40 "src/test_t/test_t.c"
+                         ){
+    failed_l = malloc(sizeof(struct failed_lists));
+    failed_l->name = malloc(strlen(name_failed));
+    strcpy(failed_l->name, name_failed);
+    failed_l->next = 
+# 44 "src/test_t/test_t.c" 3 4
+                    ((void *)0)
+# 44 "src/test_t/test_t.c"
+                        ;
+    failed_static = failed_l;
+  }
+  else{
+    struct failed_lists *tmp = malloc(sizeof(struct failed_lists));
+    tmp->name = malloc(strlen(name_failed));
+    strcpy(tmp->name, name_failed);
+    tmp->next = 
+# 51 "src/test_t/test_t.c" 3 4
+               ((void *)0)
+# 51 "src/test_t/test_t.c"
+                   ;
+    failed_static->next = tmp;
+    failed_static = tmp;
+  }
 }
 
-struct func f_beging={"begin ftest",begin_f,
-# 17 "src/test_t/test_t.c" 3 4
-                                           ((void *)0)
-# 17 "src/test_t/test_t.c"
-                                               };
-# 28 "src/test_t/test_t.c"
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start){
+  return (time_stop.tv_sec - time_start.tv_sec) + 1.0e-9 * (time_stop.tv_nsec - time_start.tv_nsec);
+}
+
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start){
+  return 1.0e3 * (time_stop.tv_sec - time_start.tv_sec) + 1.0e-3 * (time_stop.tv_nsec - time_start.tv_nsec);
+}
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start){
+  return 1.0e9 * (time_stop.tv_sec - time_start.tv_sec) + (time_stop.tv_nsec - time_start.tv_nsec);
+}
+
+
+size_t count_tests = 0;
+
+size_t count_passed = 0;
+size_t count_passed_local = 0;
+
+size_t count_failed = 0;
+size_t count_failed_local = 0;
+
+
+struct func f_beging;
+
+
 void vprintf_colored(char *color, char *format, ...) {
    va_list args;
    printf("%s",color);
    
-# 31 "src/test_t/test_t.c" 3 4
+# 84 "src/test_t/test_t.c" 3 4
   __builtin_va_start(
-# 31 "src/test_t/test_t.c"
+# 84 "src/test_t/test_t.c"
   args
-# 31 "src/test_t/test_t.c" 3 4
+# 84 "src/test_t/test_t.c" 3 4
   ,
-# 31 "src/test_t/test_t.c"
+# 84 "src/test_t/test_t.c"
   format
-# 31 "src/test_t/test_t.c" 3 4
+# 84 "src/test_t/test_t.c" 3 4
   )
-# 31 "src/test_t/test_t.c"
+# 84 "src/test_t/test_t.c"
                         ;
    vprintf(format, args);
    
-# 33 "src/test_t/test_t.c" 3 4
+# 86 "src/test_t/test_t.c" 3 4
   __builtin_va_end(
-# 33 "src/test_t/test_t.c"
+# 86 "src/test_t/test_t.c"
   args
-# 33 "src/test_t/test_t.c" 3 4
+# 86 "src/test_t/test_t.c" 3 4
   )
-# 33 "src/test_t/test_t.c"
+# 86 "src/test_t/test_t.c"
               ;
    printf("\033[0m");
 }
 
+void printHK_color(char *color, char *HK, char * format, ...){
+   printf("%s%s%s",color, HK, "\033[0m");
+   va_list args;
+   
+# 93 "src/test_t/test_t.c" 3 4
+  __builtin_va_start(
+# 93 "src/test_t/test_t.c"
+  args
+# 93 "src/test_t/test_t.c" 3 4
+  ,
+# 93 "src/test_t/test_t.c"
+  format
+# 93 "src/test_t/test_t.c" 3 4
+  )
+# 93 "src/test_t/test_t.c"
+                        ;
+   vprintf(format, args);
+   
+# 95 "src/test_t/test_t.c" 3 4
+  __builtin_va_end(
+# 95 "src/test_t/test_t.c"
+  args
+# 95 "src/test_t/test_t.c" 3 4
+  )
+# 95 "src/test_t/test_t.c"
+              ;
+}
+# 113 "src/test_t/test_t.c"
+
+# 113 "src/test_t/test_t.c" 3 4
+_Bool 
+# 113 "src/test_t/test_t.c"
+expected_true_f(
+# 113 "src/test_t/test_t.c" 3 4
+_Bool 
+# 113 "src/test_t/test_t.c"
+val, const char * var_name, const char *func_name){ if(val == 
+# 113 "src/test_t/test_t.c" 3 4
+1
+# 113 "src/test_t/test_t.c"
+) { ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 113 "src/test_t/test_t.c" 3 4
+1
+# 113 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Value of: %s\nActual: %s\nExpected: %s\n\n", var_name, "false", "true"); return 
+# 113 "src/test_t/test_t.c" 3 4
+0
+# 113 "src/test_t/test_t.c"
+; } }
+
+# 114 "src/test_t/test_t.c" 3 4
+_Bool 
+# 114 "src/test_t/test_t.c"
+expected_false_f(
+# 114 "src/test_t/test_t.c" 3 4
+_Bool 
+# 114 "src/test_t/test_t.c"
+val, const char * var_name, const char *func_name){ if(val == 
+# 114 "src/test_t/test_t.c" 3 4
+0
+# 114 "src/test_t/test_t.c"
+) { ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 114 "src/test_t/test_t.c" 3 4
+1
+# 114 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Value of: %s\nActual: %s\nExpected: %s\n\n", var_name, "true", "false"); return 
+# 114 "src/test_t/test_t.c" 3 4
+0
+# 114 "src/test_t/test_t.c"
+; } }
+# 134 "src/test_t/test_t.c"
+
+# 134 "src/test_t/test_t.c" 3 4
+_Bool 
+# 134 "src/test_t/test_t.c"
+expected_eq_TYPE_CHAR(char var1, char var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_CHAR(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 134 "src/test_t/test_t.c" 3 4
+1
+# 134 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_CHAR_TO_STR(var1), var2_name, TYPE_CHAR_TO_STR(var2)); return 
+# 134 "src/test_t/test_t.c" 3 4
+0
+# 134 "src/test_t/test_t.c"
+; } }
+
+# 135 "src/test_t/test_t.c" 3 4
+_Bool 
+# 135 "src/test_t/test_t.c"
+expected_eq_TYPE_U_CHAR(unsigned char var1, unsigned char var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_U_CHAR(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 135 "src/test_t/test_t.c" 3 4
+1
+# 135 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_U_CHAR_TO_STR(var1), var2_name, TYPE_U_CHAR_TO_STR(var2)); return 
+# 135 "src/test_t/test_t.c" 3 4
+0
+# 135 "src/test_t/test_t.c"
+; } }
+
+# 136 "src/test_t/test_t.c" 3 4
+_Bool 
+# 136 "src/test_t/test_t.c"
+expected_eq_TYPE_INT(int var1, int var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_INT(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 136 "src/test_t/test_t.c" 3 4
+1
+# 136 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_INT_TO_STR(var1), var2_name, TYPE_INT_TO_STR(var2)); return 
+# 136 "src/test_t/test_t.c" 3 4
+0
+# 136 "src/test_t/test_t.c"
+; } }
+
+# 137 "src/test_t/test_t.c" 3 4
+_Bool 
+# 137 "src/test_t/test_t.c"
+expected_eq_TYPE_U_INT(unsigned int var1, unsigned int var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_U_INT(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 137 "src/test_t/test_t.c" 3 4
+1
+# 137 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_U_INT_TO_STR(var1), var2_name, TYPE_U_INT_TO_STR(var2)); return 
+# 137 "src/test_t/test_t.c" 3 4
+0
+# 137 "src/test_t/test_t.c"
+; } }
+
+# 138 "src/test_t/test_t.c" 3 4
+_Bool 
+# 138 "src/test_t/test_t.c"
+expected_eq_TYPE_L_INT(long int var1, long int var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_L_INT(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 138 "src/test_t/test_t.c" 3 4
+1
+# 138 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_L_INT_TO_STR(var1), var2_name, TYPE_L_INT_TO_STR(var2)); return 
+# 138 "src/test_t/test_t.c" 3 4
+0
+# 138 "src/test_t/test_t.c"
+; } }
+
+# 139 "src/test_t/test_t.c" 3 4
+_Bool 
+# 139 "src/test_t/test_t.c"
+expected_eq_TYPE_U_L_INT(unsigned long int var1, unsigned long int var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_U_L_INT(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 139 "src/test_t/test_t.c" 3 4
+1
+# 139 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_U_L_INT_TO_STR(var1), var2_name, TYPE_U_L_INT_TO_STR(var2)); return 
+# 139 "src/test_t/test_t.c" 3 4
+0
+# 139 "src/test_t/test_t.c"
+; } }
+
+# 140 "src/test_t/test_t.c" 3 4
+_Bool 
+# 140 "src/test_t/test_t.c"
+expected_eq_TYPE_SIZE_T(size_t var1, size_t var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_SIZE_T(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 140 "src/test_t/test_t.c" 3 4
+1
+# 140 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_SIZE_T_TO_STR(var1), var2_name, TYPE_SIZE_T_TO_STR(var2)); return 
+# 140 "src/test_t/test_t.c" 3 4
+0
+# 140 "src/test_t/test_t.c"
+; } }
+
+# 141 "src/test_t/test_t.c" 3 4
+_Bool 
+# 141 "src/test_t/test_t.c"
+expected_eq_TYPE_FLOAT(float var1, float var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_FLOAT(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 141 "src/test_t/test_t.c" 3 4
+1
+# 141 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_FLOAT_TO_STR(var1), var2_name, TYPE_FLOAT_TO_STR(var2)); return 
+# 141 "src/test_t/test_t.c" 3 4
+0
+# 141 "src/test_t/test_t.c"
+; } }
+
+# 142 "src/test_t/test_t.c" 3 4
+_Bool 
+# 142 "src/test_t/test_t.c"
+expected_eq_TYPE_DOUBLE(double var1, double var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_DOUBLE(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 142 "src/test_t/test_t.c" 3 4
+1
+# 142 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_DOUBLE_TO_STR(var1), var2_name, TYPE_DOUBLE_TO_STR(var2)); return 
+# 142 "src/test_t/test_t.c" 3 4
+0
+# 142 "src/test_t/test_t.c"
+; } }
+
+# 143 "src/test_t/test_t.c" 3 4
+_Bool 
+# 143 "src/test_t/test_t.c"
+expected_eq_TYPE_L_DOUBLE(long double var1, long double var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_L_DOUBLE(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 143 "src/test_t/test_t.c" 3 4
+1
+# 143 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_L_DOUBLE_TO_STR(var1), var2_name, TYPE_L_DOUBLE_TO_STR(var2)); return 
+# 143 "src/test_t/test_t.c" 3 4
+0
+# 143 "src/test_t/test_t.c"
+; } }
+
+# 144 "src/test_t/test_t.c" 3 4
+_Bool 
+# 144 "src/test_t/test_t.c"
+expected_eq_TYPE_STRING(char* var1, char* var2, const char *var1_name, const char *var2_name, const char *func_name){ if(COMPARE_N_TYPE_STRING(&var1, &var2) == 0){ ++count_passed_local; printHK_color("\033[0;32m","[----------]"," 1 test passed from %s \n\n",func_name); return 
+# 144 "src/test_t/test_t.c" 3 4
+1
+# 144 "src/test_t/test_t.c"
+; }else { ++count_failed_local; printHK_color("\033[0;31m","[----------]"," 1 test failed from %s \n",func_name); printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n" ,var1_name, TYPE_STRING_TO_STR(var1), var2_name, TYPE_STRING_TO_STR(var2)); return 
+# 144 "src/test_t/test_t.c" 3 4
+0
+# 144 "src/test_t/test_t.c"
+; } }
+
+
 
 void
 append_func(void (*run)(void), char *name){
-  static struct func *f_static=&f_beging;
-  struct func *tmp = malloc(sizeof(struct func));
-  tmp->run = run;
-  tmp->name = malloc(strlen(name));
-  strcpy(tmp->name,name);
-  tmp->next = 
-# 45 "src/test_t/test_t.c" 3 4
-             ((void *)0)
-# 45 "src/test_t/test_t.c"
+  static struct func *f_static = 
+# 150 "src/test_t/test_t.c" 3 4
+                                ((void *)0)
+# 150 "src/test_t/test_t.c"
+                                    ;
+  if(f_static == 
+# 151 "src/test_t/test_t.c" 3 4
+                ((void *)0)
+# 151 "src/test_t/test_t.c"
+                    ){
+    f_static = &f_beging;
+    f_static->name = malloc(strlen(name));
+    strcpy(f_static->name,name);
+    f_static->run = run;
+    f_static->next = 
+# 156 "src/test_t/test_t.c" 3 4
+                    ((void *)0)
+# 156 "src/test_t/test_t.c"
+                        ;
+  }
+  else{
+    struct func *tmp = malloc(sizeof(struct func));
+    tmp->run = run;
+    tmp->name = malloc(strlen(name));
+    strcpy(tmp->name,name);
+    tmp->next = 
+# 163 "src/test_t/test_t.c" 3 4
+               ((void *)0)
+# 163 "src/test_t/test_t.c"
+                   ;
+    f_static->next = tmp;
+    f_static = tmp;
+  }
+  ++count_tests;
+}
+
+void begin_execute_func(char *fun_ame, struct timespec *start_t){
+  clock_gettime(
+# 171 "src/test_t/test_t.c" 3 4
+               0
+# 171 "src/test_t/test_t.c"
+                             , start_t);
+  vprintf_colored("\033[0;32m","[RUN       ]");
+  printf(" %s\n", fun_ame);
+  count_passed_local = 0;
+  count_failed_local = 0;
+}
+void end_execute_func(char *fun_ame, struct timespec start_t){
+  struct timespec end_t; clock_gettime(
+# 178 "src/test_t/test_t.c" 3 4
+                                      0
+# 178 "src/test_t/test_t.c"
+                                                    , &end_t);
+  if(count_failed_local){
+    ++count_failed;
+    append_failed_list(fun_ame);
+
+    printHK_color("\033[0;31m", "[  FAILED  ]", " %lu tests failed from %s\n",count_failed_local,fun_ame);
+    if(0) printHK_color("\033[0;31m","[      DONE]"," %lu tests passed from %s (%lf s)\n\n",count_passed_local,fun_ame, diff_timespec_seconds(end_t, start_t));
+    else if(0) printHK_color("\033[0;31m","[      DONE]"," %lu tests passed from %s (%ld ns)\n\n",count_passed_local,fun_ame, diff_timespec_nanoseconds(end_t, start_t));
+    else printHK_color("\033[0;31m","[      DONE]"," %lu tests passed from %s (%lf ms)\n\n",count_passed_local,fun_ame, diff_timespec_seconds(end_t, start_t));
+  }
+  else
+
+  {
+    ++count_passed;
+    if(0) printHK_color("\033[0;32m","[      DONE]"," %lu tests passed from %s (%lf s)\n\n",count_passed_local,fun_ame, diff_timespec_seconds(end_t, start_t));
+    else if(0) printHK_color("\033[0;32m","[      DONE]"," %lu tests passed from %s (%ld ns)\n\n",count_passed_local,fun_ame, diff_timespec_nanoseconds(end_t, start_t));
+    else printHK_color("\033[0;32m","[      DONE]"," %lu tests passed from %s (%lf ms)\n\n",count_passed_local,fun_ame, diff_timespec_milliseconds(end_t, start_t));
+
+  }
+}
+
+void head_run(size_t nbtest, struct timespec *start_t){
+  clock_gettime(
+# 200 "src/test_t/test_t.c" 3 4
+               0
+# 200 "src/test_t/test_t.c"
+                             , start_t);
+  printHK_color("\033[0;32m", "[==========]"," Running %lu tests.\n",nbtest);
+}
+
+void list_failed_test(struct failed_lists *failed_lst){
+  printHK_color("\033[0;31m", "[  FAILED  ]"," %s\n",failed_lst->name);
+  if(failed_lst->next) list_failed_test(failed_lst->next);
+}
+
+
+void
+stat_end_run(size_t ntst, struct timespec start_t){
+  struct timespec end_t; clock_gettime(
+# 212 "src/test_t/test_t.c" 3 4
+                                      0
+# 212 "src/test_t/test_t.c"
+                                                    , &end_t);
+  if(0) printHK_color("\033[0;32m", "[==========]"," %lu tests ran. (%lf s total)\n",ntst, diff_timespec_seconds(end_t, start_t));
+  else if(0) printHK_color("\033[0;32m", "[==========]"," %lu tests ran. (%ld ns total)\n",ntst, diff_timespec_nanoseconds(end_t, start_t));
+  else printHK_color("\033[0;32m", "[==========]"," %lu tests ran. (%lf ms total)\n",ntst, diff_timespec_milliseconds(end_t, start_t));
+  printHK_color("\033[0;32m", "[  PASSED  ]"," %lu tests\n", count_passed);
+  if(failed_l != 
+# 217 "src/test_t/test_t.c" 3 4
+                ((void *)0)
+# 217 "src/test_t/test_t.c"
+                    ){
+    printHK_color("\033[0;31m", "[  FAILED  ]"," %lu tests, listed below:\n",count_failed);
+    list_failed_test(failed_l);
+  }
+}
+
+
+# 223 "src/test_t/test_t.c" 3 4
+_Bool 
+# 223 "src/test_t/test_t.c"
+    is_in_array(size_t *array, size_t sz, size_t num){
+  
+# 224 "src/test_t/test_t.c" 3 4
+ _Bool 
+# 224 "src/test_t/test_t.c"
+      found = 
+# 224 "src/test_t/test_t.c" 3 4
+              0
+# 224 "src/test_t/test_t.c"
+                   ;
+  for(size_t i = 0; i < sz; ++i){
+    if(array[i] == num){
+      found = 
+# 227 "src/test_t/test_t.c" 3 4
+             1
+# 227 "src/test_t/test_t.c"
                  ;
-  f_static->next = tmp;
-  f_static = tmp;
+      break;
+    }
+  }
+  return found;
 }
 
 void execute_all(struct func *fun){
-  static size_t cur_test = 0;
-  printf("test %lu : %s\n",cur_test++, fun->name);
-  fun->run();
-  if(fun->next) execute_all(fun->next);
+  struct func *tmp = fun;
+  struct timespec start_t;
+
+  while(tmp){
+    begin_execute_func(tmp->name, &start_t);
+    tmp->run();
+    end_execute_func(tmp->name, start_t);
+    tmp = tmp->next;
+  }
+}
+
+void execute_one_test(struct func *fun, size_t num){
+  size_t cur = 0;
+  struct timespec start_t;
+  struct func *tmp = fun;
+  while(tmp){
+    if(cur++ == num){
+      begin_execute_func(fun->name, &start_t);
+      fun->run();
+      end_execute_func(fun->name, start_t);
+    }
+    tmp = tmp->next;
+  }
+}
+
+
+void execute_some_tests_ordered(struct func *fun, size_t cnt, size_t *array )
+{
+  struct timespec start_t;
+  struct func *tmp = fun;
+  size_t cur = 0, index = 0;
+
+  while(tmp){
+    if((cur < cnt) && (index++ == array[cur])){
+      begin_execute_func(tmp->name, &start_t);
+      tmp->run();
+      end_execute_func(tmp->name, start_t);
+      ++cur;
+    }
+    tmp = tmp->next;
+  }
 }
 
 void
-run_all_test()
+run_some_tests(size_t cnt, ...)
 {
-  execute_all(&f_beging);
+   struct timespec start_t;
+   head_run(cnt, &start_t);
+   va_list args;
+   
+# 284 "src/test_t/test_t.c" 3 4
+  __builtin_va_start(
+# 284 "src/test_t/test_t.c"
+  args
+# 284 "src/test_t/test_t.c" 3 4
+  ,
+# 284 "src/test_t/test_t.c"
+  cnt
+# 284 "src/test_t/test_t.c" 3 4
+  )
+# 284 "src/test_t/test_t.c"
+                     ;
+   for(size_t i=0; i < cnt; ++i){
+    execute_one_test(&f_beging, 
+# 286 "src/test_t/test_t.c" 3 4
+                               __builtin_va_arg(
+# 286 "src/test_t/test_t.c"
+                               args
+# 286 "src/test_t/test_t.c" 3 4
+                               ,
+# 286 "src/test_t/test_t.c"
+                               size_t
+# 286 "src/test_t/test_t.c" 3 4
+                               )
+# 286 "src/test_t/test_t.c"
+                                                   );
+   }
+   
+# 288 "src/test_t/test_t.c" 3 4
+  __builtin_va_end(
+# 288 "src/test_t/test_t.c"
+  args
+# 288 "src/test_t/test_t.c" 3 4
+  )
+# 288 "src/test_t/test_t.c"
+              ;
+   stat_end_run(cnt, start_t);
+}
+
+void
+run_some_tests_ordered(size_t cnt, ... )
+{
+   struct timespec start_t;
+   head_run(cnt, &start_t);
+   va_list args;
+   
+# 298 "src/test_t/test_t.c" 3 4
+  __builtin_va_start(
+# 298 "src/test_t/test_t.c"
+  args
+# 298 "src/test_t/test_t.c" 3 4
+  ,
+# 298 "src/test_t/test_t.c"
+  cnt
+# 298 "src/test_t/test_t.c" 3 4
+  )
+# 298 "src/test_t/test_t.c"
+                     ;
+   size_t *array=malloc(cnt*sizeof(size_t));
+   for(size_t i=0; i < cnt; ++i){
+    array[i] = 
+# 301 "src/test_t/test_t.c" 3 4
+              __builtin_va_arg(
+# 301 "src/test_t/test_t.c"
+              args
+# 301 "src/test_t/test_t.c" 3 4
+              ,
+# 301 "src/test_t/test_t.c"
+              size_t
+# 301 "src/test_t/test_t.c" 3 4
+              )
+# 301 "src/test_t/test_t.c"
+                                  ;
+   }
+
+   execute_some_tests_ordered(&f_beging, cnt, array);
+   
+# 305 "src/test_t/test_t.c" 3 4
+  __builtin_va_end(
+# 305 "src/test_t/test_t.c"
+  args
+# 305 "src/test_t/test_t.c" 3 4
+  )
+# 305 "src/test_t/test_t.c"
+              ;
+   stat_end_run(cnt, start_t);
+}
+
+
+
+
+void execute_all_tests_exept(struct func *fun, size_t cnt, size_t *array )
+{
+  struct timespec start_t;
+  struct func *tmp = fun;
+  size_t cur = 0;
+  while(tmp){
+    if(!is_in_array(array, cnt, cur++)){
+      begin_execute_func(tmp->name, &start_t);
+      tmp->run();
+      end_execute_func(tmp->name, start_t);
+    }
+    tmp = tmp->next;
+  }
+}
+
+void
+run_all_tests_exept(size_t cnt, ... )
+{
+   struct timespec start_t;
+   if(count_tests >= cnt)
+      head_run(count_tests - cnt, &start_t);
+   va_list args;
+   
+# 334 "src/test_t/test_t.c" 3 4
+  __builtin_va_start(
+# 334 "src/test_t/test_t.c"
+  args
+# 334 "src/test_t/test_t.c" 3 4
+  ,
+# 334 "src/test_t/test_t.c"
+  cnt
+# 334 "src/test_t/test_t.c" 3 4
+  )
+# 334 "src/test_t/test_t.c"
+                     ;
+   size_t *array=malloc(cnt*sizeof(size_t));
+   for(size_t i=0; i < cnt; ++i){
+      array[i] = 
+# 337 "src/test_t/test_t.c" 3 4
+                __builtin_va_arg(
+# 337 "src/test_t/test_t.c"
+                args
+# 337 "src/test_t/test_t.c" 3 4
+                ,
+# 337 "src/test_t/test_t.c"
+                size_t
+# 337 "src/test_t/test_t.c" 3 4
+                )
+# 337 "src/test_t/test_t.c"
+                                    ;
+   }
+
+   execute_all_tests_exept(&f_beging, cnt, array);
+   
+# 341 "src/test_t/test_t.c" 3 4
+  __builtin_va_end(
+# 341 "src/test_t/test_t.c"
+  args
+# 341 "src/test_t/test_t.c" 3 4
+  )
+# 341 "src/test_t/test_t.c"
+              ;
+   if(count_tests >= cnt)
+     stat_end_run(count_tests - cnt, start_t);
+}
+
+
+void
+run_all_tests()
+{
+   struct timespec start_t;
+   head_run(count_tests, &start_t);
+   execute_all(&f_beging);
+   stat_end_run(count_tests, start_t);
 }
 
 void
 clear_all_func(struct func **fun)
 {
   if(*fun != 
-# 66 "src/test_t/test_t.c" 3 4
+# 359 "src/test_t/test_t.c" 3 4
             ((void *)0)
-# 66 "src/test_t/test_t.c"
+# 359 "src/test_t/test_t.c"
                 )
     {
       clear_all_func(&((*fun)->next));
       free(*fun);
       *fun = 
-# 70 "src/test_t/test_t.c" 3 4
+# 363 "src/test_t/test_t.c" 3 4
             ((void *)0)
-# 70 "src/test_t/test_t.c"
+# 363 "src/test_t/test_t.c"
                 ;
     }
 }
+# 0 "src/tools_t/tools_t.c"
+# 0 "<built-in>"
+# 0 "<command-line>"
+# 1 "/usr/include/stdc-predef.h" 1 3 4
+# 0 "<command-line>" 2
+# 1 "src/tools_t/tools_t.c"
+# 1 "./src/tools_t/tools_t.h" 1
+
+
+
+# 1 "/usr/include/stdio.h" 1 3 4
+# 27 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
+# 33 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 3 4
+# 1 "/usr/include/features.h" 1 3 4
+# 392 "/usr/include/features.h" 3 4
+# 1 "/usr/include/features-time64.h" 1 3 4
+# 20 "/usr/include/features-time64.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
+# 21 "/usr/include/features-time64.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4
+# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
+# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4
+# 22 "/usr/include/features-time64.h" 2 3 4
+# 393 "/usr/include/features.h" 2 3 4
+# 486 "/usr/include/features.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
+# 559 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
+# 560 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
+# 561 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
+# 487 "/usr/include/features.h" 2 3 4
+# 510 "/usr/include/features.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
+# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
+# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
+# 511 "/usr/include/features.h" 2 3 4
+# 34 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 2 3 4
+# 28 "/usr/include/stdio.h" 2 3 4
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4
+# 209 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4
+
+# 209 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4
+typedef long unsigned int size_t;
+# 34 "/usr/include/stdio.h" 2 3 4
+
+
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h" 1 3 4
+# 40 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdarg.h" 3 4
+typedef __builtin_va_list __gnuc_va_list;
+# 37 "/usr/include/stdio.h" 2 3 4
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4
+# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
+# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 1 3 4
+# 19 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
+# 20 "/usr/include/x86_64-linux-gnu/bits/timesize.h" 2 3 4
+# 29 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
+
+
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+
+
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+
+typedef signed long int __int64_t;
+typedef unsigned long int __uint64_t;
+
+
+
+
+
+
+typedef __int8_t __int_least8_t;
+typedef __uint8_t __uint_least8_t;
+typedef __int16_t __int_least16_t;
+typedef __uint16_t __uint_least16_t;
+typedef __int32_t __int_least32_t;
+typedef __uint32_t __uint_least32_t;
+typedef __int64_t __int_least64_t;
+typedef __uint64_t __uint_least64_t;
+
+
+
+typedef long int __quad_t;
+typedef unsigned long int __u_quad_t;
+
+
+
+
+
+
+
+typedef long int __intmax_t;
+typedef unsigned long int __uintmax_t;
+# 141 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
+# 142 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/time64.h" 1 3 4
+# 143 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
+
+
+typedef unsigned long int __dev_t;
+typedef unsigned int __uid_t;
+typedef unsigned int __gid_t;
+typedef unsigned long int __ino_t;
+typedef unsigned long int __ino64_t;
+typedef unsigned int __mode_t;
+typedef unsigned long int __nlink_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef int __pid_t;
+typedef struct { int __val[2]; } __fsid_t;
+typedef long int __clock_t;
+typedef unsigned long int __rlim_t;
+typedef unsigned long int __rlim64_t;
+typedef unsigned int __id_t;
+typedef long int __time_t;
+typedef unsigned int __useconds_t;
+typedef long int __suseconds_t;
+typedef long int __suseconds64_t;
+
+typedef int __daddr_t;
+typedef int __key_t;
+
+
+typedef int __clockid_t;
+
+
+typedef void * __timer_t;
+
+
+typedef long int __blksize_t;
+
+
+
+
+typedef long int __blkcnt_t;
+typedef long int __blkcnt64_t;
+
+
+typedef unsigned long int __fsblkcnt_t;
+typedef unsigned long int __fsblkcnt64_t;
+
+
+typedef unsigned long int __fsfilcnt_t;
+typedef unsigned long int __fsfilcnt64_t;
+
+
+typedef long int __fsword_t;
+
+typedef long int __ssize_t;
+
+
+typedef long int __syscall_slong_t;
+
+typedef unsigned long int __syscall_ulong_t;
+
+
+
+typedef __off64_t __loff_t;
+typedef char *__caddr_t;
+
+
+typedef long int __intptr_t;
+
+
+typedef unsigned int __socklen_t;
+
+
+
+
+typedef int __sig_atomic_t;
+# 39 "/usr/include/stdio.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 1 3 4
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 1 3 4
+# 13 "/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h" 3 4
+typedef struct
+{
+  int __count;
+  union
+  {
+    unsigned int __wch;
+    char __wchb[4];
+  } __value;
+} __mbstate_t;
+# 6 "/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h" 2 3 4
+
+
+
+
+typedef struct _G_fpos_t
+{
+  __off_t __pos;
+  __mbstate_t __state;
+} __fpos_t;
+# 40 "/usr/include/stdio.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 1 3 4
+# 10 "/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h" 3 4
+typedef struct _G_fpos64_t
+{
+  __off64_t __pos;
+  __mbstate_t __state;
+} __fpos64_t;
+# 41 "/usr/include/stdio.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/__FILE.h" 1 3 4
+
+
+
+struct _IO_FILE;
+typedef struct _IO_FILE __FILE;
+# 42 "/usr/include/stdio.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/FILE.h" 1 3 4
+
+
+
+struct _IO_FILE;
+
+
+typedef struct _IO_FILE FILE;
+# 43 "/usr/include/stdio.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 1 3 4
+# 35 "/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h" 3 4
+struct _IO_FILE;
+struct _IO_marker;
+struct _IO_codecvt;
+struct _IO_wide_data;
+
+
+
+
+typedef void _IO_lock_t;
+
+
+
+
+
+struct _IO_FILE
+{
+  int _flags;
+
+
+  char *_IO_read_ptr;
+  char *_IO_read_end;
+  char *_IO_read_base;
+  char *_IO_write_base;
+  char *_IO_write_ptr;
+  char *_IO_write_end;
+  char *_IO_buf_base;
+  char *_IO_buf_end;
+
+
+  char *_IO_save_base;
+  char *_IO_backup_base;
+  char *_IO_save_end;
+
+  struct _IO_marker *_markers;
+
+  struct _IO_FILE *_chain;
+
+  int _fileno;
+  int _flags2;
+  __off_t _old_offset;
+
+
+  unsigned short _cur_column;
+  signed char _vtable_offset;
+  char _shortbuf[1];
+
+  _IO_lock_t *_lock;
+
+
+
+
+
+
+
+  __off64_t _offset;
+
+  struct _IO_codecvt *_codecvt;
+  struct _IO_wide_data *_wide_data;
+  struct _IO_FILE *_freeres_list;
+  void *_freeres_buf;
+  size_t __pad5;
+  int _mode;
+
+  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
+};
+# 44 "/usr/include/stdio.h" 2 3 4
+# 52 "/usr/include/stdio.h" 3 4
+typedef __gnuc_va_list va_list;
+# 63 "/usr/include/stdio.h" 3 4
+typedef __off_t off_t;
+# 77 "/usr/include/stdio.h" 3 4
+typedef __ssize_t ssize_t;
+
+
+
+
+
+
+typedef __fpos_t fpos_t;
+# 133 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
+# 134 "/usr/include/stdio.h" 2 3 4
+# 143 "/usr/include/stdio.h" 3 4
+extern FILE *stdin;
+extern FILE *stdout;
+extern FILE *stderr;
+
+
+
+
+
+
+extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));
+
+extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern int renameat (int __oldfd, const char *__old, int __newfd,
+       const char *__new) __attribute__ ((__nothrow__ , __leaf__));
+# 178 "/usr/include/stdio.h" 3 4
+extern int fclose (FILE *__stream);
+# 188 "/usr/include/stdio.h" 3 4
+extern FILE *tmpfile (void)
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+# 205 "/usr/include/stdio.h" 3 4
+extern char *tmpnam (char[20]) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+extern char *tmpnam_r (char __s[20]) __attribute__ ((__nothrow__ , __leaf__)) ;
+# 222 "/usr/include/stdio.h" 3 4
+extern char *tempnam (const char *__dir, const char *__pfx)
+   __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (__builtin_free, 1)));
+
+
+
+
+
+
+extern int fflush (FILE *__stream);
+# 239 "/usr/include/stdio.h" 3 4
+extern int fflush_unlocked (FILE *__stream);
+# 258 "/usr/include/stdio.h" 3 4
+extern FILE *fopen (const char *__restrict __filename,
+      const char *__restrict __modes)
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+
+
+
+
+extern FILE *freopen (const char *__restrict __filename,
+        const char *__restrict __modes,
+        FILE *__restrict __stream) ;
+# 293 "/usr/include/stdio.h" 3 4
+extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__))
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+# 308 "/usr/include/stdio.h" 3 4
+extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
+  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+
+
+
+
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__))
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (fclose, 1))) ;
+# 328 "/usr/include/stdio.h" 3 4
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+      int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+         size_t __size) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+
+extern int fprintf (FILE *__restrict __stream,
+      const char *__restrict __format, ...);
+
+
+
+
+extern int printf (const char *__restrict __format, ...);
+
+extern int sprintf (char *__restrict __s,
+      const char *__restrict __format, ...) __attribute__ ((__nothrow__));
+
+
+
+
+
+extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg);
+
+
+
+
+extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
+
+extern int vsprintf (char *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg) __attribute__ ((__nothrow__));
+
+
+
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+       const char *__restrict __format, ...)
+     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));
+
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+        const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));
+# 403 "/usr/include/stdio.h" 3 4
+extern int vdprintf (int __fd, const char *__restrict __fmt,
+       __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, const char *__restrict __fmt, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+
+
+
+
+
+
+
+extern int fscanf (FILE *__restrict __stream,
+     const char *__restrict __format, ...) ;
+
+
+
+
+extern int scanf (const char *__restrict __format, ...) ;
+
+extern int sscanf (const char *__restrict __s,
+     const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 1 3 4
+# 119 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 1 3 4
+# 24 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/long-double.h" 1 3 4
+# 25 "/usr/include/x86_64-linux-gnu/bits/floatn-common.h" 2 3 4
+# 120 "/usr/include/x86_64-linux-gnu/bits/floatn.h" 2 3 4
+# 431 "/usr/include/stdio.h" 2 3 4
+
+
+
+extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
+
+                               ;
+extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
+                              ;
+extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__))
+
+                      ;
+# 459 "/usr/include/stdio.h" 3 4
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
+      __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+
+
+
+
+
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+
+
+extern int vsscanf (const char *__restrict __s,
+      const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));
+
+
+
+
+
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
+
+
+
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
+
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__))
+
+
+
+     __attribute__ ((__format__ (__scanf__, 2, 0)));
+# 513 "/usr/include/stdio.h" 3 4
+extern int fgetc (FILE *__stream);
+extern int getc (FILE *__stream);
+
+
+
+
+
+extern int getchar (void);
+
+
+
+
+
+
+extern int getc_unlocked (FILE *__stream);
+extern int getchar_unlocked (void);
+# 538 "/usr/include/stdio.h" 3 4
+extern int fgetc_unlocked (FILE *__stream);
+# 549 "/usr/include/stdio.h" 3 4
+extern int fputc (int __c, FILE *__stream);
+extern int putc (int __c, FILE *__stream);
+
+
+
+
+
+extern int putchar (int __c);
+# 565 "/usr/include/stdio.h" 3 4
+extern int fputc_unlocked (int __c, FILE *__stream);
+
+
+
+
+
+
+
+extern int putc_unlocked (int __c, FILE *__stream);
+extern int putchar_unlocked (int __c);
+
+
+
+
+
+
+extern int getw (FILE *__stream);
+
+
+extern int putw (int __w, FILE *__stream);
+
+
+
+
+
+
+
+extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+     __attribute__ ((__access__ (__write_only__, 1, 2)));
+# 632 "/usr/include/stdio.h" 3 4
+extern __ssize_t __getdelim (char **__restrict __lineptr,
+                             size_t *__restrict __n, int __delimiter,
+                             FILE *__restrict __stream) ;
+extern __ssize_t getdelim (char **__restrict __lineptr,
+                           size_t *__restrict __n, int __delimiter,
+                           FILE *__restrict __stream) ;
+
+
+
+
+
+
+
+extern __ssize_t getline (char **__restrict __lineptr,
+                          size_t *__restrict __n,
+                          FILE *__restrict __stream) ;
+
+
+
+
+
+
+
+extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
+
+
+
+
+
+extern int puts (const char *__s);
+
+
+
+
+
+
+extern int ungetc (int __c, FILE *__stream);
+
+
+
+
+
+
+extern size_t fread (void *__restrict __ptr, size_t __size,
+       size_t __n, FILE *__restrict __stream) ;
+
+
+
+
+extern size_t fwrite (const void *__restrict __ptr, size_t __size,
+        size_t __n, FILE *__restrict __s);
+# 702 "/usr/include/stdio.h" 3 4
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+         size_t __n, FILE *__restrict __stream) ;
+extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
+          size_t __n, FILE *__restrict __stream);
+
+
+
+
+
+
+
+extern int fseek (FILE *__stream, long int __off, int __whence);
+
+
+
+
+extern long int ftell (FILE *__stream) ;
+
+
+
+
+extern void rewind (FILE *__stream);
+# 736 "/usr/include/stdio.h" 3 4
+extern int fseeko (FILE *__stream, __off_t __off, int __whence);
+
+
+
+
+extern __off_t ftello (FILE *__stream) ;
+# 760 "/usr/include/stdio.h" 3 4
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
+
+
+
+
+extern int fsetpos (FILE *__stream, const fpos_t *__pos);
+# 786 "/usr/include/stdio.h" 3 4
+extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+
+extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+
+
+
+extern void perror (const char *__s);
+
+
+
+
+extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+# 823 "/usr/include/stdio.h" 3 4
+extern int pclose (FILE *__stream);
+
+
+
+
+
+extern FILE *popen (const char *__command, const char *__modes)
+  __attribute__ ((__malloc__)) __attribute__ ((__malloc__ (pclose, 1))) ;
+
+
+
+
+
+
+extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__))
+  __attribute__ ((__access__ (__write_only__, 1)));
+# 867 "/usr/include/stdio.h" 3 4
+extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));
+# 885 "/usr/include/stdio.h" 3 4
+extern int __uflow (FILE *);
+extern int __overflow (FILE *, int);
+# 902 "/usr/include/stdio.h" 3 4
+
+# 5 "./src/tools_t/tools_t.h" 2
+# 1 "/usr/include/stdlib.h" 1 3 4
+# 26 "/usr/include/stdlib.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
+# 27 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4
+# 321 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 3 4
+typedef int wchar_t;
+# 33 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4
+# 41 "/usr/include/stdlib.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4
+# 42 "/usr/include/stdlib.h" 2 3 4
+# 59 "/usr/include/stdlib.h" 3 4
+typedef struct
+  {
+    int quot;
+    int rem;
+  } div_t;
+
+
+
+typedef struct
+  {
+    long int quot;
+    long int rem;
+  } ldiv_t;
+
+
+
+
+
+__extension__ typedef struct
+  {
+    long long int quot;
+    long long int rem;
+  } lldiv_t;
+# 98 "/usr/include/stdlib.h" 3 4
+extern size_t __ctype_get_mb_cur_max (void) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+extern double atof (const char *__nptr)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern int atoi (const char *__nptr)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern long int atol (const char *__nptr)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+__extension__ extern long long int atoll (const char *__nptr)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern double strtod (const char *__restrict __nptr,
+        char **__restrict __endptr)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern float strtof (const char *__restrict __nptr,
+       char **__restrict __endptr) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+extern long double strtold (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+# 177 "/usr/include/stdlib.h" 3 4
+extern long int strtol (const char *__restrict __nptr,
+   char **__restrict __endptr, int __base)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+extern unsigned long int strtoul (const char *__restrict __nptr,
+      char **__restrict __endptr, int __base)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+__extension__
+extern long long int strtoq (const char *__restrict __nptr,
+        char **__restrict __endptr, int __base)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtouq (const char *__restrict __nptr,
+           char **__restrict __endptr, int __base)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+__extension__
+extern long long int strtoll (const char *__restrict __nptr,
+         char **__restrict __endptr, int __base)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtoull (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+# 386 "/usr/include/stdlib.h" 3 4
+extern char *l64a (long int __n) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+extern long int a64l (const char *__s)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4
+# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
+
+
+
+
+
+
+typedef __u_char u_char;
+typedef __u_short u_short;
+typedef __u_int u_int;
+typedef __u_long u_long;
+typedef __quad_t quad_t;
+typedef __u_quad_t u_quad_t;
+typedef __fsid_t fsid_t;
+
+
+typedef __loff_t loff_t;
+
+
+
+
+typedef __ino_t ino_t;
+# 59 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
+typedef __dev_t dev_t;
+
+
+
+
+typedef __gid_t gid_t;
+
+
+
+
+typedef __mode_t mode_t;
+
+
+
+
+typedef __nlink_t nlink_t;
+
+
+
+
+typedef __uid_t uid_t;
+# 97 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
+typedef __pid_t pid_t;
+
+
+
+
+
+typedef __id_t id_t;
+# 114 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
+typedef __daddr_t daddr_t;
+typedef __caddr_t caddr_t;
+
+
+
+
+
+typedef __key_t key_t;
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/clock_t.h" 1 3 4
+
+
+
+
+
+
+typedef __clock_t clock_t;
+# 127 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h" 1 3 4
+
+
+
+
+
+
+typedef __clockid_t clockid_t;
+# 129 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 1 3 4
+# 10 "/usr/include/x86_64-linux-gnu/bits/types/time_t.h" 3 4
+typedef __time_t time_t;
+# 130 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/timer_t.h" 1 3 4
+
+
+
+
+
+
+typedef __timer_t timer_t;
+# 131 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
+# 144 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4
+# 145 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
+
+
+
+typedef unsigned long int ulong;
+typedef unsigned short int ushort;
+typedef unsigned int uint;
+
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 1 3 4
+# 24 "/usr/include/x86_64-linux-gnu/bits/stdint-intn.h" 3 4
+typedef __int8_t int8_t;
+typedef __int16_t int16_t;
+typedef __int32_t int32_t;
+typedef __int64_t int64_t;
+# 156 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
+
+
+typedef __uint8_t u_int8_t;
+typedef __uint16_t u_int16_t;
+typedef __uint32_t u_int32_t;
+typedef __uint64_t u_int64_t;
+
+
+typedef int register_t __attribute__ ((__mode__ (__word__)));
+# 176 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
+# 1 "/usr/include/endian.h" 1 3 4
+# 24 "/usr/include/endian.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
+# 35 "/usr/include/x86_64-linux-gnu/bits/endian.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/endianness.h" 1 3 4
+# 36 "/usr/include/x86_64-linux-gnu/bits/endian.h" 2 3 4
+# 25 "/usr/include/endian.h" 2 3 4
+# 35 "/usr/include/endian.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
+# 33 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
+static __inline __uint16_t
+__bswap_16 (__uint16_t __bsx)
+{
+
+  return __builtin_bswap16 (__bsx);
+
+
+
+}
+
+
+
+
+
+
+static __inline __uint32_t
+__bswap_32 (__uint32_t __bsx)
+{
+
+  return __builtin_bswap32 (__bsx);
+
+
+
+}
+# 69 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
+__extension__ static __inline __uint64_t
+__bswap_64 (__uint64_t __bsx)
+{
+
+  return __builtin_bswap64 (__bsx);
+
+
+
+}
+# 36 "/usr/include/endian.h" 2 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 1 3 4
+# 32 "/usr/include/x86_64-linux-gnu/bits/uintn-identity.h" 3 4
+static __inline __uint16_t
+__uint16_identity (__uint16_t __x)
+{
+  return __x;
+}
+
+static __inline __uint32_t
+__uint32_identity (__uint32_t __x)
+{
+  return __x;
+}
+
+static __inline __uint64_t
+__uint64_identity (__uint64_t __x)
+{
+  return __x;
+}
+# 37 "/usr/include/endian.h" 2 3 4
+# 177 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
+
+
+# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
+# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
+# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 1 3 4
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h" 1 3 4
+
+
+
+
+typedef struct
+{
+  unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
+} __sigset_t;
+# 5 "/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h" 2 3 4
+
+
+typedef __sigset_t sigset_t;
+# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h" 1 3 4
+
+
+
+
+
+
+
+struct timeval
+{
+
+
+
+
+  __time_t tv_sec;
+  __suseconds_t tv_usec;
+
+};
+# 38 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 1 3 4
+# 11 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
+struct timespec
+{
+
+
+
+  __time_t tv_sec;
+
+
+
+
+  __syscall_slong_t tv_nsec;
+# 31 "/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h" 3 4
+};
+# 40 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
+
+
+
+typedef __suseconds_t suseconds_t;
+
+
+
+
+
+typedef long int __fd_mask;
+# 59 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
+typedef struct
+  {
+
+
+
+
+
+
+    __fd_mask __fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
+
+
+  } fd_set;
+
+
+
+
+
+
+typedef __fd_mask fd_mask;
+# 91 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
+
+# 102 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
+extern int select (int __nfds, fd_set *__restrict __readfds,
+     fd_set *__restrict __writefds,
+     fd_set *__restrict __exceptfds,
+     struct timeval *__restrict __timeout);
+# 127 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
+extern int pselect (int __nfds, fd_set *__restrict __readfds,
+      fd_set *__restrict __writefds,
+      fd_set *__restrict __exceptfds,
+      const struct timespec *__restrict __timeout,
+      const __sigset_t *__restrict __sigmask);
+# 153 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
+
+# 180 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
+
+
+
+
+
+typedef __blksize_t blksize_t;
+
+
+
+
+
+
+typedef __blkcnt_t blkcnt_t;
+
+
+
+typedef __fsblkcnt_t fsblkcnt_t;
+
+
+
+typedef __fsfilcnt_t fsfilcnt_t;
+# 227 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4
+# 23 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 1 3 4
+# 44 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 1 3 4
+# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
+# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h" 2 3 4
+# 45 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 1 3 4
+# 25 "/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h" 3 4
+typedef union
+{
+  __extension__ unsigned long long int __value64;
+  struct
+  {
+    unsigned int __low;
+    unsigned int __high;
+  } __value32;
+} __atomic_wide_counter;
+# 47 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
+
+
+
+
+typedef struct __pthread_internal_list
+{
+  struct __pthread_internal_list *__prev;
+  struct __pthread_internal_list *__next;
+} __pthread_list_t;
+
+typedef struct __pthread_internal_slist
+{
+  struct __pthread_internal_slist *__next;
+} __pthread_slist_t;
+# 76 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 1 3 4
+# 22 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
+struct __pthread_mutex_s
+{
+  int __lock;
+  unsigned int __count;
+  int __owner;
+
+  unsigned int __nusers;
+
+
+
+  int __kind;
+
+  short __spins;
+  short __elision;
+  __pthread_list_t __list;
+# 53 "/usr/include/x86_64-linux-gnu/bits/struct_mutex.h" 3 4
+};
+# 77 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
+# 89 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 1 3 4
+# 23 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
+struct __pthread_rwlock_arch_t
+{
+  unsigned int __readers;
+  unsigned int __writers;
+  unsigned int __wrphase_futex;
+  unsigned int __writers_futex;
+  unsigned int __pad3;
+  unsigned int __pad4;
+
+  int __cur_writer;
+  int __shared;
+  signed char __rwelision;
+
+
+
+
+  unsigned char __pad1[7];
+
+
+  unsigned long int __pad2;
+
+
+  unsigned int __flags;
+# 55 "/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h" 3 4
+};
+# 90 "/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h" 2 3 4
+
+
+
+
+struct __pthread_cond_s
+{
+  __atomic_wide_counter __wseq;
+  __atomic_wide_counter __g1_start;
+  unsigned int __g_refs[2] ;
+  unsigned int __g_size[2];
+  unsigned int __g1_orig_size;
+  unsigned int __wrefs;
+  unsigned int __g_signals[2];
+};
+
+typedef unsigned int __tss_t;
+typedef unsigned long int __thrd_t;
+
+typedef struct
+{
+  int __data ;
+} __once_flag;
+# 24 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4
+
+
+
+typedef unsigned long int pthread_t;
+
+
+
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_mutexattr_t;
+
+
+
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_condattr_t;
+
+
+
+typedef unsigned int pthread_key_t;
+
+
+
+typedef int pthread_once_t;
+
+
+union pthread_attr_t
+{
+  char __size[56];
+  long int __align;
+};
+
+typedef union pthread_attr_t pthread_attr_t;
+
+
+
+
+typedef union
+{
+  struct __pthread_mutex_s __data;
+  char __size[40];
+  long int __align;
+} pthread_mutex_t;
+
+
+typedef union
+{
+  struct __pthread_cond_s __data;
+  char __size[48];
+  __extension__ long long int __align;
+} pthread_cond_t;
+
+
+
+
+
+typedef union
+{
+  struct __pthread_rwlock_arch_t __data;
+  char __size[56];
+  long int __align;
+} pthread_rwlock_t;
+
+typedef union
+{
+  char __size[8];
+  long int __align;
+} pthread_rwlockattr_t;
+
+
+
+
+
+typedef volatile int pthread_spinlock_t;
+
+
+
+
+typedef union
+{
+  char __size[32];
+  long int __align;
+} pthread_barrier_t;
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_barrierattr_t;
+# 228 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
+
+
+
+# 396 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+
+extern long int random (void) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern void srandom (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+extern char *initstate (unsigned int __seed, char *__statebuf,
+   size_t __statelen) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern char *setstate (char *__statebuf) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+struct random_data
+  {
+    int32_t *fptr;
+    int32_t *rptr;
+    int32_t *state;
+    int rand_type;
+    int rand_deg;
+    int rand_sep;
+    int32_t *end_ptr;
+  };
+
+extern int random_r (struct random_data *__restrict __buf,
+       int32_t *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int srandom_r (unsigned int __seed, struct random_data *__buf)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
+
+extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
+   size_t __statelen,
+   struct random_data *__restrict __buf)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)));
+
+extern int setstate_r (char *__restrict __statebuf,
+         struct random_data *__restrict __buf)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern int rand (void) __attribute__ ((__nothrow__ , __leaf__));
+
+extern void srand (unsigned int __seed) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern int rand_r (unsigned int *__seed) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+
+extern double drand48 (void) __attribute__ ((__nothrow__ , __leaf__));
+extern double erand48 (unsigned short int __xsubi[3]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern long int lrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
+extern long int nrand48 (unsigned short int __xsubi[3])
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern long int mrand48 (void) __attribute__ ((__nothrow__ , __leaf__));
+extern long int jrand48 (unsigned short int __xsubi[3])
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern void srand48 (long int __seedval) __attribute__ ((__nothrow__ , __leaf__));
+extern unsigned short int *seed48 (unsigned short int __seed16v[3])
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+extern void lcong48 (unsigned short int __param[7]) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+struct drand48_data
+  {
+    unsigned short int __x[3];
+    unsigned short int __old_x[3];
+    unsigned short int __c;
+    unsigned short int __init;
+    __extension__ unsigned long long int __a;
+
+  };
+
+
+extern int drand48_r (struct drand48_data *__restrict __buffer,
+        double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int erand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        double *__restrict __result) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int lrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int nrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int mrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int jrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
+
+extern int seed48_r (unsigned short int __seed16v[3],
+       struct drand48_data *__buffer) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int lcong48_r (unsigned short int __param[7],
+        struct drand48_data *__buffer)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern void *malloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__))
+     __attribute__ ((__alloc_size__ (1))) ;
+
+extern void *calloc (size_t __nmemb, size_t __size)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ;
+
+
+
+
+
+
+extern void *realloc (void *__ptr, size_t __size)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));
+
+
+extern void free (void *__ptr) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+
+extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__warn_unused_result__))
+     __attribute__ ((__alloc_size__ (2, 3)))
+    __attribute__ ((__malloc__ (__builtin_free, 1)));
+
+
+extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__ (reallocarray, 1)));
+
+
+
+# 1 "/usr/include/alloca.h" 1 3 4
+# 24 "/usr/include/alloca.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4
+# 25 "/usr/include/alloca.h" 2 3 4
+
+
+
+
+
+
+
+extern void *alloca (size_t __size) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+
+
+
+# 575 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+extern void *valloc (size_t __size) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__))
+     __attribute__ ((__alloc_size__ (1))) ;
+
+
+
+
+extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+extern void *aligned_alloc (size_t __alignment, size_t __size)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1)))
+     __attribute__ ((__alloc_size__ (2))) ;
+
+
+
+extern void abort (void) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
+
+
+
+extern int atexit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int at_quick_exit (void (*__func) (void)) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern void exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
+
+
+
+
+
+extern void quick_exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
+
+
+
+
+
+extern void _Exit (int __status) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__noreturn__));
+
+
+
+
+extern char *getenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+# 654 "/usr/include/stdlib.h" 3 4
+extern int putenv (char *__string) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int setenv (const char *__name, const char *__value, int __replace)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
+
+
+extern int unsetenv (const char *__name) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int clearenv (void) __attribute__ ((__nothrow__ , __leaf__));
+# 682 "/usr/include/stdlib.h" 3 4
+extern char *mktemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+# 695 "/usr/include/stdlib.h" 3 4
+extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
+# 717 "/usr/include/stdlib.h" 3 4
+extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
+# 738 "/usr/include/stdlib.h" 3 4
+extern char *mkdtemp (char *__template) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+# 791 "/usr/include/stdlib.h" 3 4
+extern int system (const char *__command) ;
+# 808 "/usr/include/stdlib.h" 3 4
+extern char *realpath (const char *__restrict __name,
+         char *__restrict __resolved) __attribute__ ((__nothrow__ , __leaf__)) ;
+
+
+
+
+
+
+typedef int (*__compar_fn_t) (const void *, const void *);
+# 828 "/usr/include/stdlib.h" 3 4
+extern void *bsearch (const void *__key, const void *__base,
+        size_t __nmemb, size_t __size, __compar_fn_t __compar)
+     __attribute__ ((__nonnull__ (1, 2, 5))) ;
+
+
+
+
+
+
+
+extern void qsort (void *__base, size_t __nmemb, size_t __size,
+     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
+# 848 "/usr/include/stdlib.h" 3 4
+extern int abs (int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
+extern long int labs (long int __x) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
+
+
+__extension__ extern long long int llabs (long long int __x)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
+
+
+
+
+
+
+extern div_t div (int __numer, int __denom)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
+extern ldiv_t ldiv (long int __numer, long int __denom)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
+
+
+__extension__ extern lldiv_t lldiv (long long int __numer,
+        long long int __denom)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__)) ;
+# 880 "/usr/include/stdlib.h" 3 4
+extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *gcvt (double __value, int __ndigit, char *__buf)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern char *qecvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qfcvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qgcvt (long double __value, int __ndigit, char *__buf)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
+
+extern int qecvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int qfcvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (3, 4, 5)));
+
+
+
+
+
+extern int mblen (const char *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int mbtowc (wchar_t *__restrict __pwc,
+     const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__));
+
+
+extern int wctomb (char *__s, wchar_t __wchar) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+extern size_t mbstowcs (wchar_t *__restrict __pwcs,
+   const char *__restrict __s, size_t __n) __attribute__ ((__nothrow__ , __leaf__))
+    __attribute__ ((__access__ (__read_only__, 2)));
+
+extern size_t wcstombs (char *__restrict __s,
+   const wchar_t *__restrict __pwcs, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__))
+  __attribute__ ((__access__ (__write_only__, 1, 3)))
+  __attribute__ ((__access__ (__read_only__, 2)));
+
+
+
+
+
+
+extern int rpmatch (const char *__response) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1))) ;
+# 967 "/usr/include/stdlib.h" 3 4
+extern int getsubopt (char **__restrict __optionp,
+        char *const *__restrict __tokens,
+        char **__restrict __valuep)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2, 3))) ;
+# 1013 "/usr/include/stdlib.h" 3 4
+extern int getloadavg (double __loadavg[], int __nelem)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+# 1023 "/usr/include/stdlib.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4
+# 1024 "/usr/include/stdlib.h" 2 3 4
+# 1035 "/usr/include/stdlib.h" 3 4
+
+# 6 "./src/tools_t/tools_t.h" 2
+# 1 "/usr/include/string.h" 1 3 4
+# 26 "/usr/include/string.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/libc-header-start.h" 1 3 4
+# 27 "/usr/include/string.h" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4
+# 34 "/usr/include/string.h" 2 3 4
+# 43 "/usr/include/string.h" 3 4
+extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
+       size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void *memmove (void *__dest, const void *__src, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
+        int __c, size_t __n)
+    __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4)));
+
+
+
+
+extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern int memcmp (const void *__s1, const void *__s2, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 80 "/usr/include/string.h" 3 4
+extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 107 "/usr/include/string.h" 3 4
+extern void *memchr (const void *__s, int __c, size_t __n)
+      __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 141 "/usr/include/string.h" 3 4
+extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncpy (char *__restrict __dest,
+        const char *__restrict __src, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern char *strcat (char *__restrict __dest, const char *__restrict __src)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncat (char *__restrict __dest, const char *__restrict __src,
+        size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcmp (const char *__s1, const char *__s2)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int strncmp (const char *__s1, const char *__s2, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcoll (const char *__s1, const char *__s2)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern size_t strxfrm (char *__restrict __dest,
+         const char *__restrict __src, size_t __n)
+    __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3)));
+
+
+
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 1 3 4
+# 22 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 3 4
+# 1 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 1 3 4
+# 27 "/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h" 3 4
+struct __locale_struct
+{
+
+  struct __locale_data *__locales[13];
+
+
+  const unsigned short int *__ctype_b;
+  const int *__ctype_tolower;
+  const int *__ctype_toupper;
+
+
+  const char *__names[13];
+};
+
+typedef struct __locale_struct *__locale_t;
+# 23 "/usr/include/x86_64-linux-gnu/bits/types/locale_t.h" 2 3 4
+
+typedef __locale_t locale_t;
+# 173 "/usr/include/string.h" 2 3 4
+
+
+extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
+    locale_t __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 4)))
+     __attribute__ ((__access__ (__write_only__, 1, 3)));
+
+
+
+
+
+extern char *strdup (const char *__s)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern char *strndup (const char *__string, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+# 246 "/usr/include/string.h" 3 4
+extern char *strchr (const char *__s, int __c)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 273 "/usr/include/string.h" 3 4
+extern char *strrchr (const char *__s, int __c)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 293 "/usr/include/string.h" 3 4
+extern size_t strcspn (const char *__s, const char *__reject)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern size_t strspn (const char *__s, const char *__accept)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 323 "/usr/include/string.h" 3 4
+extern char *strpbrk (const char *__s, const char *__accept)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 350 "/usr/include/string.h" 3 4
+extern char *strstr (const char *__haystack, const char *__needle)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern char *strtok (char *__restrict __s, const char *__restrict __delim)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern char *__strtok_r (char *__restrict __s,
+    const char *__restrict __delim,
+    char **__restrict __save_ptr)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
+
+extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
+         char **__restrict __save_ptr)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (2, 3)));
+# 407 "/usr/include/string.h" 3 4
+extern size_t strlen (const char *__s)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern size_t strnlen (const char *__string, size_t __maxlen)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern char *strerror (int __errnum) __attribute__ ((__nothrow__ , __leaf__));
+# 432 "/usr/include/string.h" 3 4
+extern int strerror_r (int __errnum, char *__buf, size_t __buflen) __asm__ ("" "__xpg_strerror_r") __attribute__ ((__nothrow__ , __leaf__))
+
+                        __attribute__ ((__nonnull__ (2)))
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+# 458 "/usr/include/string.h" 3 4
+extern char *strerror_l (int __errnum, locale_t __l) __attribute__ ((__nothrow__ , __leaf__));
+
+
+
+# 1 "/usr/include/strings.h" 1 3 4
+# 23 "/usr/include/strings.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stddef.h" 1 3 4
+# 24 "/usr/include/strings.h" 2 3 4
+
+
+
+
+
+
+
+
+
+
+extern int bcmp (const void *__s1, const void *__s2, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void bcopy (const void *__src, void *__dest, size_t __n)
+  __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)));
+# 68 "/usr/include/strings.h" 3 4
+extern char *index (const char *__s, int __c)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 96 "/usr/include/strings.h" 3 4
+extern char *rindex (const char *__s, int __c)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int ffs (int __i) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
+
+
+
+
+
+extern int ffsl (long int __l) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
+__extension__ extern int ffsll (long long int __ll)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__const__));
+
+
+
+extern int strcasecmp (const char *__s1, const char *__s2)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+extern int strncasecmp_l (const char *__s1, const char *__s2,
+     size_t __n, locale_t __loc)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
+
+
+
+# 463 "/usr/include/string.h" 2 3 4
+
+
+
+extern void explicit_bzero (void *__s, size_t __n) __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+extern char *strsep (char **__restrict __stringp,
+       const char *__restrict __delim)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern char *strsignal (int __sig) __attribute__ ((__nothrow__ , __leaf__));
+# 489 "/usr/include/string.h" 3 4
+extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern char *__stpncpy (char *__restrict __dest,
+   const char *__restrict __src, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpncpy (char *__restrict __dest,
+        const char *__restrict __src, size_t __n)
+     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__nonnull__ (1, 2)));
+# 539 "/usr/include/string.h" 3 4
+
+# 7 "./src/tools_t/tools_t.h" 2
+# 1 "/usr/lib/gcc/x86_64-linux-gnu/11/include/stdbool.h" 1 3 4
+# 8 "./src/tools_t/tools_t.h" 2
+# 49 "./src/tools_t/tools_t.h"
+
+# 49 "./src/tools_t/tools_t.h"
+int COMPARE_N_TYPE_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_CHAR(char* dst, const char* src, size_t size); char MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_CHAR(const char *array, size_t size); char MIN_ARRAY_TYPE_CHAR(const char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_CHAR(const char *array, size_t size); char* TYPE_CHAR_TO_STR(char var);
+int COMPARE_N_TYPE_U_CHAR(const void *,const void*); void COPY_ARRAY_TYPE_U_CHAR(unsigned char* dst, const unsigned char* src, size_t size); unsigned char MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); unsigned char MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size); char* TYPE_U_CHAR_TO_STR(unsigned char var);
+int COMPARE_N_TYPE_INT(const void *,const void*); void COPY_ARRAY_TYPE_INT(int* dst, const int* src, size_t size); int MAX_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_INT(const int *array, size_t size); int MIN_ARRAY_TYPE_INT(const int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_INT(const int *array, size_t size); char* TYPE_INT_TO_STR(int var);
+int COMPARE_N_TYPE_U_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_INT(unsigned int* dst, const unsigned int* src, size_t size); unsigned int MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); unsigned int MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size); char* TYPE_U_INT_TO_STR(unsigned int var);
+int COMPARE_N_TYPE_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_L_INT(long int* dst, const long int* src, size_t size); long int MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size); long int MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size); char* TYPE_L_INT_TO_STR(long int var);
+int COMPARE_N_TYPE_U_L_INT(const void *,const void*); void COPY_ARRAY_TYPE_U_L_INT(unsigned long int* dst, const unsigned long int* src, size_t size); unsigned long int MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); unsigned long int MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size); char* TYPE_U_L_INT_TO_STR(unsigned long int var);
+int COMPARE_N_TYPE_SIZE_T(const void *,const void*); void COPY_ARRAY_TYPE_SIZE_T(size_t* dst, const size_t* src, size_t size); size_t MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size); char* TYPE_SIZE_T_TO_STR(size_t var);
+int COMPARE_N_TYPE_FLOAT(const void *,const void*); void COPY_ARRAY_TYPE_FLOAT(float* dst, const float* src, size_t size); float MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size); float MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size); char* TYPE_FLOAT_TO_STR(float var);
+int COMPARE_N_TYPE_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_DOUBLE(double* dst, const double* src, size_t size); double MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size); double MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size); char* TYPE_DOUBLE_TO_STR(double var);
+int COMPARE_N_TYPE_L_DOUBLE(const void *,const void*); void COPY_ARRAY_TYPE_L_DOUBLE(long double* dst, const long double* src, size_t size); long double MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); long double MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size); char* TYPE_L_DOUBLE_TO_STR(long double var);
+int COMPARE_N_TYPE_STRING(const void *,const void*); void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size); char* MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MAX_ARRAY_TYPE_STRING(const char* *array, size_t size); char* MIN_ARRAY_TYPE_STRING(const char* *array, size_t size); size_t ARG_MIN_ARRAY_TYPE_STRING(const char* *array, size_t size); char* TYPE_STRING_TO_STR(char* var);
+# 2 "src/tools_t/tools_t.c" 2
+# 11 "src/tools_t/tools_t.c"
+char* TYPE_CHAR_TO_STR(char var){ char *ret = malloc(2); sprintf(ret,"%c",var); ret[strlen(ret)]='\0'; return ret; }
+char* TYPE_U_CHAR_TO_STR(unsigned char var){ char *ret = malloc(2); sprintf(ret,"%c",var); ret[strlen(ret)]='\0'; return ret; }
+char* TYPE_INT_TO_STR(int var){ char *ret = malloc(22); sprintf(ret,"%d",var); ret[strlen(ret)]='\0'; return ret; }
+char* TYPE_U_INT_TO_STR(unsigned int var){ char *ret = malloc(22); sprintf(ret,"%u",var); ret[strlen(ret)]='\0'; return ret; }
+char* TYPE_L_INT_TO_STR(long int var){ char *ret = malloc(22); sprintf(ret,"%ld",var); ret[strlen(ret)]='\0'; return ret; }
+char* TYPE_U_L_INT_TO_STR(unsigned long int var){ char *ret = malloc(22); sprintf(ret,"%lu",var); ret[strlen(ret)]='\0'; return ret; }
+char* TYPE_SIZE_T_TO_STR(size_t var){ char *ret = malloc(22); sprintf(ret,"%lu",var); ret[strlen(ret)]='\0'; return ret; }
+char* TYPE_FLOAT_TO_STR(float var){ char *ret = malloc(128); sprintf(ret,"%.10f",var); ret[strlen(ret)]='\0'; return ret; }
+char* TYPE_DOUBLE_TO_STR(double var){ char *ret = malloc(256); sprintf(ret,"%.30lf",var); ret[strlen(ret)]='\0'; return ret; }
+char* TYPE_L_DOUBLE_TO_STR(long double var){ char *ret = malloc(256); sprintf(ret,"%.30Lf",var); ret[strlen(ret)]='\0'; return ret; }
+
+char* TYPE_STRING_TO_STR(char* var){
+  return var;
+}
+# 58 "src/tools_t/tools_t.c"
+int
+COMPARE_N_TYPE_STRING(const void *a,const void* b)
+{
+  return strcmp(( char*)a,( char*)b);
+}
+
+void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size)
+{
+  for(size_t i = 0; i < size; ++i) strcpy(dst[i],src[i]);
+}
+
+
+int COMPARE_N_TYPE_CHAR(const void *a, const void *b){ char diff = (*(char*)a - *(char*)b)*1; do { if (0) fprintf(
+# 70 "src/tools_t/tools_t.c" 3 4
+stderr
+# 70 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 70, __func__, TYPE_CHAR_TO_STR(diff),TYPE_CHAR_TO_STR(*(char*)a), TYPE_CHAR_TO_STR(*(char*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_CHAR(char *dst, const char *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+int COMPARE_N_TYPE_U_CHAR(const void *a, const void *b){ unsigned char diff = (*(unsigned char*)a - *(unsigned char*)b)*1; do { if (0) fprintf(
+# 71 "src/tools_t/tools_t.c" 3 4
+stderr
+# 71 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 71, __func__, TYPE_U_CHAR_TO_STR(diff),TYPE_U_CHAR_TO_STR(*(unsigned char*)a), TYPE_U_CHAR_TO_STR(*(unsigned char*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_U_CHAR(unsigned char *dst, const unsigned char *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+int COMPARE_N_TYPE_INT(const void *a, const void *b){ int diff = (*(int*)a - *(int*)b)*1; do { if (0) fprintf(
+# 72 "src/tools_t/tools_t.c" 3 4
+stderr
+# 72 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 72, __func__, TYPE_INT_TO_STR(diff),TYPE_INT_TO_STR(*(int*)a), TYPE_INT_TO_STR(*(int*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_INT(int *dst, const int *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+int COMPARE_N_TYPE_U_INT(const void *a, const void *b){ unsigned int diff = (*(unsigned int*)a - *(unsigned int*)b)*1; do { if (0) fprintf(
+# 73 "src/tools_t/tools_t.c" 3 4
+stderr
+# 73 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 73, __func__, TYPE_U_INT_TO_STR(diff),TYPE_U_INT_TO_STR(*(unsigned int*)a), TYPE_U_INT_TO_STR(*(unsigned int*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_U_INT(unsigned int *dst, const unsigned int *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+int COMPARE_N_TYPE_L_INT(const void *a, const void *b){ long int diff = (*(long int*)a - *(long int*)b)*1; do { if (0) fprintf(
+# 74 "src/tools_t/tools_t.c" 3 4
+stderr
+# 74 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 74, __func__, TYPE_L_INT_TO_STR(diff),TYPE_L_INT_TO_STR(*(long int*)a), TYPE_L_INT_TO_STR(*(long int*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_L_INT(long int *dst, const long int *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+int COMPARE_N_TYPE_U_L_INT(const void *a, const void *b){ unsigned long int diff = (*(unsigned long int*)a - *(unsigned long int*)b)*1; do { if (0) fprintf(
+# 75 "src/tools_t/tools_t.c" 3 4
+stderr
+# 75 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 75, __func__, TYPE_U_L_INT_TO_STR(diff),TYPE_U_L_INT_TO_STR(*(unsigned long int*)a), TYPE_U_L_INT_TO_STR(*(unsigned long int*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_U_L_INT(unsigned long int *dst, const unsigned long int *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+int COMPARE_N_TYPE_SIZE_T(const void *a, const void *b){ size_t diff = (*(size_t*)a - *(size_t*)b)*1; do { if (0) fprintf(
+# 76 "src/tools_t/tools_t.c" 3 4
+stderr
+# 76 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 76, __func__, TYPE_SIZE_T_TO_STR(diff),TYPE_SIZE_T_TO_STR(*(size_t*)a), TYPE_SIZE_T_TO_STR(*(size_t*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_SIZE_T(size_t *dst, const size_t *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+int COMPARE_N_TYPE_FLOAT(const void *a, const void *b){ float diff = (*(float*)a - *(float*)b)*100000000; do { if (0) fprintf(
+# 77 "src/tools_t/tools_t.c" 3 4
+stderr
+# 77 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 77, __func__, TYPE_FLOAT_TO_STR(diff),TYPE_FLOAT_TO_STR(*(float*)a), TYPE_FLOAT_TO_STR(*(float*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_FLOAT(float *dst, const float *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+int COMPARE_N_TYPE_DOUBLE(const void *a, const void *b){ double diff = (*(double*)a - *(double*)b)*100000000000; do { if (0) fprintf(
+# 78 "src/tools_t/tools_t.c" 3 4
+stderr
+# 78 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 78, __func__, TYPE_DOUBLE_TO_STR(diff),TYPE_DOUBLE_TO_STR(*(double*)a), TYPE_DOUBLE_TO_STR(*(double*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_DOUBLE(double *dst, const double *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+int COMPARE_N_TYPE_L_DOUBLE(const void *a, const void *b){ long double diff = (*(long double*)a - *(long double*)b)*100000000000000; do { if (0) fprintf(
+# 79 "src/tools_t/tools_t.c" 3 4
+stderr
+# 79 "src/tools_t/tools_t.c"
+, "%s:%d:%s(): " " diff = %s a=%s b=%s\n", "src/tools_t/tools_t.c", 79, __func__, TYPE_L_DOUBLE_TO_STR(diff),TYPE_L_DOUBLE_TO_STR(*(long double*)a), TYPE_L_DOUBLE_TO_STR(*(long double*)b)); } while (0); if ((diff < 1) && (diff > -1) ) return 0; return diff; } void COPY_ARRAY_TYPE_L_DOUBLE(long double *dst, const long double *src, size_t size){ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }
+# 112 "src/tools_t/tools_t.c"
+char MAX_ARRAY_TYPE_CHAR(const char *array, size_t size){ if(array == 
+# 112 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 112 "src/tools_t/tools_t.c"
+) return 0; char mx =(char)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_CHAR(&mx,&array[i]) < 0) mx =(char)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_CHAR(const char *array, size_t size){ if(array == 
+# 112 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 112 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_CHAR(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} char MIN_ARRAY_TYPE_CHAR(const char *array, size_t size){ if(array == 
+# 112 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 112 "src/tools_t/tools_t.c"
+) return 0; char mn =(char)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_CHAR(&mn,&array[i]) > 0) mn =(char)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_CHAR(const char *array, size_t size){ if(array == 
+# 112 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 112 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_CHAR(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+unsigned char MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size){ if(array == 
+# 113 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 113 "src/tools_t/tools_t.c"
+) return 0; unsigned char mx =(unsigned char)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_CHAR(&mx,&array[i]) < 0) mx =(unsigned char)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size){ if(array == 
+# 113 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 113 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_CHAR(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} unsigned char MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size){ if(array == 
+# 113 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 113 "src/tools_t/tools_t.c"
+) return 0; unsigned char mn =(unsigned char)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_CHAR(&mn,&array[i]) > 0) mn =(unsigned char)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_U_CHAR(const unsigned char *array, size_t size){ if(array == 
+# 113 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 113 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_CHAR(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+int MAX_ARRAY_TYPE_INT(const int *array, size_t size){ if(array == 
+# 114 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 114 "src/tools_t/tools_t.c"
+) return 0; int mx =(int)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_INT(&mx,&array[i]) < 0) mx =(int)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_INT(const int *array, size_t size){ if(array == 
+# 114 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 114 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_INT(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} int MIN_ARRAY_TYPE_INT(const int *array, size_t size){ if(array == 
+# 114 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 114 "src/tools_t/tools_t.c"
+) return 0; int mn =(int)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_INT(&mn,&array[i]) > 0) mn =(int)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_INT(const int *array, size_t size){ if(array == 
+# 114 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 114 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_INT(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+unsigned int MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size){ if(array == 
+# 115 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 115 "src/tools_t/tools_t.c"
+) return 0; unsigned int mx =(unsigned int)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_INT(&mx,&array[i]) < 0) mx =(unsigned int)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size){ if(array == 
+# 115 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 115 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_INT(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} unsigned int MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size){ if(array == 
+# 115 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 115 "src/tools_t/tools_t.c"
+) return 0; unsigned int mn =(unsigned int)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_INT(&mn,&array[i]) > 0) mn =(unsigned int)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_U_INT(const unsigned int *array, size_t size){ if(array == 
+# 115 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 115 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_INT(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+long int MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size){ if(array == 
+# 116 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 116 "src/tools_t/tools_t.c"
+) return 0; long int mx =(long int)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_L_INT(&mx,&array[i]) < 0) mx =(long int)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_L_INT(const long int *array, size_t size){ if(array == 
+# 116 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 116 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_L_INT(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} long int MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size){ if(array == 
+# 116 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 116 "src/tools_t/tools_t.c"
+) return 0; long int mn =(long int)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_L_INT(&mn,&array[i]) > 0) mn =(long int)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_L_INT(const long int *array, size_t size){ if(array == 
+# 116 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 116 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_L_INT(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+unsigned long int MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size){ if(array == 
+# 117 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 117 "src/tools_t/tools_t.c"
+) return 0; unsigned long int mx =(unsigned long int)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_L_INT(&mx,&array[i]) < 0) mx =(unsigned long int)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size){ if(array == 
+# 117 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 117 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_L_INT(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} unsigned long int MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size){ if(array == 
+# 117 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 117 "src/tools_t/tools_t.c"
+) return 0; unsigned long int mn =(unsigned long int)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_L_INT(&mn,&array[i]) > 0) mn =(unsigned long int)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_U_L_INT(const unsigned long int *array, size_t size){ if(array == 
+# 117 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 117 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_U_L_INT(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+size_t MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size){ if(array == 
+# 118 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 118 "src/tools_t/tools_t.c"
+) return 0; size_t mx =(size_t)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_SIZE_T(&mx,&array[i]) < 0) mx =(size_t)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size){ if(array == 
+# 118 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 118 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_SIZE_T(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} size_t MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size){ if(array == 
+# 118 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 118 "src/tools_t/tools_t.c"
+) return 0; size_t mn =(size_t)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_SIZE_T(&mn,&array[i]) > 0) mn =(size_t)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_SIZE_T(const size_t *array, size_t size){ if(array == 
+# 118 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 118 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_SIZE_T(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+float MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size){ if(array == 
+# 119 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 119 "src/tools_t/tools_t.c"
+) return 0; float mx =(float)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_FLOAT(&mx,&array[i]) < 0) mx =(float)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_FLOAT(const float *array, size_t size){ if(array == 
+# 119 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 119 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_FLOAT(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} float MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size){ if(array == 
+# 119 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 119 "src/tools_t/tools_t.c"
+) return 0; float mn =(float)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_FLOAT(&mn,&array[i]) > 0) mn =(float)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_FLOAT(const float *array, size_t size){ if(array == 
+# 119 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 119 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_FLOAT(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+double MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size){ if(array == 
+# 120 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 120 "src/tools_t/tools_t.c"
+) return 0; double mx =(double)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_DOUBLE(&mx,&array[i]) < 0) mx =(double)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_DOUBLE(const double *array, size_t size){ if(array == 
+# 120 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 120 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_DOUBLE(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} double MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size){ if(array == 
+# 120 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 120 "src/tools_t/tools_t.c"
+) return 0; double mn =(double)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_DOUBLE(&mn,&array[i]) > 0) mn =(double)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_DOUBLE(const double *array, size_t size){ if(array == 
+# 120 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 120 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_DOUBLE(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+long double MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size){ if(array == 
+# 121 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 121 "src/tools_t/tools_t.c"
+) return 0; long double mx =(long double)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_L_DOUBLE(&mx,&array[i]) < 0) mx =(long double)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size){ if(array == 
+# 121 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 121 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_L_DOUBLE(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} long double MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size){ if(array == 
+# 121 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 121 "src/tools_t/tools_t.c"
+) return 0; long double mn =(long double)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_L_DOUBLE(&mn,&array[i]) > 0) mn =(long double)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_L_DOUBLE(const long double *array, size_t size){ if(array == 
+# 121 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 121 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_L_DOUBLE(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
+char* MAX_ARRAY_TYPE_STRING(const char* *array, size_t size){ if(array == 
+# 122 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 122 "src/tools_t/tools_t.c"
+) return 0; char* mx =(char*)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_STRING(&mx,&array[i]) < 0) mx =(char*)array[i]; return mx;} size_t ARG_MAX_ARRAY_TYPE_STRING(const char* *array, size_t size){ if(array == 
+# 122 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 122 "src/tools_t/tools_t.c"
+) return 0; size_t i_mx = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_STRING(&array[i_mx],&array[i]) < 0) i_mx = i; return i_mx;} char* MIN_ARRAY_TYPE_STRING(const char* *array, size_t size){ if(array == 
+# 122 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 122 "src/tools_t/tools_t.c"
+) return 0; char* mn =(char*)array[0]; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_STRING(&mn,&array[i]) > 0) mn =(char*)array[i]; return mn;} size_t ARG_MIN_ARRAY_TYPE_STRING(const char* *array, size_t size){ if(array == 
+# 122 "src/tools_t/tools_t.c" 3 4
+((void *)0)
+# 122 "src/tools_t/tools_t.c"
+) return 0; size_t i_mn = 0; for(size_t i = 0; i < size; ++i) if(COMPARE_N_TYPE_STRING(&array[i_mn],&array[i]) > 0) i_mn = i; return i_mn;}
diff --git a/isgood b/isgood
index 2e6a955d8be3adf568dfa6c267815164835d8435..e4a27c6d62980b82661707e043a16194cfa399f2 100644
GIT binary patch
literal 43064
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
Bv?2fi

literal 42688
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
Kw;9;7+W!aKA6#qz

diff --git a/src/test_t/is_good.c b/src/test_t/is_good.c
index 69b7925..703ba0a 100644
--- a/src/test_t/is_good.c
+++ b/src/test_t/is_good.c
@@ -1,6 +1,11 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
+#ifdef __linux__ 
+  #include <unistd.h>
+#elif _WIN32 
+  #include <windows.h>
+#endif
 
 #include "src/test_t/test_t.h"
 
@@ -55,21 +60,22 @@ TEST(double_equal){
   double a = 1.00000001;
   double b = 1.00000001;
   ASSERT_EQ_TYPE_DOUBLE(a,b);
-  b=1.0000000101;
+  b=1.00000001000000001;
   ASSERT_EQ_TYPE_DOUBLE(a,b);
-  ASSERT_EQ_TYPE_DOUBLE(1.0000000102,b);
+  ASSERT_EQ_TYPE_DOUBLE(1.0000000100000002,b);
 }
 
 TEST(){
   unsigned char c = 'a';
 
-  printf("another size_permutation2, a = %c\n",c);
+  debug_print("another size_permutation2, a = %c\n",c);
   ASSERT_FALSE(true);
   ASSERT_TRUE(true);
   ASSERT_TRUE(true);
 }
 
 TEST(){
+  sleep(3);
   int a = 5;
   long b = 5;
   ASSERT_EQ(a,b);
@@ -78,6 +84,18 @@ TEST(){
 
 }
 
+TEST(expect){
+  sleep(2);
+  int a = 5;
+  int b = 6;
+  EXPECT_EQ(a,b);
+  EXPECT_EQ_TYPE_STRING("hello","hello");
+  float f1 = 1.00019999, f2=1.00019999;
+  EXPECT_EQ_TYPE_FLOAT(f1,f2);
+
+  //EXPECT_EQ_TYPE_FLOAT(f1, 1.0001);
+}
+
 //END_TEST(size_permutation)
 
 //INIT()
diff --git a/src/test_t/test_t.c b/src/test_t/test_t.c
index 0da727a..87bb88d 100644
--- a/src/test_t/test_t.c
+++ b/src/test_t/test_t.c
@@ -12,10 +12,25 @@
 #define HK_DN "[      DONE]"
 #define HK_OK "[       OK ]"
 #define HK_FL "[  FAILED  ]"
+#define HK_PS "[  PASSED  ]"
 
+
+#ifndef SECOND
+  #define SECOND 0
+#endif
+#ifndef NANOSECOND
+  #define NANOSECOND 0
+#endif
+
+
+
+//#define INCR_PASS_CNT ++count_passed_local;
+//#define INCR_FAIL_CNT ++count_failed_local;
+
+/*
 #define INCR_PASS_CNT ++count_passed; ++count_passed_local;
 #define INCR_FAIL_CNT ++count_failed; ++count_failed_local;
-
+*/
 struct failed_lists{
   char *name;
   struct failed_lists *next;
@@ -41,6 +56,18 @@ void append_failed_list(const char *name_failed){
 }
 
 
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start){
+  return (time_stop.tv_sec - time_start.tv_sec) + 1.0e-9 * (time_stop.tv_nsec - time_start.tv_nsec);
+}
+
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start){
+  return 1.0e3 * (time_stop.tv_sec - time_start.tv_sec) + 1.0e-3 * (time_stop.tv_nsec - time_start.tv_nsec);
+}
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start){
+  return 1.0e9 * (time_stop.tv_sec - time_start.tv_sec) + (time_stop.tv_nsec - time_start.tv_nsec);
+}
+
+
 size_t count_tests = 0;
 
 size_t count_passed = 0;
@@ -70,52 +97,53 @@ void printHK_color(char *color, char *HK, char * format, ...){
    va_end(args);
 }
 
-#define ASSERT_EXPECT_FROM(expect, not_expect)                                            \
-bool assert_##expect##_from(bool val, const char * var_name, const char *func_name){      \
+#define EXPECTED_EXPECT_FROM(expect, not_expect)                                            \
+bool expected_##expect##_f(bool val, const char * var_name, const char *func_name){      \
   if(val == expect) {                                                                     \
-    INCR_PASS_CNT;                                                                        \
+    ++count_passed_local; /*INCR_PASS_CNT;*/                                                                        \
     printHK_color(GREEN_K,HK_TR," 1 test passed from %s \n\n",func_name);                 \
     return true;                                                                          \
   }else {                                                                                 \
-    INCR_FAIL_CNT;                                                                        \
+    ++count_failed_local; /*INCR_FAIL_CNT;*/                                                                        \
     printHK_color(RED_K,HK_TR," 1 test failed from %s \n",func_name);                     \
-    append_failed_list(func_name);                                                        \
-    printf("Value of: %s\nActual: %s\nExpected: %s\n\n",#not_expect, #expect, var_name);  \
+    /*append_failed_list(func_name);*/                                                        \
+    printf("Value of: %s\nActual: %s\nExpected: %s\n\n", var_name, #not_expect, #expect);  \
     return false;                                                                         \
   }                                                                                       \
 }     
 
-ASSERT_EXPECT_FROM(true,false)
-ASSERT_EXPECT_FROM(false,true)
+EXPECTED_EXPECT_FROM(true,false)
+EXPECTED_EXPECT_FROM(false,true)
 
-#define ASSERT_EQ_TYPE(type)\
-bool assert_eq_##type(type var1, type var2,                                                       \
+#define EXPECTED_EQ_TYPE(type)\
+bool expected_eq_##type(type var1, type var2,                                                       \
     const char *var1_name, const char *var2_name, const char *func_name){                         \
   if(COMPARE_N_##type(&var1, &var2) == 0){                                                        \
-    INCR_PASS_CNT;                                                                                \
+    ++count_passed_local; /*INCR_PASS_CNT;*/                                                                        \
     printHK_color(GREEN_K,HK_TR," 1 test passed from %s \n\n",func_name);                         \
     return true;                                                                                  \
   }else {                                                                                         \
-    INCR_FAIL_CNT;                                                                                \
+    ++count_failed_local; /*INCR_FAIL_CNT;*/                                                                        \
+    /*append_failed_list(func_name);*/                                                              \
     printHK_color(RED_K,HK_TR," 1 test failed from %s \n",func_name);                             \
-    append_failed_list(func_name);                                                                \
     printf("Expected equality of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n"  \
         ,var1_name, type##_TO_STR(var1),  var2_name, type##_TO_STR(var2));                        \
     return false;                                                                                 \
   }                                                                                               \
 }
 
-ASSERT_EQ_TYPE(TYPE_CHAR)
-ASSERT_EQ_TYPE(TYPE_U_CHAR)
-ASSERT_EQ_TYPE(TYPE_INT)
-ASSERT_EQ_TYPE(TYPE_U_INT)
-ASSERT_EQ_TYPE(TYPE_L_INT)
-ASSERT_EQ_TYPE(TYPE_U_L_INT)
-ASSERT_EQ_TYPE(TYPE_SIZE_T)
-ASSERT_EQ_TYPE(TYPE_FLOAT)
-ASSERT_EQ_TYPE(TYPE_DOUBLE)
-ASSERT_EQ_TYPE(TYPE_L_DOUBLE)
-ASSERT_EQ_TYPE(TYPE_STRING)
+
+EXPECTED_EQ_TYPE(TYPE_CHAR)
+EXPECTED_EQ_TYPE(TYPE_U_CHAR)
+EXPECTED_EQ_TYPE(TYPE_INT)
+EXPECTED_EQ_TYPE(TYPE_U_INT)
+EXPECTED_EQ_TYPE(TYPE_L_INT)
+EXPECTED_EQ_TYPE(TYPE_U_L_INT)
+EXPECTED_EQ_TYPE(TYPE_SIZE_T)
+EXPECTED_EQ_TYPE(TYPE_FLOAT)
+EXPECTED_EQ_TYPE(TYPE_DOUBLE)
+EXPECTED_EQ_TYPE(TYPE_L_DOUBLE)
+EXPECTED_EQ_TYPE(TYPE_STRING)
 
 
 
@@ -141,22 +169,36 @@ append_func(void (*run)(void), char *name){
   ++count_tests;
 }
 
-void begin_execute_func(char *fun_ame){
+void begin_execute_func(char *fun_ame, struct timespec *start_t){
+  clock_gettime(CLOCK_REALTIME, start_t);
   vprintf_colored(GREEN_K,HK_RN); 
   printf(" %s\n", fun_ame); 
   count_passed_local = 0;
   count_failed_local = 0;
 }
-void end_execute_func(char *fun_ame){
-  if(count_passed_local){
-    printHK_color(GREEN_K,HK_DN," %lu tests passed from %s\n",count_passed_local,fun_ame);
-  }
+
+#define PRINT_TIMESTAMP_STAT(color)\
+    if(SECOND) printHK_color(color,HK_DN," %lu tests passed from %s (%lf s)\n\n",count_passed_local,fun_ame, diff_timespec_seconds(end_t, start_t));\
+    else if(NANOSECOND) printHK_color(color,HK_DN," %lu tests passed from %s (%ld ns)\n\n",count_passed_local,fun_ame, diff_timespec_nanoseconds(end_t, start_t));\
+    else printHK_color(color,HK_DN," %lu tests passed from %s (%lf ms)\n\n",count_passed_local,fun_ame, diff_timespec_milliseconds(end_t, start_t));
+
+void end_execute_func(char *fun_ame, struct timespec start_t){
+  struct timespec end_t; clock_gettime(CLOCK_REALTIME, &end_t);
   if(count_failed_local){
-    printHK_color(RED_K, HK_DN, " %lu tests failed from %s\n",count_failed_local,fun_ame);
+    ++count_failed;
+    append_failed_list(fun_ame); 
+    printHK_color(RED_K, HK_FL, " %lu tests failed from %s\n",count_failed_local,fun_ame);
+    PRINT_TIMESTAMP_STAT(RED_K);
+  }
+  else 
+  {
+    ++count_passed;
+    PRINT_TIMESTAMP_STAT(GREEN_K);
   }
 }
 
-void head_run(size_t nbtest){
+void head_run(size_t nbtest, struct timespec *start_t){
+  clock_gettime(CLOCK_REALTIME, start_t);
   printHK_color(GREEN_K, HK_EQ," Running %lu tests.\n",nbtest);
 }
 
@@ -167,7 +209,14 @@ void list_failed_test(struct failed_lists *failed_lst){
 
 
 void
-stat_end_run(){
+stat_end_run(size_t ntst, struct timespec start_t){
+  struct timespec end_t; clock_gettime(CLOCK_REALTIME, &end_t);
+  
+  if(SECOND) printHK_color(GREEN_K, HK_EQ," %lu tests ran. (%lf s total)\n",ntst, diff_timespec_seconds(end_t, start_t));
+  else if(NANOSECOND) printHK_color(GREEN_K, HK_EQ," %lu tests ran. (%ld ns total)\n",ntst, diff_timespec_nanoseconds(end_t, start_t));
+  else printHK_color(GREEN_K, HK_EQ," %lu tests ran. (%lf ms total)\n",ntst, diff_timespec_milliseconds(end_t, start_t));
+  
+  printHK_color(GREEN_K, HK_PS," %lu tests\n", count_passed);
   if(failed_l != NULL){
     printHK_color(RED_K, HK_FL," %lu tests, listed below:\n",count_failed); 
     list_failed_test(failed_l);
@@ -187,23 +236,25 @@ bool is_in_array(size_t *array, size_t sz, size_t num){
 
 void execute_all(struct func *fun){
   struct func *tmp = fun;
+  struct timespec start_t;
   //printHK_color(GREEN_K, HK_EQ," Running %lu tests.\n",count_tests);
   while(tmp){
-    begin_execute_func(tmp->name);
+    begin_execute_func(tmp->name, &start_t);
     tmp->run();
-    end_execute_func(tmp->name);
+    end_execute_func(tmp->name, start_t);
     tmp = tmp->next;
   }
 }
 
 void execute_one_test(struct func *fun, size_t num){
   size_t cur = 0;
+  struct timespec start_t;
   struct func *tmp = fun;
   while(tmp){
     if(cur++ == num){
-      begin_execute_func(fun->name);
+      begin_execute_func(fun->name, &start_t);
       fun->run();
-      end_execute_func(fun->name);
+      end_execute_func(fun->name, start_t);
     }
     tmp = tmp->next;
   }
@@ -212,14 +263,15 @@ void execute_one_test(struct func *fun, size_t num){
 
 void execute_some_tests_ordered(struct func *fun, size_t cnt, size_t *array )
 {   
+  struct timespec start_t;
   struct func *tmp = fun;
   size_t cur = 0, index = 0;
   
   while(tmp){
     if((cur < cnt) && (index++ == array[cur])){
-      begin_execute_func(tmp->name);
+      begin_execute_func(tmp->name, &start_t);
       tmp->run();
-      end_execute_func(tmp->name);
+      end_execute_func(tmp->name, start_t);
       ++cur;
     }   
     tmp = tmp->next;
@@ -229,20 +281,22 @@ void execute_some_tests_ordered(struct func *fun, size_t cnt, size_t *array )
 void
 run_some_tests(size_t cnt, ...)
 {
-   head_run(cnt);
+   struct timespec start_t;
+   head_run(cnt, &start_t);
    va_list args;
    va_start(args, cnt);
    for(size_t i=0; i < cnt; ++i){
     execute_one_test(&f_beging, va_arg(args, size_t));
    }
    va_end(args);
-   stat_end_run();
+   stat_end_run(cnt, start_t);
 }
 
 void 
 run_some_tests_ordered(size_t cnt, ... )
 {
-   head_run(cnt);
+   struct timespec start_t;
+   head_run(cnt, &start_t);
    va_list args;
    va_start(args, cnt);
    size_t *array=malloc(cnt*sizeof(size_t));
@@ -252,21 +306,22 @@ run_some_tests_ordered(size_t cnt, ... )
 
    execute_some_tests_ordered(&f_beging, cnt, array);
    va_end(args);
-   stat_end_run();
+   stat_end_run(cnt, start_t);
 }
 
 
 
 
 void execute_all_tests_exept(struct func *fun, size_t cnt, size_t *array )
-{  
+{ 
+  struct timespec start_t; 
   struct func *tmp = fun;
   size_t cur = 0;
   while(tmp){
     if(!is_in_array(array, cnt, cur++)){
-      begin_execute_func(tmp->name);
+      begin_execute_func(tmp->name, &start_t);
       tmp->run();
-      end_execute_func(tmp->name);
+      end_execute_func(tmp->name, start_t);
     }
     tmp = tmp->next;
   }
@@ -275,8 +330,9 @@ void execute_all_tests_exept(struct func *fun, size_t cnt, size_t *array )
 void 
 run_all_tests_exept(size_t cnt, ... )
 {
+   struct timespec start_t;
    if(count_tests >= cnt)
-      head_run(count_tests - cnt);
+      head_run(count_tests - cnt, &start_t);
    va_list args;
    va_start(args, cnt);
    size_t *array=malloc(cnt*sizeof(size_t));
@@ -286,16 +342,18 @@ run_all_tests_exept(size_t cnt, ... )
 
    execute_all_tests_exept(&f_beging, cnt, array);
    va_end(args);
-   stat_end_run();
+   if(count_tests >= cnt)
+     stat_end_run(count_tests - cnt, start_t);
 }
 
 
 void
 run_all_tests()
 {
-   head_run(count_tests);
+   struct timespec start_t;
+   head_run(count_tests, &start_t);
    execute_all(&f_beging);
-   stat_end_run();
+   stat_end_run(count_tests, start_t);
 }
 
 void 
diff --git a/src/test_t/test_t.h b/src/test_t/test_t.h
index c50c30a..d95a820 100644
--- a/src/test_t/test_t.h
+++ b/src/test_t/test_t.h
@@ -5,6 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
+//#include <time.h>
 
 #include "src/tools_t/tools_t.h"
 
@@ -31,39 +32,55 @@ void run_some_tests_ordered(size_t cnt, ... );
 
 
 
-bool assert_true_from(bool val, const char* var_name, const char * func_name);
-bool assert_false_from(bool val, const char* var_name, const char * func_name);
+bool expected_true_f(bool val, const char* var_name, const char * func_name);
+bool expected_false_f(bool val, const char* var_name, const char * func_name);
 
 
-#define GEN_ASSERT_EQ_TYPE_FUNC(type)\
-  bool assert_eq_##type(type var1, type var2,                                                   \
+#define GEN_EXPECTED_EQ_TYPE_FUNC(type)\
+  bool expected_eq_##type(type var1, type var2,                                                   \
     const char *var1_name, const char *var2_name, const char *func_name);                       \
 
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_CHAR)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_U_CHAR)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_INT)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_U_INT)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_L_INT)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_U_L_INT)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_SIZE_T)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_FLOAT)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_DOUBLE)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_L_DOUBLE)
-GEN_ASSERT_EQ_TYPE_FUNC(TYPE_STRING)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_CHAR)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_U_CHAR)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_INT)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_U_INT)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_L_INT)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_U_L_INT)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_SIZE_T)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_FLOAT)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_DOUBLE)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_L_DOUBLE)
+GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_STRING)
 
-#define ASSERT_EQ_TYPE_CHAR(var1, var2) if(assert_eq_TYPE_CHAR(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_U_CHAR(var1, var2) if(assert_eq_TYPE_U_CHAR(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_INT(var1, var2) if(assert_eq_TYPE_INT(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_U_INT(var1, var2) if(assert_eq_TYPE_U_INT(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_L_INT(var1, var2) if(assert_eq_TYPE_L_INT(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_U_L_INT(var1, var2) if(assert_eq_TYPE_U_L_INT(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_SIZE_T(var1, var2) if(assert_eq_TYPE_SIZE_T(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_FLOAT(var1, var2) if(assert_eq_TYPE_FLOAT(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_DOUBLE(var1, var2) if(assert_eq_TYPE_DOUBLE(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_L_DOUBLE(var1, var2) if(assert_eq_TYPE_L_DOUBLE(var1, var2, #var1, #var2, __func__) == false) return ;
-#define ASSERT_EQ_TYPE_STRING(var1, var2) if(assert_eq_TYPE_STRING(var1, var2, #var1, #var2, __func__) == false) return ;
+#define EXPECT_EQ_TYPE_CHAR(var1, var2) expected_eq_TYPE_CHAR(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_U_CHAR(var1, var2) expected_eq_TYPE_U_CHAR(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_INT(var1, var2) expected_eq_TYPE_INT(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_U_INT(var1, var2) expected_eq_TYPE_U_INT(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_L_INT(var1, var2) expected_eq_TYPE_L_INT(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_U_L_INT(var1, var2) expected_eq_TYPE_U_L_INT(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_SIZE_T(var1, var2) expected_eq_TYPE_SIZE_T(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_FLOAT(var1, var2) expected_eq_TYPE_FLOAT(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_DOUBLE(var1, var2) expected_eq_TYPE_DOUBLE(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_L_DOUBLE(var1, var2) expected_eq_TYPE_L_DOUBLE(var1, var2, #var1, #var2, __func__) ;
+#define EXPECT_EQ_TYPE_STRING(var1, var2) expected_eq_TYPE_STRING(var1, var2, #var1, #var2, __func__) ;
 
-#define ASSERT_EQ(var1, var2) if(assert_eq_TYPE_L_INT(var1, var2, #var1, #var2, __func__) == false) return ;
+#define EXPECT_EQ(var1, var2) expected_eq_TYPE_L_INT(var1, var2, #var1, #var2, __func__) ;
+
+
+
+#define ASSERT_EQ_TYPE_CHAR(var1, var2) do{ if(expected_eq_TYPE_CHAR(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_U_CHAR(var1, var2) do{ if(expected_eq_TYPE_U_CHAR(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_INT(var1, var2) do{ if(expected_eq_TYPE_INT(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_U_INT(var1, var2) do{ if(expected_eq_TYPE_U_INT(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_L_INT(var1, var2) do{ if(expected_eq_TYPE_L_INT(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_U_L_INT(var1, var2) do{ if(expected_eq_TYPE_U_L_INT(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_SIZE_T(var1, var2) do{ if(expected_eq_TYPE_SIZE_T(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_FLOAT(var1, var2) do{ if(expected_eq_TYPE_FLOAT(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_DOUBLE(var1, var2) do{ if(expected_eq_TYPE_DOUBLE(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_L_DOUBLE(var1, var2) do{ if(expected_eq_TYPE_L_DOUBLE(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+#define ASSERT_EQ_TYPE_STRING(var1, var2) do{ if(expected_eq_TYPE_STRING(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
+
+#define ASSERT_EQ(var1, var2) do{ if(expected_eq_TYPE_L_INT(var1, var2, #var1, #var2, __func__) == false) return ;} while(0)
 
 
 #define CONCAT(x,y) x ## y
@@ -95,10 +112,10 @@ GEN_ASSERT_EQ_TYPE_FUNC(TYPE_STRING)
   FTEST__(__COUNTER__,name_f)
 
 #define ASSERT_TRUE(val)\
-  if(assert_true_from(val,#val,__func__) == false) return;
+  if(expected_true_f(val,#val,__func__) == false) return;
   
 #define ASSERT_FALSE(val)\
-  if(assert_false_from(val,#val,__func__) == false) return;
+  if(expected_false_f(val,#val,__func__) == false) return;
 
 
 
diff --git a/src/tools_t/tools_t.c b/src/tools_t/tools_t.c
index dea4fb9..0630370 100644
--- a/src/tools_t/tools_t.c
+++ b/src/tools_t/tools_t.c
@@ -1,5 +1,18 @@
 #include "src/tools_t/tools_t.h"
 
+/*
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start){
+  return (time_stop.tv_sec - time_start.tv_sec) + 1.0e-9 * (time_stop.tv_nsec - time_start.tv_nsec);
+}
+
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start){
+  return 1.0e3 * (time_stop.tv_sec - time_start.tv_sec) + 1.0e-3 * (time_stop.tv_nsec - time_start.tv_nsec);
+}
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start){
+  return 1.0e9 * (time_stop.tv_sec - time_start.tv_sec) + (time_stop.tv_nsec - time_start.tv_nsec);
+}
+*/
+
 
 #define GEN_TO_STR_N(type,size,format)  \
   TYPE_STRING type##_TO_STR(type var){  \
diff --git a/src/tools_t/tools_t.h b/src/tools_t/tools_t.h
index c952df0..05fb420 100644
--- a/src/tools_t/tools_t.h
+++ b/src/tools_t/tools_t.h
@@ -5,13 +5,26 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdbool.h>
-
+#include <time.h>
 
 // to define DEBUG in gcc cli do: gcc -D DEBUG=1 or 0 if need!
 #ifndef DEBUG
   #define DEBUG 0
 #endif
 
+/*
+#ifndef SECOND
+  #define SECOND 0
+#endif
+#ifndef NANOSECOND
+  #define NANOSECOND 0
+#endif
+
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
+*/
+
 #define debug_print(fmt, ...) \
   do { if (DEBUG) fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
       __LINE__, __func__, __VA_ARGS__); } while (0)