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 2e6a955..e4a27c6 100644
Binary files a/isgood and b/isgood differ
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)