opencstl.h

// OpenCSTL — Single-Header Amalgamation (compact)
// Copyright (C) 2018-2026, Kim Bomm. Licensed under the OpenCSTL License Agreement.

#pragma once
#ifndef _OPENCSTL_AMALGAMATED_H
#define _OPENCSTL_AMALGAMATED_H
#if defined(__cplusplus)
extern "C" {
#endif
#ifndef _OPENCSTL_CROSSPLATFORM_H
#define _OPENCSTL_CROSSPLATFORM_H
#if defined(_WIN32) || defined(_WIN64)
#define OCSTL_OS_STR "Windows"
#define OCSTL_OS_WINDOWS
#elif defined(__linux__)
#define OCSTL_OS_STR "Linux"
#define OCSTL_OS_LINUX
#elif defined(__APPLE__)
#define OCSTL_OS_STR "MacOS"
#define OCSTL_OS_MACOS
#endif
#if defined(__POCC__)
#define OCSTL_CC_STR "PellesC"
#define OCSTL_CC_POCC
#elif defined(__NVCC__)
#define OCSTL_CC_STR "NVCC"
#define OCSTL_CC_NVCC
#elif defined(__clang__)
#define OCSTL_CC_STR "Clang"
#define OCSTL_CC_CLANG
#elif defined(__TINYC__)
#define OCSTL_CC_STR "TCC"
#define OCSTL_CC_TCC
#elif defined(_MSC_VER)
#define OCSTL_CC_STR "MSVC"
#define OCSTL_CC_MSVC
#elif defined(__GNUC__)
#define OCSTL_CC_STR "GCC"
#define OCSTL_CC_GCC
#endif
#if defined(__STDC_VERSION__)
#   if __STDC_VERSION__ >= 202311L
#define OCSTL_C_VERSION_STR "C23"
#define OCSTL_C_VERSION_23
#   elif __STDC_VERSION__ >= 201710L
#define OCSTL_C_VERSION_STR "C17 (C18)"
#define OCSTL_C_VERSION_17
#   elif __STDC_VERSION__ >= 201112L
#define OCSTL_C_VERSION_STR "C11"
#define OCSTL_C_VERSION_11
#   elif __STDC_VERSION__ >= 199901L
#define OCSTL_C_VERSION_STR "C99"
#define OCSTL_C_VERSION_99
#   else
#define OCSTL_C_VERSION_STR "C94 (AMD1)"
#define OCSTL_C_VERSION_94
#   endif
#elif defined(__STDC__)
#define OCSTL_C_VERSION_STR "C89 (C90)"
#define OCSTL_C_VERSION_89
#else
#define OCSTL_C_VERSION_STR "pre-ANSI C (K&R)"
#define OCSTL_C_VERSION_PRE_ANSI
#endif
#if defined(_DEBUG) || !defined(NDEBUG)
#define OCSTL_DEBUG
#else
#define OCSTL_RELEASE
#endif
#endif
#ifndef OPENCSTL_THREADING_CC_H
#define OPENCSTL_THREADING_CC_H
#include <stdint.h>
#if defined(OCSTL_OS_WINDOWS)
#include <windows.h>
#elif defined(OCSTL_OS_MACOS)
#include <sys/sysctl.h>
#else
#include <unistd.h>
#endif
static int cpu_count(void) {
#if defined(OCSTL_OS_WINDOWS)
    SYSTEM_INFO si;
    GetSystemInfo(&si);
    return (int) si.dwNumberOfProcessors;
#elif defined(OCSTL_OS_MACOS)
    int count = 0;
    size_t size = sizeof(count);
    sysctlbyname("hw.logicalcpu", &count, &size, NULL, 0);
    return count;
#else
    int cpu_threads = 0;
    int siblings = 0;
    int cpu_cores = 0;
    int got_sib = 0;
    int got_cor = 0;
    FILE *f = fopen("/proc/cpuinfo", "r");
    if (f) {
        char line[128];
        while (fgets(line, sizeof(line), f)) {
            if (strncmp(line, "processor", 9) == 0) {
                cpu_threads++;
            }
            if (!got_sib && strncmp(line, "siblings", 8) == 0) {
                char *colon = strchr(line, ':');
                if (colon) {
                    siblings = atoi(colon + 1);
                    got_sib = 1;
                }
            }
            if (!got_cor && strncmp(line, "cpu cores", 9) == 0) {
                char *colon = strchr(line, ':');
                if (colon) {
                    cpu_cores = atoi(colon + 1);
                    got_cor = 1;
                }
            }
        }
        fclose(f);
    }
    int hyper_threading = (got_sib && got_cor && cpu_cores > 0)
                              ? (siblings == cpu_cores * 2)
                              : 0;
    if (hyper_threading) {
        cpu_threads *= 2;
    }
    if (cpu_threads <= 0) {
        long n = sysconf(_SC_NPROCESSORS_ONLN);
        cpu_threads = n > 0 ? (int) n : 1;
    }
    return cpu_threads;
#endif
}
#if defined(OCSTL_OS_WINDOWS)
#include <windows.h>
#elif defined(OCSTL_OS_LINUX)
#include <sys/syscall.h>
#include <unistd.h>
#elif defined(OCSTL_OS_MACOS)
#include <mach/mach.h>
#include <mach/mach_time.h>
#include <mach/thread_policy.h>
#endif
static void cpu_pin(void) {
#if defined(OCSTL_OS_WINDOWS)
    SetThreadAffinityMask(GetCurrentThread(), (DWORD_PTR) 1 << 0);
#elif defined(OCSTL_OS_LINUX)
    unsigned long cpuset = 0UL;
    cpuset |= 1UL << 0;
    syscall(SYS_sched_setaffinity, 0, sizeof(cpuset), &cpuset);
#elif defined(OCSTL_OS_MACOS)
    thread_affinity_policy_data_t affinity = {1};
    thread_policy_set(
        mach_thread_self(),
        THREAD_AFFINITY_POLICY,
        (thread_policy_t) & affinity,
        THREAD_AFFINITY_POLICY_COUNT
    );
    mach_timebase_info_data_t tb;
    mach_timebase_info(&tb);
#define NS_TO_MACH(ns) ((uint64_t)(ns) * tb.denom / tb.numer)
    thread_time_constraint_policy_data_t rt;
    rt.period = 0;
    rt.computation = NS_TO_MACH(500000000);
    rt.constraint = NS_TO_MACH(500000000);
    rt.preemptible = 0;
    thread_policy_set(
        mach_thread_self(),
        THREAD_TIME_CONSTRAINT_POLICY,
        (thread_policy_t) & rt,
        THREAD_TIME_CONSTRAINT_POLICY_COUNT
    );
#undef NS_TO_MACH
#endif
}
#endif
#if defined(OCSTL_CC_MSVC)
#pragma warning(disable:4819)
#endif
#if defined(OCSTL_CC_CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wformat"
#pragma clang diagnostic ignored "-Wunused-parameter"
#pragma clang diagnostic ignored "-Wunused-variable"
#pragma clang diagnostic ignored "-Wunused-function"
#pragma clang diagnostic ignored "-Wunused-value"
#pragma clang diagnostic ignored "-Wsign-compare"
#pragma clang diagnostic ignored "-Wpedantic"
#pragma clang diagnostic ignored "-Wgnu-auto-type"
#pragma clang diagnostic ignored "-Wsometimes-uninitialized"
#pragma clang diagnostic ignored "-Wnonnull"
#pragma clang diagnostic ignored "-Wcast-function-type-mismatch"
#ifdef OCSTL_OS_MACOS
#pragma clang diagnostic ignored "-Wgnu-statement-expression-from-macro-expansion"
#endif
#if !defined(OCSTL_OS_LINUX) && !defined(OCSTL_OS_WINDOWS)
#pragma clang diagnostic ignored "-Wuse-after-free"
#endif
#endif
#if defined(OCSTL_CC_GCC)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#pragma GCC diagnostic ignored "-Wunused-value"
#pragma GCC diagnostic ignored "-Wsign-compare"
#pragma GCC diagnostic ignored "-Wpedantic"
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wuse-after-free"
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
#pragma GCC diagnostic ignored "-Wnonnull"
#pragma GCC diagnostic ignored "-Wcast-function-type"
#pragma GCC diagnostic ignored "-Wformat="
#pragma GCC diagnostic ignored "-Wnonnull"
#endif
#if !defined(_OPENCSTL_ZALLOC_H)
#define _OPENCSTL_ZALLOC_H
#include <stdlib.h>
#ifndef OPENCSTL_TRACER_H
#define OPENCSTL_TRACER_H
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if !defined(_OPENCSTL_TYPES_H)
#define _OPENCSTL_TYPES_H
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdarg.h>
#include<stdint.h>
#include<limits.h>
#include<stddef.h>
#include<stdbool.h>
#include<assert.h>
typedef int (*CSTL_COMPARE)(const void *, const void *);
typedef int (*CSTL_COMPARE_BYTES)(const void *, const void *, size_t);
typedef int (*CSTL_EQUALS_FN)(const void *, const void *, size_t);
typedef bool (*CSTL_COND)(const void *);
typedef int size_type;
typedef long long size_type64;
typedef size_type64 cstl_ptr;
typedef size_type64 (*cstl_hash)(void *key, size_type64 capacity, size_type64 key_size);
typedef int int32_x;
typedef long long int64_x;
typedef unsigned int uint32_x;
typedef unsigned long long uint64_x;
typedef unsigned char ubyte_x;
typedef wchar_t wchar;
#endif
#if !defined(_OPENCSTL_LOGGING_H)
#define _OPENCSTL_LOGGING_H
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#ifdef OCSTL_OS_WINDOWS
#include <windows.h>
#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
#endif
#endif
const char *__red = "\033[31m";
const char *__green = "\033[32m";
const char *__yellow = "\033[33m";
const char *__blue = "\033[34m";
const char *__magenta = "\033[35m";
const char *__cyan = "\033[36m";
const char *__reset = "\033[0m";
#ifdef OCSTL_OS_WINDOWS
static int s_ansi_enabled = -1;
static int try_enable_ansi(void) {
    if (s_ansi_enabled == -1) {
        HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
        DWORD mode = 0;
        if (!GetConsoleMode(h, &mode)) {
            s_ansi_enabled = 0;
        } else {
            s_ansi_enabled = SetConsoleMode(h, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING) ? 1 : 0;
        }
    }
    return s_ansi_enabled;
}
static WORD ansi_to_winattr(const char *color) {
    if (color == __red) return FOREGROUND_RED | FOREGROUND_INTENSITY;
    if (color == __green) return FOREGROUND_GREEN | FOREGROUND_INTENSITY;
    if (color == __yellow) return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY;
    if (color == __blue) return FOREGROUND_BLUE | FOREGROUND_INTENSITY;
    if (color == __magenta) return FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
    if (color == __cyan) return FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY;
    return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
}
#endif
static int __vcprintln(const char *color, const char *format, va_list args) {
    int ret;
#ifdef OCSTL_OS_WINDOWS
    if (try_enable_ansi()) {
        printf("%s", color);
        ret = vprintf(format, args);
        printf("%s\n", __reset);
    } else {
        HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
        SetConsoleTextAttribute(h, ansi_to_winattr(color));
        ret = vprintf(format, args);
        SetConsoleTextAttribute(h, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
        printf("\n");
    }
#elif defined(OCSTL_OS_LINUX) || defined(OCSTL_OS_MACOS)
    printf("%s", color);
    ret = vprintf(format, args);
    printf("%s\n", __reset);
#else
    ret = vprintf(format, args);
    printf("\n");
#endif
    return ret;
}
#if defined(OCSTL_OS_MACOS)
void __fatal_message_box(const char *msg) {
    char cmd[512];
    snprintf(cmd, sizeof(cmd),
             "osascript -e 'display dialog \"%s\" with title \"FATAL\" with icon stop buttons {\"OK\"} default button \"OK\"' > /dev/null 2>&1",
             msg);
    system(cmd);
}
#elif defined(OCSTL_CC_NVCC)
void __fatal_message_box(const char *msg) {
    fprintf(stderr, "[FATAL] %s\n", msg);
}
#elif defined(OCSTL_OS_WINDOWS)
#if !defined(OCSTL_CC_TCC)
void __fatal_message_box(const char *msg) {
    MessageBoxA(NULL, msg, "FATAL", MB_OK | MB_ICONERROR);
}
#else
void __fatal_message_box(const char *msg) {
    fprintf(stderr, "[FATAL] %s\n", msg);
}
#endif
#elif defined(OCSTL_OS_LINUX)
void __fatal_message_box(const char *msg) {
    char cmd[512];
    snprintf(cmd, sizeof(cmd),
             "zenity --error --title=\"FATAL\" --text=\"%s\" 2>/dev/null"
             " || kdialog --error \"%s\" --title \"FATAL\" 2>/dev/null",
             msg, msg);
    if (system(cmd) != 0)
        fprintf(stderr, "[FATAL] %s\n", msg);
}
#endif
int __clogging(const char *color, const char *format, ...) {
    va_list args;
    int ret;
    va_start(args, format);
    ret = __vcprintln(color, format, args);
    va_end(args);
    return ret;
}
static int _logging_error(const char *format, ...) {
    va_list args;
    int ret;
    va_start(args, format);
    ret = __vcprintln(__red, format, args);
    va_end(args);
    return ret;
}
static int _logging_debug(const char *format, ...) {
#if defined(OCSTL_DEBUG)
    va_list args;
    int ret;
    va_start(args, format);
    ret = __vcprintln(__green, format, args);
    va_end(args);
    return ret;
#else
    return 0;
#endif
}
static int _logging_warning(const char *format, ...) {
    va_list args;
    int ret;
    va_start(args, format);
    ret = __vcprintln(__yellow, format, args);
    va_end(args);
    return ret;
}
static int _logging_info(const char *format, ...) {
    va_list args;
    int ret;
    va_start(args, format);
    ret = __vcprintln(__blue, format, args);
    va_end(args);
    return ret;
}
static int _logging_critical(const char *format, ...) {
    va_list args;
    int ret;
    va_start(args, format);
    ret = __vcprintln(__magenta, format, args);
    va_end(args);
    return ret;
}
static int _logging_fatal(const char *format, ...) {
    va_list args;
    int ret;
    va_start(args, format);
    ret = __vcprintln(__cyan, format, args);
    va_end(args);
    return ret;
}
typedef int (*logging_fn)(const char *format, ...);
typedef struct LOGGING {
    logging_fn debug;
    logging_fn info;
    logging_fn warning;
    logging_fn error;
    logging_fn critical;
    logging_fn fatal;
} LOGGING;
static const LOGGING logging = {
    _logging_debug,
    _logging_info,
    _logging_warning,
    _logging_error,
    _logging_critical,
    _logging_fatal,
};
#endif
#if !defined(_OPENCSTL_C_ALLOCA_H)
#define _OPENCSTL_C_ALLOCA_H
#if defined(__linux__) || defined(__APPLE__)
#include <alloca.h>
#define salloc(size) (void*)alloca(size)
#elif defined(_WIN32) || defined(_WIN64)
#include <malloc.h>
#define salloc(size) _alloca(size)
#else
#error "No Alloca Function"
#endif
#endif
#if !defined(_HG_B0BA2BCEE842F587B495A9DAC23CC19DF2528F0D7D48D49AA5462B025137A965_H)
#define _HG_B0BA2BCEE842F587B495A9DAC23CC19DF2528F0D7D48D49AA5462B025137A965_H
#define ___OCSTL_1MB   (1024UL * 1024UL)
#define ___OCSTL_128MB (___OCSTL_1MB * 128UL)
#define ___OCSTL_512MB (___OCSTL_1MB * 512UL)
#if defined(OPENCSTL_GBLOCK_MB)
#define ___OCSTL_GBLOCK_SIZE (___OCSTL_1MB * OPENCSTL_GBLOCK_MB)
#else
#define ___OCSTL_GBLOCK_SIZE (___OCSTL_512MB)
#endif
unsigned char OCSTL_GBLOCK[___OCSTL_GBLOCK_SIZE];
unsigned char OCSTL_DBLOCK[___OCSTL_1MB] = {0};
#endif
#define _1MB (1024*1024)
#define _512KB (1024*512)
#ifdef OPENCSTL_TRACER
typedef struct ZMem {
    void *ptr;
    char *file;
    char *func;
    int line;
} ZMEM;
ZMEM zmem[8192] = {0};
size_type64 zalloc_size = 0;
size_type64 zalloc_count = 0;
static void zinsert(void *ptr, char *file, const char *func, int line) {
    zmem[zalloc_size].ptr = ptr;
    zmem[zalloc_size].file = file;
    zmem[zalloc_size].func = (char*)func;
    zmem[zalloc_size].line = line;
    zalloc_size++;
    zalloc_count++;
}
static void zremove(void *ptr) {
    for (size_type64 i = 0; i < zalloc_size; i++) {
        if (zmem[i].ptr == ptr) {
            memmove(zmem + i, zmem + i + 1, (zalloc_size - i - 1) * sizeof(ZMEM));
            zalloc_size--;
            zmem[zalloc_size].ptr = NULL;
            zmem[zalloc_size].file = NULL;
            zmem[zalloc_size].func = NULL;
            zmem[zalloc_size].line = 0;
            return;
        }
    }
}
#endif
#ifdef OPENCSTL_TRACER
static void opencstl_exit(void) {
    if (zalloc_size > 0) {
        logging.warning("%d memory blocks were not released", zalloc_size);
        for (size_type64 i = 0; i < zalloc_size; i++) {
            logging.debug("%p: %s, %s, %d", zmem[i].ptr, zmem[i].file, zmem[i].func, zmem[i].line);
        }
    }
    logging.debug("OpenCSTL tracer end");
    logging.debug("zalloc count: %d", zalloc_count);
}
#endif
#ifdef OPENCSTL_TRACER
#if defined(__GNUC__) || defined(__clang__)
__attribute__((constructor))
#endif
static int opencstl_init(void) {
    logging.debug("OpenCSTL tracer start");
    atexit(opencstl_exit);
    return 0;
}
#if defined(_MSC_VER)
# pragma section(".CRT$XCU",read)
__declspec(allocate(".CRT$XCU")) static int (*__p)(void) = opencstl_init;
# pragma data_seg()
#endif
#endif
#endif
#ifdef OPENCSTL_TRACER
typedef void (*free_fn)(void *ptr);
typedef void *(*malloc_fn)(size_t sz);
typedef void *(*realloc_fn)(void *ptr, size_t new_size);
typedef void * (*calloc_fn)(size_t cnt, size_t sz);
static free_fn ofree = free;
static malloc_fn omalloc = malloc;
static realloc_fn orealloc = realloc;
static calloc_fn ocalloc = calloc;
static void zfree(void *ptr) {
    zremove(ptr);
    ofree(ptr);
}
static void *_zcalloc(size_type64 cnt, size_type64 sz, char *file, const char *func, int line) {
    void *ptr = ocalloc(cnt, sz);
    if (ptr) {
        zinsert(ptr, file, func, line);
    }
    return ptr;
}
static void *_zmalloc(size_type64 sz, char *file, const char *func, int line) {
    void *ptr = omalloc(sz);
    if (ptr) {
        zinsert(ptr, file, func, line);
    }
    return ptr;
}
static void *_zrealloc(void *ptr, size_type64 new_size, char *file, const char *func, int line) {
    if (ptr == NULL) {
        return _zmalloc(new_size, file, func, line);
    }
    if (new_size == 0) {
        zfree(ptr);
        return NULL;
    }
    void *new_ptr = orealloc(ptr, new_size);
    if (new_ptr == NULL) {
        return NULL;
    }
    if (new_ptr != ptr) {
        zremove(ptr);
        zinsert(new_ptr, file, func, line);
    }
    return new_ptr;
}
#define free(ptr) zfree(ptr)
#define calloc(cnt, sz) _zcalloc(cnt, sz,__FILE__,__func__,__LINE__)
#define malloc(sz) _zmalloc(sz,__FILE__,__func__,__LINE__)
#define realloc(ptr, new_size) _zrealloc(ptr, new_size,__FILE__,__func__,__LINE__)
#endif
#endif
#if !defined(_OPENCSTL_DEFINES_H)
#define _OPENCSTL_DEFINES_H
#if defined(_WIN32) || defined(_WIN64)
#define OPENCSTL_OS_WINDOWS
#elif defined(__linux__)
#define OPENCSTL_OS_LINUX
#elif defined(__APPLE__)
#define OPENCSTL_OS_OSX
#endif
#if defined(__clang__)
#define OPENCSTL_CC_CLANG
#elif defined(_MSC_VER)
#define OPENCSTL_CC_MSVC
#elif defined(__GNUC__)
#define OPENCSTL_CC_GCC
#endif
#define OPENCSTL_SET		    0
#define OPENCSTL_MAP		    1
#define OPENCSTL_VECTOR		    2
#define OPENCSTL_LIST		    3
#define OPENCSTL_DEQUE		    4
#define OPENCSTL_STACK		    5
#define OPENCSTL_QUEUE		    6
#define OPENCSTL_PRIORITY_QUEUE	7
#define OPENCSTL_UNORDERED_SET	8
#define OPENCSTL_UNORDERED_MAP	9
#define OPENCSTL_ARRAY          10
#if defined(OPENCSTL_OS_WINDOWS)
#include<Windows.h>
#endif
#if defined(__GNUC__) || defined(__clang__)
typedef long long __attribute__((__aligned__(1), __may_alias__)) _opencstl_ll_ua;
#elif defined(_MSC_VER)
typedef long long __unaligned _opencstl_ll_ua;
#else
typedef long long _opencstl_ll_ua;
#endif
#define OPENCSTL_NIDX(container,nidx) (((_opencstl_ll_ua*)*container)[(nidx)])
#define OPENCSTL_HEADER	(12)
#define NIDX_CTYPE	    (-12)
#define NIDX_HSIZE	    (-11)
#define NIDX_TSIZE	    (-10)
#define NIDX_LIST_NODE_SIZE	(3)
#define NIDX_TREE_NODE_SIZE	(5)
#define HEAP_PARENT(I)	    (((I)-1)>>1)
#define HEAP_LEFT(I)		(((I)<<1)+1)
#define HEAP_RIGHT(I)	    (((I)<<1)+2)
#if defined(_MSC_VER)
#   define ARGN(...)  INTERNAL_EXPAND_ARGS_PRIVATE(INTERNAL_ARGS_AUGMENTER(__VA_ARGS__))
#   define INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__
#   define INTERNAL_EXPAND(x) x
#   define INTERNAL_EXPAND_ARGS_PRIVATE(...) INTERNAL_EXPAND(INTERNAL_GET_ARG_COUNT_PRIVATE(__VA_ARGS__, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
#   define INTERNAL_GET_ARG_COUNT_PRIVATE(_1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, _11_, _12_, _13_, _14_, _15_, _16_, _17_, _18_, _19_, _20_, _21_, _22_, _23_, _24_, _25_, _26_, _27_, _28_, _29_, _30_, _31_, _32_, _33_, _34_, _35_, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, count, ...) count
#else
#   define ARGN(...) INTERNAL_GET_ARG_COUNT_PRIVATE(0, ## __VA_ARGS__, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#   define INTERNAL_GET_ARG_COUNT_PRIVATE(_0, _1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, _10_, _11_, _12_, _13_, _14_, _15_, _16_, _17_, _18_, _19_, _20_, _21_, _22_, _23_, _24_, _25_, _26_, _27_, _28_, _29_, _30_, _31_, _32_, _33_, _34_, _35_, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, _70, count, ...) count
#endif
#endif
#if defined(OCSTL_CC_MSVC)
#define cstl_value(iter, TYPE) \
(*(TYPE __unaligned *)((char *)(iter) + sizeof(*(iter))))
#else
#define cstl_value(iter, TYPE) \
(*(TYPE *)memcpy(&(TYPE){0}, (char *)(iter) + sizeof(*(iter)), sizeof(TYPE)))
#endif
#if defined(_WIN32) || defined(_WIN64)
#  define CSTL_USE_VAARG 0
#else
#  define CSTL_USE_VAARG 1
#endif
#if defined(_WIN32) || defined(_WIN64)
#define __cstl_va_start(V,C,beg)	va_start(V,C);beg=(void*)V;
#define __cstl_va_arg(PTR)	(PTR)
#define __cstl_va_arg_next(V)	(NULL)
#define __cstl_va_end(V)	va_end(V)
#else
#define __cstl_va_start(V,C,beg)	va_start(V,C)
#define __cstl_va_arg_next(V)	    va_arg((V),void*)
#define __cstl_va_end(V)	        va_end(V)
#endif
#define cstl_pop(container)	        _cstl_pop(&(container))
#define cstl_pop_back(container)	_cstl_pop_back(&(container))
#define cstl_pop_front(container)	_cstl_pop_front(&(container))
#define cstl_size(container)	    _cstl_size(&(container))
#define cstl_capacity(container)	_cstl_capacity(&(container))
#define cstl_next(iterator)	        _cstl_next(iterator)
#define cstl_prev(iterator)	        _cstl_prev(iterator)
#define cstl_begin(container)	    _cstl_begin(&(container))
#define cstl_rbegin(container)	    _cstl_rbegin(&(container))
#define cstl_end(container)	        _cstl_end(&(container))
#define cstl_rend(container)	    _cstl_rend(&(container))
#define cstl_clear(container)	    _cstl_clear(&(container))
#define cstl_empty(container)	    _cstl_empty(&(container))
#define cstl_free(container)	    _cstl_free(&(container))
#define _cstl_deque_type(container) (*(_opencstl_ll_ua *)((char*)*(void**)container + (ptrdiff_t)(NIDX_CTYPE) * (ptrdiff_t)sizeof(size_type64) + (OPENCSTL_NIDX(((void**)container), -1) + 1)))
#ifdef _MSC_VER
#pragma warning(disable:4047)
#pragma warning(disable:4477)
#pragma warning(disable:4313)
#elif defined(__GNUC__) || defined(__clang__)
#if !defined(__clang__)
#endif
#endif
#if defined(__GNUC__) || defined(__clang__)
#define _cstl_deref(P) (__extension__ ({ \
    __typeof__(*(P)) _cstl_rv; \
    __builtin_memcpy(&_cstl_rv, (const void *)(P), sizeof(_cstl_rv)); \
    _cstl_rv; \
}))
#else
#define _cstl_deref(P) (*(P))
#endif
#define _cstl_err_ptr (void*)(size_type64)0
#define cstl_front(C)	_cstl_deref((void**)(__is_deque((void**)&C)?\
_cstl_deque_type(&C)==OPENCSTL_DEQUE?(void*)(C):(_cstl_deque_type(&C)==OPENCSTL_QUEUE?(void*)(C):_cstl_err_ptr) :\
(OPENCSTL_NIDX(((void**)&C), NIDX_CTYPE)==OPENCSTL_VECTOR?(void*)(C):\
(OPENCSTL_NIDX(((void**)&C), NIDX_CTYPE)==OPENCSTL_LIST)?(void*)(*(void**)C):_cstl_err_ptr)))
#define cstl_back(C)	_cstl_deref((void**)(__is_deque((void**)&C)?\
_cstl_deque_type(&C)==OPENCSTL_DEQUE?(void*)(C+cstl_size(C)-1):(_cstl_deque_type(&C)==OPENCSTL_QUEUE?(void*)(C+cstl_size(C)-1):_cstl_err_ptr) :\
(OPENCSTL_NIDX(((void**)&C), NIDX_CTYPE)==OPENCSTL_VECTOR?(void*)(C+cstl_size(C)-1):\
(OPENCSTL_NIDX(((void**)&C), NIDX_CTYPE)==OPENCSTL_LIST)?(void*)((void**)C)[-2]:_cstl_err_ptr)))
#if defined(__GNUC__) || defined(__clang__)
#endif
#define OPENCSTL_DEQUE_NIDX(container, nidx) (*(_opencstl_ll_ua *)((char*)*(void**)container + (ptrdiff_t)(nidx) * (ptrdiff_t)sizeof(size_type64) + (OPENCSTL_NIDX(((void**)container), -1) + 1)))
#define _cstl_stack_top(container)   *container[OPENCSTL_DEQUE_NIDX(container, -2) -1]
#define cstl_top(container)   __is_deque((void**)&container)?\
OPENCSTL_DEQUE_NIDX(&container, NIDX_CTYPE) == OPENCSTL_STACK ?_cstl_stack_top(&container) : (container[0]):\
(OPENCSTL_NIDX(((void**)&container), NIDX_CTYPE)==OPENCSTL_PRIORITY_QUEUE?(*container):(container[0]))
#define cstl_reserve(container,n)	_cstl_reserve(&(container),n)
#if defined(_WIN32) || defined(_WIN64)
#define cstl_push(container,...)	_cstl_push(&(container),__VA_ARGS__)
#define cstl_push_back(container,...)	_cstl_push_back(&(container),__VA_ARGS__)
#define cstl_push_front(container,...)	_cstl_push_front(&(container),__VA_ARGS__)
#define cstl_insert(container,...)	_cstl_insert(&(container),ARGN(__VA_ARGS__),__VA_ARGS__)
#define cstl_erase(container,...)	_cstl_erase(&(container),ARGN(__VA_ARGS__),__VA_ARGS__)
#define cstl_resize(container,...)	_cstl_resize(&(container),ARGN(__VA_ARGS__),__VA_ARGS__)
#define cstl_assign(container,...)	_cstl_assign(&(container),ARGN(__VA_ARGS__),__VA_ARGS__)
#define cstl_find(container,...)	_cstl_find(&(container),ARGN(__VA_ARGS__),__VA_ARGS__)
#define cstl_shrink_to_fit(container) _cstl_shrink_to_fit(&(container))
#define cstl_max_size(container) _cstl_max_size(&container)
#define cstl_reverse(container) _cstl_reverse(&(container))
#define cstl_count_if(container,...)	_cstl_count_if(&(container),__VA_ARGS__)
#define cstl_lower_bound(container,...)	_cstl_lower_bound(&(container),ARGN(__VA_ARGS__),__VA_ARGS__)
#define cstl_upper_bound(container,...)	_cstl_upper_bound(&(container),ARGN(__VA_ARGS__),__VA_ARGS__)
#define cstl_max_element(C, ...) ocstl_min_max_element(&(C), ##__VA_ARGS__, 1LL, NULL)
#define cstl_min_element(C, ...) ocstl_min_max_element(&(C), ##__VA_ARGS__, 0LL, NULL)
#elif defined(__linux__) || defined(__APPLE__)
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
#define _CSTL_TYPEOF(x)  typeof(x)
#elif defined(__cplusplus)
#define _CSTL_TYPEOF(x)  decltype(x)
#elif defined(__GNUC__) || defined(__clang__) || defined(__TINYC__)
#define _CSTL_TYPEOF(x)  __typeof__(x)
#else
#define _CSTL_TYPEOF(x)  void*
#endif
#define cstl_push_back(C,...) _linux_cstl_push_back(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,__VA_ARGS__)
#define _linux_cstl_push_back(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_push_back ## _ ## N
#define _cstl_push_back_0(C)    {_CSTL_TYPEOF(&C) __0=&C;_cstl_push_back( __0);}
#define _cstl_push_back_1(C,_1)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_push_back( __0,&__1);}
#define _cstl_push_back_2(C,_1,_2)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_push_back( __0,&__1,&__2);}
#define _cstl_push_back_3(C,_1,_2,_3)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_push_back( __0,&__1,&__2,&__3);}
#define _cstl_push_back_4(C,_1,_2,_3,_4)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_push_back( __0,&__1,&__2,&__3,&__4);}
#define _cstl_push_back_5(C,_1,_2,_3,_4,_5)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_push_back( __0,&__1,&__2,&__3,&__4,&__5);}
#define _cstl_push_back_6(C,_1,_2,_3,_4,_5,_6)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_push_back( __0,&__1,&__2,&__3,&__4,&__5,&__6);}
#define _cstl_push_back_7(C,_1,_2,_3,_4,_5,_6,_7)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_push_back( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}
#define _cstl_push_back_8(C,_1,_2,_3,_4,_5,_6,_7,_8)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_push_back( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}
#define _cstl_push_back_9(C,_1,_2,_3,_4,_5,_6,_7,_8,_9)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_push_back( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}
#define _cstl_push_back_10(C,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_push_back( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}
#define cstl_push_front(C,...) _linux_cstl_push_front(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,__VA_ARGS__)
#define _linux_cstl_push_front(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_push_front ## _ ## N
#define _cstl_push_front_0(C)    {_CSTL_TYPEOF(&C) __0=&C;_cstl_push_front( __0);}
#define _cstl_push_front_1(C,_1)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_push_front( __0,&__1);}
#define _cstl_push_front_2(C,_1,_2)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_push_front( __0,&__1,&__2);}
#define _cstl_push_front_3(C,_1,_2,_3)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_push_front( __0,&__1,&__2,&__3);}
#define _cstl_push_front_4(C,_1,_2,_3,_4)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_push_front( __0,&__1,&__2,&__3,&__4);}
#define _cstl_push_front_5(C,_1,_2,_3,_4,_5)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_push_front( __0,&__1,&__2,&__3,&__4,&__5);}
#define _cstl_push_front_6(C,_1,_2,_3,_4,_5,_6)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_push_front( __0,&__1,&__2,&__3,&__4,&__5,&__6);}
#define _cstl_push_front_7(C,_1,_2,_3,_4,_5,_6,_7)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_push_front( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}
#define _cstl_push_front_8(C,_1,_2,_3,_4,_5,_6,_7,_8)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_push_front( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}
#define _cstl_push_front_9(C,_1,_2,_3,_4,_5,_6,_7,_8,_9)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_push_front( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}
#define _cstl_push_front_10(C,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_push_front( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}
#define cstl_insert(C,...) _linux_cstl_insert(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,ARGN(__VA_ARGS__),__VA_ARGS__)
#define _linux_cstl_insert(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_insert ## _ ## N
#define _cstl_insert_0(C,argc)    {_CSTL_TYPEOF(&C) __0=&C;_cstl_insert( __0,argc);}
#define _cstl_insert_1(C,argc,_1)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_insert( __0,argc,&__1);}
#define _cstl_insert_2(C,argc,_1,_2)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_insert( __0,argc,&__1,&__2);}
#define _cstl_insert_3(C,argc,_1,_2,_3)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_insert( __0,argc,&__1,&__2,&__3);}
#define _cstl_insert_4(C,argc,_1,_2,_3,_4)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_insert( __0,argc,&__1,&__2,&__3,&__4);}
#define _cstl_insert_5(C,argc,_1,_2,_3,_4,_5)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_insert( __0,argc,&__1,&__2,&__3,&__4,&__5);}
#define _cstl_insert_6(C,argc,_1,_2,_3,_4,_5,_6)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_insert( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6);}
#define _cstl_insert_7(C,argc,_1,_2,_3,_4,_5,_6,_7)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_insert( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}
#define _cstl_insert_8(C,argc,_1,_2,_3,_4,_5,_6,_7,_8)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_insert( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}
#define _cstl_insert_9(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_insert( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}
#define _cstl_insert_10(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_insert( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}
#define cstl_erase(C,...) _linux_cstl_erase(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,ARGN(__VA_ARGS__),__VA_ARGS__)
#define _linux_cstl_erase(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_erase ## _ ## N
#define _cstl_erase_0(C,argc)    {_CSTL_TYPEOF(&C) __0=&C;_cstl_erase( __0,argc);}
#define _cstl_erase_1(C,argc,_1)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_erase( __0,argc,&__1);}
#define _cstl_erase_2(C,argc,_1,_2)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_erase( __0,argc,&__1,&__2);}
#define _cstl_erase_3(C,argc,_1,_2,_3)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_erase( __0,argc,&__1,&__2,&__3);}
#define _cstl_erase_4(C,argc,_1,_2,_3,_4)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_erase( __0,argc,&__1,&__2,&__3,&__4);}
#define _cstl_erase_5(C,argc,_1,_2,_3,_4,_5)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_erase( __0,argc,&__1,&__2,&__3,&__4,&__5);}
#define _cstl_erase_6(C,argc,_1,_2,_3,_4,_5,_6)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_erase( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6);}
#define _cstl_erase_7(C,argc,_1,_2,_3,_4,_5,_6,_7)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_erase( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}
#define _cstl_erase_8(C,argc,_1,_2,_3,_4,_5,_6,_7,_8)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_erase( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}
#define _cstl_erase_9(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_erase( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}
#define _cstl_erase_10(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_erase( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}
#define cstl_resize(C,...) _linux_cstl_resize(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,ARGN(__VA_ARGS__),__VA_ARGS__)
#define _linux_cstl_resize(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_resize ## _ ## N
#define _cstl_resize_0(C,argc)    {_CSTL_TYPEOF(&C) __0=&C;_cstl_resize( __0,argc);}
#define _cstl_resize_1(C,argc,_1)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_resize( __0,argc,&__1);}
#define _cstl_resize_2(C,argc,_1,_2)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_resize( __0,argc,&__1,&__2);}
#define _cstl_resize_3(C,argc,_1,_2,_3)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_resize( __0,argc,&__1,&__2,&__3);}
#define _cstl_resize_4(C,argc,_1,_2,_3,_4)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_resize( __0,argc,&__1,&__2,&__3,&__4);}
#define _cstl_resize_5(C,argc,_1,_2,_3,_4,_5)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_resize( __0,argc,&__1,&__2,&__3,&__4,&__5);}
#define _cstl_resize_6(C,argc,_1,_2,_3,_4,_5,_6)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_resize( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6);}
#define _cstl_resize_7(C,argc,_1,_2,_3,_4,_5,_6,_7)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_resize( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}
#define _cstl_resize_8(C,argc,_1,_2,_3,_4,_5,_6,_7,_8)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_resize( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}
#define _cstl_resize_9(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_resize( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}
#define _cstl_resize_10(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_resize( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}
#define cstl_assign(C,...) _linux_cstl_assign(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,ARGN(__VA_ARGS__),__VA_ARGS__)
#define _linux_cstl_assign(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_assign ## _ ## N
#define _cstl_assign_0(C,argc)    {_CSTL_TYPEOF(&C) __0=&C;_cstl_assign( __0,argc);}
#define _cstl_assign_1(C,argc,_1)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_assign( __0,argc,&__1);}
#define _cstl_assign_2(C,argc,_1,_2)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_assign( __0,argc,&__1,&__2);}
#define _cstl_assign_3(C,argc,_1,_2,_3)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_assign( __0,argc,&__1,&__2,&__3);}
#define _cstl_assign_4(C,argc,_1,_2,_3,_4)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_assign( __0,argc,&__1,&__2,&__3,&__4);}
#define _cstl_assign_5(C,argc,_1,_2,_3,_4,_5)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_assign( __0,argc,&__1,&__2,&__3,&__4,&__5);}
#define _cstl_assign_6(C,argc,_1,_2,_3,_4,_5,_6)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_assign( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6);}
#define _cstl_assign_7(C,argc,_1,_2,_3,_4,_5,_6,_7)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_assign( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}
#define _cstl_assign_8(C,argc,_1,_2,_3,_4,_5,_6,_7,_8)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_assign( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}
#define _cstl_assign_9(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_assign( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}
#define _cstl_assign_10(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_assign( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}
#define cstl_find(C,...) _linux_cstl_find(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,ARGN(__VA_ARGS__),__VA_ARGS__)
#define _linux_cstl_find(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_find ## _ ## N
#define _cstl_find_0(C,argc)    ({_CSTL_TYPEOF(&C) __0=&C;_cstl_find( __0,argc);})
#define _cstl_find_1(C,argc,_1)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_find( __0,argc,&__1);}))
#define _cstl_find_2(C,argc,_1,_2)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_find( __0,argc,&__1,&__2);}))
#define _cstl_find_3(C,argc,_1,_2,_3)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_find( __0,argc,&__1,&__2,&__3);}))
#define _cstl_find_4(C,argc,_1,_2,_3,_4)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_find( __0,argc,&__1,&__2,&__3,&__4);}))
#define _cstl_find_5(C,argc,_1,_2,_3,_4,_5)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_find( __0,argc,&__1,&__2,&__3,&__4,&__5);}))
#define _cstl_find_6(C,argc,_1,_2,_3,_4,_5,_6)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_find( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6);}))
#define _cstl_find_7(C,argc,_1,_2,_3,_4,_5,_6,_7)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_find( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}))
#define _cstl_find_8(C,argc,_1,_2,_3,_4,_5,_6,_7,_8)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_find( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}))
#define _cstl_find_9(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_find( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}))
#define _cstl_find_10(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_find( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}))
#define cstl_push(C,...) _linux_cstl_push(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,__VA_ARGS__)
#define _linux_cstl_push(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_push ## _ ## N
#define _cstl_push_0(C)    {_CSTL_TYPEOF(&C) __0=&C;_cstl_push( __0);}
#define _cstl_push_1(C,_1)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_push( __0,&__1);}
#define _cstl_push_2(C,_1,_2)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_push( __0,&__1,&__2);}
#define _cstl_push_3(C,_1,_2,_3)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_push( __0,&__1,&__2,&__3);}
#define _cstl_push_4(C,_1,_2,_3,_4)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_push( __0,&__1,&__2,&__3,&__4);}
#define _cstl_push_5(C,_1,_2,_3,_4,_5)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_push( __0,&__1,&__2,&__3,&__4,&__5);}
#define _cstl_push_6(C,_1,_2,_3,_4,_5,_6)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_push( __0,&__1,&__2,&__3,&__4,&__5,&__6);}
#define _cstl_push_7(C,_1,_2,_3,_4,_5,_6,_7)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_push( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}
#define _cstl_push_8(C,_1,_2,_3,_4,_5,_6,_7,_8)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_push( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}
#define _cstl_push_9(C,_1,_2,_3,_4,_5,_6,_7,_8,_9)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_push( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}
#define _cstl_push_10(C,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_push( __0,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}
#define cstl_max_size(container) _cstl_max_size(&container)
#define cstl_shrink_to_fit(container) _cstl_shrink_to_fit(&(container))
#define cstl_reverse(container) _cstl_reverse(&(container))
#define cstl_count(C,...) _linux_cstl_count(C,__VA_ARGS__, 5, 4, 3, 2, 1, 0)(C,__VA_ARGS__)
#define _linux_cstl_count(C,_1, _2, _3, _4, _5, N, ...) _cstl_count ## _ ## N
#define _cstl_count_0(C)    (({_CSTL_TYPEOF(&C) __0=&C;_cstl_count( __0);}))
#define _cstl_count_1(C,_1)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_count( __0,&__1);}))
#define _cstl_count_2(C,_1,_2)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_count( __0,&__1,&__2);}))
#define _cstl_count_3(C,_1,_2,_3)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_count( __0,&__1,&__2,&__3);}))
#define _cstl_count_4(C,_1,_2,_3,_4)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_count( __0,&__1,&__2,&__3,&__4);}))
#define _cstl_count_5(C,_1,_2,_3,_4,_5)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_count( __0,&__1,&__2,&__3,&__4,&__5);}))
#define cstl_count_if(C,...) _linux_cstl_count_if(C,__VA_ARGS__, 5, 4, 3, 2, 1, 0)(C,__VA_ARGS__)
#define _linux_cstl_count_if(C,_1, _2, _3, _4, _5, N, ...) _cstl_count_if ## _ ## N
#define _cstl_count_if_0(C)    (({_CSTL_TYPEOF(&C) __0=&C;_cstl_count_if( __0);}))
#define _cstl_count_if_1(C,_1)    (({_CSTL_TYPEOF(&C) __0=&C;_cstl_count_if( __0,_1);}))
#define _cstl_count_if_2(C,_1,_2)    (({_CSTL_TYPEOF(&C) __0=&C;_cstl_count_if( __0,_1,_2);}))
#define _cstl_count_if_3(C,_1,_2,_3)    (({_CSTL_TYPEOF(&C) __0=&C;_cstl_count_if( __0,_1,_2,_3);}))
#define _cstl_count_if_4(C,_1,_2,_3,_4)    (({_CSTL_TYPEOF(&C) __0=&C;_cstl_count_if( __0,_1,_2,_3,_4);}))
#define _cstl_count_if_5(C,_1,_2,_3,_4,_5)    (({_CSTL_TYPEOF(&C) __0=&C;_cstl_count_if( __0,_1,_2,_3,_4,_5);}))
#define cstl_lower_bound(C,...) _linux_cstl_lower_bound(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,ARGN(__VA_ARGS__),__VA_ARGS__)
#define _linux_cstl_lower_bound(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_lower_bound ## _ ## N
#define _cstl_lower_bound_0(C,argc)    (({_CSTL_TYPEOF(&C) __0=&C;_cstl_lower_bound( __0,argc);}))
#define _cstl_lower_bound_1(C,argc,_1)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_lower_bound( __0,argc,&__1);}))
#define _cstl_lower_bound_2(C,argc,_1,_2)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_lower_bound( __0,argc,&__1,&__2);}))
#define _cstl_lower_bound_3(C,argc,_1,_2,_3)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_lower_bound( __0,argc,&__1,&__2,&__3);}))
#define _cstl_lower_bound_4(C,argc,_1,_2,_3,_4)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_lower_bound( __0,argc,&__1,&__2,&__3,&__4);}))
#define _cstl_lower_bound_5(C,argc,_1,_2,_3,_4,_5)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_lower_bound( __0,argc,&__1,&__2,&__3,&__4,&__5);}))
#define _cstl_lower_bound_6(C,argc,_1,_2,_3,_4,_5,_6)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_lower_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6);}))
#define _cstl_lower_bound_7(C,argc,_1,_2,_3,_4,_5,_6,_7)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_lower_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}))
#define _cstl_lower_bound_8(C,argc,_1,_2,_3,_4,_5,_6,_7,_8)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_lower_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}))
#define _cstl_lower_bound_9(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_lower_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}))
#define _cstl_lower_bound_10(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_lower_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}))
#define cstl_upper_bound(C,...) _linux_cstl_upper_bound(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,ARGN(__VA_ARGS__),__VA_ARGS__)
#define _linux_cstl_upper_bound(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_upper_bound ## _ ## N
#define _cstl_upper_bound_0(C,argc)    (({_CSTL_TYPEOF(&C) __0=&C;_cstl_upper_bound( __0,argc);}))
#define _cstl_upper_bound_1(C,argc,_1)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_upper_bound( __0,argc,&__1);}))
#define _cstl_upper_bound_2(C,argc,_1,_2)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_upper_bound( __0,argc,&__1,&__2);}))
#define _cstl_upper_bound_3(C,argc,_1,_2,_3)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_upper_bound( __0,argc,&__1,&__2,&__3);}))
#define _cstl_upper_bound_4(C,argc,_1,_2,_3,_4)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_upper_bound( __0,argc,&__1,&__2,&__3,&__4);}))
#define _cstl_upper_bound_5(C,argc,_1,_2,_3,_4,_5)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_upper_bound( __0,argc,&__1,&__2,&__3,&__4,&__5);}))
#define _cstl_upper_bound_6(C,argc,_1,_2,_3,_4,_5,_6)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_upper_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6);}))
#define _cstl_upper_bound_7(C,argc,_1,_2,_3,_4,_5,_6,_7)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_upper_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}))
#define _cstl_upper_bound_8(C,argc,_1,_2,_3,_4,_5,_6,_7,_8)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_upper_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}))
#define _cstl_upper_bound_9(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_upper_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}))
#define _cstl_upper_bound_10(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    (({_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_upper_bound( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}))
#endif
#if defined(_WIN32) || defined(_WIN64)
#define SELECT_ANY	__declspec(selectany)
#elif defined(__linux__) || defined(__APPLE__)
#define SELECT_ANY	__attribute__((weak))
#endif
#define OPENCSTL_FUNC	static
#define USE_CSTL_FUNC
#ifndef OPENCSTL_STRING_H
#define OPENCSTL_STRING_H
#ifndef OPENCSTL_VERIFY_H
#define OPENCSTL_VERIFY_H
#include <assert.h>
#define verify(EXPR) do { if(!(EXPR)) __verify(#EXPR,__FILE__,__LINE__); } while(0)
static int __verify(char *expression, char *file, int line) {
    logging.error("Verification failed: %s, file %s, line %d",
                  expression, file, line);
    fflush(stdout);
    fflush(stderr);
    abort();
}
#define fault(STR) do{_fault((STR),__FILE__,__LINE__);}while(0)
static void _fault(char *str, char *file, int line) {
    logging.error("Fault: %s, file %s, line %d", str, file, line);
    fflush(stdout);
    fflush(stderr);
    exit(-1);
}
#endif
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdbool.h>
static char *__cstl_string_substr(char *src, int pos, int len) {
    verify(strlen(src) >= pos + len);
    char *ret = (char *) calloc(len + 1, sizeof(char));
    memcpy(ret, src + pos, len);
    return ret;
}
static char **__cstl_string_split(const char *src, const char *sep, int *n) {
    int len = (int) strlen(src);
    int sep_len = (int) strlen(sep);
    if (sep_len == 0) {
        char **ret = (char **) malloc(sizeof(char *) + (len + 1));
        char *buf = (char *) ret + sizeof(char *);
        memcpy(buf, src, len + 1);
        ret[0] = buf;
        *n = 1;
        return ret;
    }
    int count = 1;
    const char *p = src;
    while ((p = strstr(p, sep)) != NULL) {
        count++;
        p += sep_len;
    }
    char **ret = (char **) malloc(count * sizeof(char *) + (len + 1));
    char *buf = (char *) ret + count * sizeof(char *);
    memcpy(buf, src, len + 1);
    int idx = 0;
    ret[idx++] = buf;
    char *s = buf;
    while ((s = strstr(s, sep)) != NULL) {
        *s = '\0';
        s += sep_len;
        ret[idx++] = s;
    }
    *n = count;
    return ret;
}
static char *__cstl_string_replace(char *src, char *from, char *to) {
    int len = strlen(src);
    int from_len = strlen(from);
    int to_len = strlen(to);
    int count = 0;
    char *p = src;
    while ((p = strstr(p, from)) != NULL) {
        count++;
        p += from_len;
    }
    char *ret = (char *) calloc(len + count * (to_len - from_len) + 1, 1);
    char *dst = ret;
    p = src;
    while (*p) {
        if (strncmp(p, from, from_len) == 0) {
            memcpy(dst, to, to_len);
            dst += to_len;
            p += from_len;
        } else {
            *dst++ = *p++;
        }
    }
    *dst = '\0';
    return ret;
}
static char *__cstl_string_ltrim(const char *src) {
    const char *p = src;
    while (*p && isspace((unsigned char) *p)) p++;
    size_type64 len = strlen(p);
    char *ret = (char *) malloc(len + 1);
    memcpy(ret, p, len + 1);
    return ret;
}
static char *__cstl_string_rtrim(const char *src) {
    size_type64 len = strlen(src);
    while (len > 0 && isspace((unsigned char) src[len - 1])) len--;
    char *ret = (char *) malloc(len + 1);
    memcpy(ret, src, len);
    ret[len] = '\0';
    return ret;
}
static char *__cstl_string_trim(const char *src) {
    const char *begin = src;
    while (*begin && isspace((unsigned char) *begin)) begin++;
    const char *end = src + strlen(src);
    while (end > begin && isspace((unsigned char) *(end - 1))) end--;
    size_type64 len = end - begin;
    char *ret = (char *) malloc(len + 1);
    memcpy(ret, begin, len);
    ret[len] = '\0';
    return ret;
}
static char *__cstl_string_to_upper(const char *src) {
    size_type64 len = strlen(src);
    char *ret = (char *) malloc(len + 1);
    for (size_type64 i = 0; i < len; i++) ret[i] = (char) toupper((unsigned char) src[i]);
    ret[len] = '\0';
    return ret;
}
static char *__cstl_string_to_lower(const char *src) {
    size_type64 len = strlen(src);
    char *ret = (char *) malloc(len + 1);
    for (size_type64 i = 0; i < len; i++) ret[i] = (char) tolower((unsigned char) src[i]);
    ret[len] = '\0';
    return ret;
}
static bool __cstl_string_starts_with(const char *src, const char *prefix) {
    size_type64 plen = strlen(prefix);
    return strncmp(src, prefix, plen) == 0;
}
static bool __cstl_string_ends_with(const char *src, const char *suffix) {
    size_type64 slen = strlen(src);
    size_type64 flen = strlen(suffix);
    if (flen > slen) return false;
    return memcmp(src + slen - flen, suffix, flen) == 0;
}
static int __cstl_string_count(const char *src, const char *sub) {
    int count = 0;
    size_type64 sub_len = strlen(sub);
    if (sub_len == 0) return 0;
    const char *p = src;
    while ((p = strstr(p, sub)) != NULL) {
        count++;
        p += sub_len;
    }
    return count;
}
static char *__cstl_string_join(char **parts, int n, const char *delim) {
    if (n <= 0) {
        char *empty = (char *) malloc(1);
        *empty = '\0';
        return empty;
    }
    size_type64 dlen = strlen(delim);
    size_type64 total = 0;
    for (int i = 0; i < n; i++) total += strlen(parts[i]);
    total += dlen * (n - 1) + 1;
    char *ret = (char *) malloc(total);
    char *dst = ret;
    for (int i = 0; i < n; i++) {
        if (i > 0) {
            memcpy(dst, delim, dlen);
            dst += dlen;
        }
        size_type64 len = strlen(parts[i]);
        memcpy(dst, parts[i], len);
        dst += len;
    }
    *dst = '\0';
    return ret;
}
static char *__cstl_string_concat(const char *a, const char *b) {
    size_type64 alen = strlen(a);
    size_type64 blen = strlen(b);
    char *ret = (char *) malloc(alen + blen + 1);
    memcpy(ret, a, alen);
    memcpy(ret + alen, b, blen + 1);
    return ret;
}
static char *__cstl_string_reverse(const char *src) {
    size_type64 len = strlen(src);
    char *ret = (char *) malloc(len + 1);
    for (size_type64 i = 0; i < len; i++) ret[i] = src[len - 1 - i];
    ret[len] = '\0';
    return ret;
}
static bool __cstl_string_is_digit(const char *src) {
    if (!*src) return false;
    for (const char *p = src; *p; p++)
        if (!isdigit((unsigned char) *p)) return false;
    return true;
}
static bool __cstl_string_is_alpha(const char *src) {
    if (!*src) return false;
    for (const char *p = src; *p; p++)
        if (!isalpha((unsigned char) *p)) return false;
    return true;
}
static bool __cstl_string_is_alnum(const char *src) {
    if (!*src) return false;
    for (const char *p = src; *p; p++)
        if (!isalnum((unsigned char) *p)) return false;
    return true;
}
static bool __cstl_string_is_space(const char *src) {
    if (!*src) return false;
    for (const char *p = src; *p; p++)
        if (!isspace((unsigned char) *p)) return false;
    return true;
}
static int *__cstl_string_kmp(char *src, char *pattern, int *count) {
    if (count != NULL) *count = 0;
    if (src == NULL || pattern == NULL || count == NULL) {
        return NULL;
    }
    size_type64 n = strlen(src);
    size_type64 m = strlen(pattern);
    if (m == 0 || n < m) {
        return NULL;
    }
    int *lps = (int *) malloc(sizeof(int) * m);
    if (lps == NULL) return NULL;
    lps[0] = 0;
    size_type64 len = 0;
    size_type64 i = 1;
    while (i < m) {
        if (pattern[i] == pattern[len]) {
            len++;
            lps[i] = (int) len;
            i++;
        } else {
            if (len != 0) {
                len = lps[len - 1];
            } else {
                lps[i] = 0;
                i++;
            }
        }
    }
    size_type64 capacity = 16;
    int *matches = (int *) malloc(sizeof(int) * capacity);
    if (matches == NULL) {
        free(lps);
        return NULL;
    }
    size_type64 match_count = 0;
    size_type64 j = 0;
    i = 0;
    while (i < n) {
        if (pattern[j] == src[i]) {
            i++;
            j++;
            if (j == m) {
                if (match_count >= capacity) {
                    capacity *= 2;
                    int *temp = (int *) realloc(matches, sizeof(int) * capacity);
                    if (temp == NULL) {
                        free(matches);
                        free(lps);
                        return NULL;
                    }
                    matches = temp;
                }
                matches[match_count] = (int) (i - j);
                match_count++;
                j = lps[j - 1];
            }
        } else {
            if (j != 0) {
                j = lps[j - 1];
            } else {
                i++;
            }
        }
    }
    free(lps);
    *count = (int) match_count;
    if (match_count == 0) {
        free(matches);
        return NULL;
    }
    int *result = (int *) realloc(matches, sizeof(int) * match_count);
    return (result != NULL) ? result : matches;
}
typedef char *(*string_substr_fn)(char *, int, int);
typedef char **(*string_split_fn)(const char *, const char *, int *);
typedef char *(*string_replace_fn)(char *, char *, char *);
typedef char *(*string_unary_fn)(const char *);
typedef bool (*string_match_fn)(const char *, const char *);
typedef int (*string_count_fn)(const char *, const char *);
typedef char *(*string_join_fn)(char **, int, const char *);
typedef char *(*string_concat_fn)(const char *, const char *);
typedef bool (*string_pred_fn)(const char *);
typedef int * (*string_kmp_fn)(char *src, char *pattern, int *count);
typedef struct {
    string_substr_fn substr;
    string_split_fn split;
    string_replace_fn replace;
    string_unary_fn ltrim;
    string_unary_fn rtrim;
    string_unary_fn trim;
    string_unary_fn to_upper;
    string_unary_fn to_lower;
    string_match_fn starts_with;
    string_match_fn ends_with;
    string_count_fn count_str;
    string_join_fn join;
    string_concat_fn concat;
    string_unary_fn reverse;
    string_pred_fn is_digit;
    string_pred_fn is_alpha;
    string_pred_fn is_alnum;
    string_pred_fn is_space;
    string_kmp_fn kmp;
} __STRING;
static __STRING string = {
    __cstl_string_substr,
    __cstl_string_split,
    __cstl_string_replace,
    __cstl_string_ltrim,
    __cstl_string_rtrim,
    __cstl_string_trim,
    __cstl_string_to_upper,
    __cstl_string_to_lower,
    __cstl_string_starts_with,
    __cstl_string_ends_with,
    __cstl_string_count,
    __cstl_string_join,
    __cstl_string_concat,
    __cstl_string_reverse,
    __cstl_string_is_digit,
    __cstl_string_is_alpha,
    __cstl_string_is_alnum,
    __cstl_string_is_space,
    __cstl_string_kmp
};
#endif
#if !defined(_OPENCSTL_DEQUE_H)
#define _OPENCSTL_DEQUE_H
#if !defined(_OPENCSTL_VAN_EMDE_BOAS_TREE_H)
#define _OPENCSTL_VAN_EMDE_BOAS_TREE_H
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <inttypes.h>
#include <string.h>
#include <stdbool.h>
typedef uintptr_t u64;
#define VEB_EMPTY   (~(u64)0)
#define HM_INIT_CAP 16
typedef struct {
    u64 key;
    void *val;
    int used;
} HMEntry;
typedef struct {
    HMEntry *e;
    size_type64 cap, size;
} HashMap;
static u64 hm_hash(u64 k) {
    k = (k ^ (k >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
    k = (k ^ (k >> 27)) * UINT64_C(0x94d049bb133111eb);
    return k ^ (k >> 31);
}
static HashMap *hm_new(void) {
    HashMap *h = (HashMap *) calloc(1, sizeof(HashMap));
    h->cap = HM_INIT_CAP;
    h->e = (HMEntry *) calloc(h->cap, sizeof(HMEntry));
    return h;
}
static void hm_free(HashMap *h) {
    free(h->e);
    free(h);
}
static void hm_set(HashMap *h, u64 key, void *val);
static void hm_grow(HashMap *h) {
    size_type64 oc = h->cap;
    HMEntry *oe = h->e;
    h->cap = oc * 2;
    h->e = (HMEntry *) calloc(h->cap, sizeof(HMEntry));
    h->size = 0;
    for (size_type64 i = 0; i < oc; i++)
        if (oe[i].used) hm_set(h, oe[i].key, oe[i].val);
    free(oe);
}
static void hm_set(HashMap *h, u64 k, void *v) {
    if (h->size * 2 >= h->cap) hm_grow(h);
    size_type64 i = (size_type64) (hm_hash(k) % h->cap);
    while (h->e[i].used && h->e[i].key != k)
        i = (i + 1) % h->cap;
    if (!h->e[i].used) h->size++;
    h->e[i] = (HMEntry){k, v, 1};
}
static void *hm_get(const HashMap *h, u64 k) {
    size_type64 i = (size_type64) (hm_hash(k) % h->cap);
    while (h->e[i].used) {
        if (h->e[i].key == k) return h->e[i].val;
        i = (i + 1) % h->cap;
    }
    return NULL;
}
static void hm_del(HashMap *h, u64 k) {
    size_type64 i = (size_type64) (hm_hash(k) % h->cap);
    while (h->e[i].used && h->e[i].key != k)
        i = (i + 1) % h->cap;
    if (!h->e[i].used) return;
    h->e[i].used = 0;
    h->size--;
    size_type64 j = (i + 1) % h->cap;
    while (h->e[j].used) {
        HMEntry t = h->e[j];
        h->e[j].used = 0;
        h->size--;
        hm_set(h, t.key, t.val);
        j = (j + 1) % h->cap;
    }
}
typedef struct VEB {
    int bits;
    u64 min;
    u64 max;
    struct VEB *sum;
    HashMap *cls;
} VEB;
static int lo_b(int b) { return b / 2; }
static int hi_b(int b) { return b - b / 2; }
static u64 vhi(u64 x, int b) { return x >> lo_b(b); }
static u64 vlo(u64 x, int b) { return x & (((u64) 1 << lo_b(b)) - 1); }
static u64 vidx(u64 h, u64 l, int b) { return (h << lo_b(b)) | l; }
static VEB *veb_new(int bits) {
    VEB *v = (VEB *) calloc(1, sizeof(VEB));
    v->bits = bits;
    v->min = VEB_EMPTY;
    v->max = VEB_EMPTY;
    if (bits > 1) v->cls = hm_new();
    return v;
}
static void veb_free(VEB *v);
static void cls_free_all(HashMap *hm) {
    for (size_type64 i = 0; i < hm->cap; i++)
        if (hm->e[i].used) veb_free((VEB *) hm->e[i].val);
    hm_free(hm);
}
static void veb_free(VEB *v) {
    if (!v) return;
    if (v->bits > 1) {
        veb_free(v->sum);
        if (v->cls) cls_free_all(v->cls);
    }
    free(v);
}
static int veb_empty(const VEB *v) { return v->min == VEB_EMPTY; }
static VEB *cls_get(VEB *v, u64 h) { return (VEB *) hm_get(v->cls, h); }
static VEB *cls_or_new(VEB *v, u64 h) {
    VEB *c = (VEB *) hm_get(v->cls, h);
    if (!c) {
        c = veb_new(lo_b(v->bits));
        hm_set(v->cls, h, c);
    }
    return c;
}
static VEB *sum_or_new(VEB *v) {
    if (!v->sum) v->sum = veb_new(hi_b(v->bits));
    return v->sum;
}
static void veb_ins(VEB *v, u64 x) {
    if (veb_empty(v)) {
        v->min = v->max = x;
        return;
    }
    if (x < v->min) {
        u64 t = v->min;
        v->min = x;
        x = t;
    }
    if (v->bits == 1) {
        if (x > v->max) v->max = x;
        return;
    }
    u64 h = vhi(x, v->bits), l = vlo(x, v->bits);
    VEB *c = cls_or_new(v, h);
    if (veb_empty(c)) veb_ins(sum_or_new(v), h);
    veb_ins(c, l);
    if (x > v->max) v->max = x;
}
static void veb_del(VEB *v, u64 x) {
    if (v->min == v->max) {
        v->min = v->max = VEB_EMPTY;
        return;
    }
    if (v->bits == 1) {
        v->min = v->max = (x == 0) ? 1 : 0;
        return;
    }
    if (x == v->min) {
        if (!v->sum || veb_empty(v->sum)) {
            v->min = v->max = VEB_EMPTY;
            return;
        }
        u64 fh = v->sum->min;
        VEB *fc = cls_get(v, fh);
        v->min = x = vidx(fh, fc->min, v->bits);
    }
    u64 h = vhi(x, v->bits), l = vlo(x, v->bits);
    VEB *c = cls_get(v, h);
    if (!c) return;
    veb_del(c, l);
    if (veb_empty(c)) {
        hm_del(v->cls, h);
        veb_free(c);
        if (v->sum) veb_del(v->sum, h);
        if (x == v->max) {
            if (!v->sum || veb_empty(v->sum)) v->max = v->min;
            else {
                u64 lh = v->sum->max;
                VEB *lc = cls_get(v, lh);
                v->max = vidx(lh, lc->max, v->bits);
            }
        }
    } else if (x == v->max) {
        v->max = vidx(h, c->max, v->bits);
    }
}
static u64 veb_pred(VEB *v, u64 x) {
    if (veb_empty(v) || x <= v->min) return VEB_EMPTY;
    if (x > v->max) return v->max;
    if (v->bits == 1) return 0;
    u64 h = vhi(x, v->bits), l = vlo(x, v->bits);
    VEB *c = cls_get(v, h);
    if (c && !veb_empty(c) && l > c->min)
        return vidx(h, veb_pred(c, l), v->bits);
    u64 ph = (v->sum && !veb_empty(v->sum)) ? veb_pred(v->sum, h) : VEB_EMPTY;
    if (ph == VEB_EMPTY) return (x > v->min) ? v->min : VEB_EMPTY;
    VEB *pc = cls_get(v, ph);
    return pc ? vidx(ph, pc->max, v->bits) : VEB_EMPTY;
}
static u64 veb_floor(VEB *v, u64 x) {
    if (veb_empty(v) || x < v->min) return VEB_EMPTY;
    if (x >= v->max) return v->max;
    if (x == v->min) return v->min;
    return veb_pred(v, x + 1);
}
typedef enum CONTAINER_TYPE {
    CT_VECTOR,
    CT_LIST,
    CT_STACK,
    CT_QUEUE,
    CT_DEQUE,
    CT_SET,
    CT_MAP,
    CT_UNORDERED_SET,
    CT_UNORDERED_MAP,
    CT_JSON,
    CT_GLOB,
    CT_CSV,
    CT_BITSET,
} CONTAINER_TYPE;
typedef struct {
    void *a;
    void *b;
    CONTAINER_TYPE ctype;
    size_type64 type_size;
    char *type_name;
} Interval;
typedef struct {
    VEB *veb;
    HashMap *data;
} IntervalVEB;
typedef struct {
    void *p1, *p2;
    char *tombstone;
    int type_size;
    bool used;
} HashtableManager;
typedef struct {
    VEB *veb;
    HashMap *data;
} HTMVEB;
typedef struct {
    unsigned char *p1;
    unsigned char *p2;
    int type_size;
} GInterval;
typedef struct {
    VEB *veb;
    HashMap *data;
} GIntervalVEB;
HTMVEB *htm_new(void) {
    HTMVEB *iv = (HTMVEB *) calloc(1, sizeof(HTMVEB));
    iv->veb = veb_new(64);
    iv->data = hm_new();
    return iv;
}
void htm_free(HTMVEB *iv) {
    for (size_type64 i = 0; i < iv->data->cap; i++)
        if (iv->data->e[i].used)
            free(iv->data->e[i].val);
    hm_free(iv->data);
    veb_free(iv->veb);
    free(iv);
}
void htm_insert(HTMVEB *iv, void *a, void *b, char *tombstone, int type_size) {
    u64 k = (u64) (uintptr_t) a;
    HashtableManager *it = (HashtableManager *) hm_get(iv->data, k);
    if (!it) {
        it = (HashtableManager *) malloc(sizeof(HashtableManager));
        hm_set(iv->data, k, it);
        veb_ins(iv->veb, k);
    }
    it->p1 = a;
    it->p2 = b;
    it->tombstone = tombstone;
    it->used = true;
    it->type_size = type_size;
}
void htm_erase(HTMVEB *iv, void *a) {
    u64 k = (u64) (uintptr_t) a;
    HashtableManager *it = (HashtableManager *) hm_get(iv->data, k);
    if (!it) return;
    free(it);
    hm_del(iv->data, k);
    veb_del(iv->veb, k);
}
HashtableManager *htm_find(HTMVEB *iv, void *x) {
    u64 key = (u64) (uintptr_t) x;
    u64 start = veb_floor(iv->veb, key);
    if (start == VEB_EMPTY) return NULL;
    HashtableManager *it = (HashtableManager *) hm_get(iv->data, start);
    if (!it) return NULL;
    return ((uintptr_t) x <= (uintptr_t) it->p2) ? it : NULL;
}
IntervalVEB *iveb_new(void) {
    IntervalVEB *iv = (IntervalVEB *) calloc(1, sizeof(IntervalVEB));
    iv->veb = veb_new(64);
    iv->data = hm_new();
    return iv;
}
void iveb_free(IntervalVEB *iv) {
    for (size_type64 i = 0; i < iv->data->cap; i++)
        if (iv->data->e[i].used)
            free(iv->data->e[i].val);
    hm_free(iv->data);
    veb_free(iv->veb);
    free(iv);
}
void iveb_insert(IntervalVEB *iv, void *a, void *b, CONTAINER_TYPE ctype, size_type64 type_size, char *type_name) {
    u64 k = (u64) (uintptr_t) a;
    Interval *it = (Interval *) hm_get(iv->data, k);
    if (!it) {
        it = (Interval *) malloc(sizeof(Interval));
        hm_set(iv->data, k, it);
        veb_ins(iv->veb, k);
    }
    it->a = a;
    it->b = b;
    it->ctype = ctype;
    it->type_size = type_size;
    it->type_name = type_name;
}
void iveb_erase(IntervalVEB *iv, void *a) {
    u64 k = (u64) (uintptr_t) a;
    Interval *it = (Interval *) hm_get(iv->data, k);
    if (!it) return;
    free(it);
    hm_del(iv->data, k);
    veb_del(iv->veb, k);
}
Interval *iveb_find(IntervalVEB *iv, void *x) {
    if (iv == NULL) return NULL;
    u64 key = (u64) (uintptr_t) x;
    u64 start = veb_floor(iv->veb, key);
    if (start == VEB_EMPTY) return NULL;
    Interval *it = (Interval *) hm_get(iv->data, start);
    if (!it) return NULL;
    return ((uintptr_t) x <= (uintptr_t) it->b) ? it : NULL;
}
#define _DBLOCK_MIN_SHIFT    4
#define _DBLOCK_MAX_SHIFT    20
#define _DBLOCK_NUM_BUCKETS  (_DBLOCK_MAX_SHIFT - _DBLOCK_MIN_SHIFT + 1)
typedef struct _OCSTLDBlockNode {
    struct _OCSTLDBlockNode *next;
} _OCSTLDBlockNode;
static size_type64 _ocstl_dblock_bump = 0;
static _OCSTLDBlockNode *_ocstl_dblock_freelist[_DBLOCK_NUM_BUCKETS] = {NULL};
static int _ocstl_dblock_bucket(size_type64 sz) {
    int sh = _DBLOCK_MIN_SHIFT;
    size_type64 s = (size_type64) 1 << sh;
    while (s < sz) {
        s <<= 1;
        sh++;
    }
    return sh - _DBLOCK_MIN_SHIFT;
}
static void *_ocstl_dblock_alloc(size_type64 sz) {
    int b = _ocstl_dblock_bucket(sz);
    size_type64 real = (size_type64) 1 << (b + _DBLOCK_MIN_SHIFT);
    if (_ocstl_dblock_freelist[b]) {
        _OCSTLDBlockNode *n = _ocstl_dblock_freelist[b];
        _ocstl_dblock_freelist[b] = n->next;
        memset(n, 0, real);
        return n;
    }
    if (_ocstl_dblock_bump + real > ___OCSTL_1MB) return NULL;
    void *p = &OCSTL_DBLOCK[_ocstl_dblock_bump];
    _ocstl_dblock_bump += real;
    memset(p, 0, real);
    return p;
}
static void _ocstl_dblock_free(void *p, size_type64 sz) {
    if (!p) return;
    int b = _ocstl_dblock_bucket(sz);
    _OCSTLDBlockNode *n = (_OCSTLDBlockNode *) p;
    n->next = _ocstl_dblock_freelist[b];
    _ocstl_dblock_freelist[b] = n;
}
static void giveb_hm_set(HashMap *h, u64 key, void *val);
static HashMap *giveb_hm_new(void) {
    HashMap *h = (HashMap *) _ocstl_dblock_alloc(sizeof(HashMap));
    h->cap = HM_INIT_CAP;
    h->e = (HMEntry *) _ocstl_dblock_alloc(h->cap * sizeof(HMEntry));
    return h;
}
static void giveb_hm_free(HashMap *h) {
    _ocstl_dblock_free(h->e, h->cap * sizeof(HMEntry));
    _ocstl_dblock_free(h, sizeof(HashMap));
}
static void giveb_hm_grow(HashMap *h) {
    size_type64 oc = h->cap;
    HMEntry *oe = h->e;
    h->cap = oc * 2;
    h->e = (HMEntry *) _ocstl_dblock_alloc(h->cap * sizeof(HMEntry));
    h->size = 0;
    for (size_type64 i = 0; i < oc; i++)
        if (oe[i].used) giveb_hm_set(h, oe[i].key, oe[i].val);
    _ocstl_dblock_free(oe, oc * sizeof(HMEntry));
}
static void giveb_hm_set(HashMap *h, u64 k, void *v) {
    if (h->size * 2 >= h->cap) giveb_hm_grow(h);
    size_type64 i = (size_type64) (hm_hash(k) % h->cap);
    while (h->e[i].used && h->e[i].key != k)
        i = (i + 1) % h->cap;
    if (!h->e[i].used) h->size++;
    h->e[i] = (HMEntry){k, v, 1};
}
static void giveb_hm_del(HashMap *h, u64 k) {
    size_type64 i = (size_type64) (hm_hash(k) % h->cap);
    while (h->e[i].used && h->e[i].key != k)
        i = (i + 1) % h->cap;
    if (!h->e[i].used) return;
    h->e[i].used = 0;
    h->size--;
    size_type64 j = (i + 1) % h->cap;
    while (h->e[j].used) {
        HMEntry t = h->e[j];
        h->e[j].used = 0;
        h->size--;
        giveb_hm_set(h, t.key, t.val);
        j = (j + 1) % h->cap;
    }
}
static VEB *giveb_veb_new(int bits) {
    VEB *v = (VEB *) _ocstl_dblock_alloc(sizeof(VEB));
    v->bits = bits;
    v->min = VEB_EMPTY;
    v->max = VEB_EMPTY;
    if (bits > 1) v->cls = giveb_hm_new();
    return v;
}
static void giveb_veb_free(VEB *v);
static void giveb_cls_free_all(HashMap *hm) {
    for (size_type64 i = 0; i < hm->cap; i++)
        if (hm->e[i].used) giveb_veb_free((VEB *) hm->e[i].val);
    giveb_hm_free(hm);
}
static void giveb_veb_free(VEB *v) {
    if (!v) return;
    if (v->bits > 1) {
        giveb_veb_free(v->sum);
        if (v->cls) giveb_cls_free_all(v->cls);
    }
    _ocstl_dblock_free(v, sizeof(VEB));
}
static VEB *giveb_cls_or_new(VEB *v, u64 h) {
    VEB *c = (VEB *) hm_get(v->cls, h);
    if (!c) {
        c = giveb_veb_new(lo_b(v->bits));
        giveb_hm_set(v->cls, h, c);
    }
    return c;
}
static VEB *giveb_sum_or_new(VEB *v) {
    if (!v->sum) v->sum = giveb_veb_new(hi_b(v->bits));
    return v->sum;
}
static void giveb_veb_ins(VEB *v, u64 x) {
    if (veb_empty(v)) {
        v->min = v->max = x;
        return;
    }
    if (x < v->min) {
        u64 t = v->min;
        v->min = x;
        x = t;
    }
    if (v->bits == 1) {
        if (x > v->max) v->max = x;
        return;
    }
    u64 h = vhi(x, v->bits), l = vlo(x, v->bits);
    VEB *c = giveb_cls_or_new(v, h);
    if (veb_empty(c)) giveb_veb_ins(giveb_sum_or_new(v), h);
    giveb_veb_ins(c, l);
    if (x > v->max) v->max = x;
}
static void giveb_veb_del(VEB *v, u64 x) {
    if (v->min == v->max) {
        v->min = v->max = VEB_EMPTY;
        return;
    }
    if (v->bits == 1) {
        v->min = v->max = (x == 0) ? 1 : 0;
        return;
    }
    if (x == v->min) {
        if (!v->sum || veb_empty(v->sum)) {
            v->min = v->max = VEB_EMPTY;
            return;
        }
        u64 fh = v->sum->min;
        VEB *fc = cls_get(v, fh);
        v->min = x = vidx(fh, fc->min, v->bits);
    }
    u64 h = vhi(x, v->bits), l = vlo(x, v->bits);
    VEB *c = cls_get(v, h);
    if (!c) return;
    giveb_veb_del(c, l);
    if (veb_empty(c)) {
        giveb_hm_del(v->cls, h);
        giveb_veb_free(c);
        if (v->sum) giveb_veb_del(v->sum, h);
        if (x == v->max) {
            if (!v->sum || veb_empty(v->sum)) v->max = v->min;
            else {
                u64 lh = v->sum->max;
                VEB *lc = cls_get(v, lh);
                v->max = vidx(lh, lc->max, v->bits);
            }
        }
    } else if (x == v->max) {
        v->max = vidx(h, c->max, v->bits);
    }
}
GIntervalVEB *giveb_new(void) {
    GIntervalVEB *iv = (GIntervalVEB *) _ocstl_dblock_alloc(sizeof(GIntervalVEB));
    iv->veb = giveb_veb_new(64);
    iv->data = giveb_hm_new();
    return iv;
}
void giveb_free(GIntervalVEB *iv) {
    for (size_type64 i = 0; i < iv->data->cap; i++)
        if (iv->data->e[i].used)
            _ocstl_dblock_free(iv->data->e[i].val, sizeof(GInterval));
    giveb_hm_free(iv->data);
    giveb_veb_free(iv->veb);
    _ocstl_dblock_free(iv, sizeof(GIntervalVEB));
}
void giveb_insert(GIntervalVEB *iv, void *a, void *b, int type_size) {
    u64 k = (u64) (uintptr_t) a;
    GInterval *it = (GInterval *) hm_get(iv->data, k);
    if (!it) {
        it = (GInterval *) _ocstl_dblock_alloc(sizeof(GInterval));
        giveb_hm_set(iv->data, k, it);
        giveb_veb_ins(iv->veb, k);
    }
    it->p1 = a;
    it->p2 = b;
    it->type_size = type_size;
}
void giveb_erase(GIntervalVEB *iv, void *a) {
    u64 key = (u64) (uintptr_t) a;
    u64 start = veb_floor(iv->veb, key);
    if (start == VEB_EMPTY) return;
    GInterval *it = (GInterval *) hm_get(iv->data, start);
    if (!it) return;
    if ((uintptr_t) a > (uintptr_t) it->p2) return;
    _ocstl_dblock_free(it, sizeof(GInterval));
    giveb_hm_del(iv->data, start);
    giveb_veb_del(iv->veb, start);
}
GInterval *giveb_find(GIntervalVEB *iv, void *x) {
    if (iv == NULL) return NULL;
    u64 key = (u64) (uintptr_t) x;
    u64 start = veb_floor(iv->veb, key);
    if (start == VEB_EMPTY) return NULL;
    GInterval *it = (GInterval *) hm_get(iv->data, start);
    if (!it) return NULL;
    return ((uintptr_t) x <= (uintptr_t) it->p2) ? it : NULL;
}
static u64 veb_succ(VEB *v, u64 x) {
    if (veb_empty(v) || x >= v->max) return VEB_EMPTY;
    if (x < v->min) return v->min;
    if (v->bits == 1) return 1;
    u64 h = vhi(x, v->bits), l = vlo(x, v->bits);
    VEB *c = cls_get(v, h);
    if (c && !veb_empty(c) && l < c->max) {
        u64 nl = veb_succ(c, l);
        return vidx(h, nl, v->bits);
    }
    u64 nh = (v->sum && !veb_empty(v->sum))
                 ? veb_succ(v->sum, h)
                 : VEB_EMPTY;
    if (nh == VEB_EMPTY) return VEB_EMPTY;
    VEB *nc = cls_get(v, nh);
    if (!nc) return VEB_EMPTY;
    return vidx(nh, nc->min, v->bits);
}
void *giveb_alloc(GIntervalVEB *iv, size_type64 sz, size_type64 type_size) {
    if (!iv || sz == 0) return NULL;
    void *block_start = (void *) OCSTL_GBLOCK;
    void *block_end = (void *) (OCSTL_GBLOCK + ___OCSTL_512MB);
    if (veb_empty(iv->veb)) {
        if (sz <= ___OCSTL_512MB) {
            giveb_insert(iv, block_start,
                         (void *) ((unsigned char *) block_start + sz - 1), type_size);
            return block_start;
        }
        return NULL;
    }
    u64 cur_key = iv->veb->min;
    GInterval *first = (GInterval *) hm_get(iv->data, cur_key);
    if (first) {
        u64 gap_start = (u64) (uintptr_t) block_start;
        u64 gap_end = (u64) (uintptr_t) first->p1;
        if (gap_end > gap_start && gap_end - gap_start >= sz) {
            void *p = (void *) (uintptr_t) gap_start;
            giveb_insert(iv, p, (void *) ((unsigned char *) p + sz - 1), type_size);
            return p;
        }
    }
    while (cur_key != VEB_EMPTY) {
        GInterval *cur = (GInterval *) hm_get(iv->data, cur_key);
        if (!cur) break;
        u64 gap_start = (u64) (uintptr_t) cur->p2 + 1;
        u64 next_key = veb_succ(iv->veb, cur_key);
        u64 gap_end = (next_key != VEB_EMPTY)
                          ? (u64) (uintptr_t) ((GInterval *) hm_get(iv->data, next_key))->p1
                          : (u64) (uintptr_t) block_end;
        if (gap_start < (u64) (uintptr_t) block_start)
            gap_start = (u64) (uintptr_t) block_start;
        if (gap_end > (u64) (uintptr_t) block_end)
            gap_end = (u64) (uintptr_t) block_end;
        if (gap_end > gap_start && gap_end - gap_start >= sz) {
            void *p = (void *) (uintptr_t) gap_start;
            giveb_insert(iv, p, (void *) ((unsigned char *) p + sz - 1), type_size);
            return p;
        }
        if (next_key == VEB_EMPTY) break;
        cur_key = next_key;
    }
    return NULL;
}
static GIntervalVEB *giveb = NULL;
static IntervalVEB *iveb = NULL;
static HTMVEB *htm = NULL;
void __opencstl_giveb_destroy(void) {
    giveb_free(giveb);
}
void __cstl_htm_destroy(void) {
    htm_free(htm);
}
void __opencstl_iveb_destroy(void) {
    iveb_free(iveb);
}
#ifdef OPENCSTL_TRACER
void *_garray_ctx = NULL;
#define galloc(SZ,tsz)  (_garray_ctx=_galloc(SZ,tsz));zinsert(_garray_ctx,__FILE__,__func__,__LINE__);
#define gfree(P) _gfree(P);zremove(P);
#else
#define galloc(SZ,TSZ) _galloc(SZ ,TSZ)
#define gfree(P) _gfree(P)
#endif
static void *_galloc(size_type64 sz, size_type64 type_size) {
    bool giveb_init = false;
    if (giveb == NULL) {
        giveb = giveb_new();
        giveb_init = true;
    }
    void *p = giveb_alloc(giveb, sz, type_size);
    if (p == NULL) {
        return NULL;
    }
    giveb_insert(giveb, p, (char *) p + (sz), type_size);
    if (giveb_init) {
        atexit(__opencstl_giveb_destroy);
    }
    return p;
}
static void _gfree(void *p) {
    giveb_erase(giveb, p);
}
#endif
#ifdef _MSC_VER
#pragma warning(disable:4146)
#pragma warning(disable:4308)
#pragma warning(disable:4307)
#endif
#ifndef OPENCSTL_COMPARE_H
#define OPENCSTL_COMPARE_H
#include <string.h>
#include <float.h>
#if !defined(OPENCSTL_MEMCMPS_H)
#define OPENCSTL_MEMCMPS_H
#include <string.h>
static int _memcmp1(const void *a, const void *b) { return memcmp(a, b, 1); }
static int _memcmp2(const void *a, const void *b) { return memcmp(a, b, 2); }
static int _memcmp3(const void *a, const void *b) { return memcmp(a, b, 3); }
static int _memcmp4(const void *a, const void *b) { return memcmp(a, b, 4); }
static int _memcmp5(const void *a, const void *b) { return memcmp(a, b, 5); }
static int _memcmp6(const void *a, const void *b) { return memcmp(a, b, 6); }
static int _memcmp7(const void *a, const void *b) { return memcmp(a, b, 7); }
static int _memcmp8(const void *a, const void *b) { return memcmp(a, b, 8); }
static int _memcmp9(const void *a, const void *b) { return memcmp(a, b, 9); }
static int _memcmp10(const void *a, const void *b) { return memcmp(a, b, 10); }
static int _memcmp11(const void *a, const void *b) { return memcmp(a, b, 11); }
static int _memcmp12(const void *a, const void *b) { return memcmp(a, b, 12); }
static int _memcmp13(const void *a, const void *b) { return memcmp(a, b, 13); }
static int _memcmp14(const void *a, const void *b) { return memcmp(a, b, 14); }
static int _memcmp15(const void *a, const void *b) { return memcmp(a, b, 15); }
static int _memcmp16(const void *a, const void *b) { return memcmp(a, b, 16); }
static int _memcmp17(const void *a, const void *b) { return memcmp(a, b, 17); }
static int _memcmp18(const void *a, const void *b) { return memcmp(a, b, 18); }
static int _memcmp19(const void *a, const void *b) { return memcmp(a, b, 19); }
static int _memcmp20(const void *a, const void *b) { return memcmp(a, b, 20); }
static int _memcmp21(const void *a, const void *b) { return memcmp(a, b, 21); }
static int _memcmp22(const void *a, const void *b) { return memcmp(a, b, 22); }
static int _memcmp23(const void *a, const void *b) { return memcmp(a, b, 23); }
static int _memcmp24(const void *a, const void *b) { return memcmp(a, b, 24); }
static int _memcmp25(const void *a, const void *b) { return memcmp(a, b, 25); }
static int _memcmp26(const void *a, const void *b) { return memcmp(a, b, 26); }
static int _memcmp27(const void *a, const void *b) { return memcmp(a, b, 27); }
static int _memcmp28(const void *a, const void *b) { return memcmp(a, b, 28); }
static int _memcmp29(const void *a, const void *b) { return memcmp(a, b, 29); }
static int _memcmp30(const void *a, const void *b) { return memcmp(a, b, 30); }
static int _memcmp31(const void *a, const void *b) { return memcmp(a, b, 31); }
static int _memcmp32(const void *a, const void *b) { return memcmp(a, b, 32); }
static int _memcmp33(const void *a, const void *b) { return memcmp(a, b, 33); }
static int _memcmp34(const void *a, const void *b) { return memcmp(a, b, 34); }
static int _memcmp35(const void *a, const void *b) { return memcmp(a, b, 35); }
static int _memcmp36(const void *a, const void *b) { return memcmp(a, b, 36); }
static int _memcmp37(const void *a, const void *b) { return memcmp(a, b, 37); }
static int _memcmp38(const void *a, const void *b) { return memcmp(a, b, 38); }
static int _memcmp39(const void *a, const void *b) { return memcmp(a, b, 39); }
static int _memcmp40(const void *a, const void *b) { return memcmp(a, b, 40); }
static int _memcmp41(const void *a, const void *b) { return memcmp(a, b, 41); }
static int _memcmp42(const void *a, const void *b) { return memcmp(a, b, 42); }
static int _memcmp43(const void *a, const void *b) { return memcmp(a, b, 43); }
static int _memcmp44(const void *a, const void *b) { return memcmp(a, b, 44); }
static int _memcmp45(const void *a, const void *b) { return memcmp(a, b, 45); }
static int _memcmp46(const void *a, const void *b) { return memcmp(a, b, 46); }
static int _memcmp47(const void *a, const void *b) { return memcmp(a, b, 47); }
static int _memcmp48(const void *a, const void *b) { return memcmp(a, b, 48); }
static int _memcmp49(const void *a, const void *b) { return memcmp(a, b, 49); }
static int _memcmp50(const void *a, const void *b) { return memcmp(a, b, 50); }
static int _memcmp51(const void *a, const void *b) { return memcmp(a, b, 51); }
static int _memcmp52(const void *a, const void *b) { return memcmp(a, b, 52); }
static int _memcmp53(const void *a, const void *b) { return memcmp(a, b, 53); }
static int _memcmp54(const void *a, const void *b) { return memcmp(a, b, 54); }
static int _memcmp55(const void *a, const void *b) { return memcmp(a, b, 55); }
static int _memcmp56(const void *a, const void *b) { return memcmp(a, b, 56); }
static int _memcmp57(const void *a, const void *b) { return memcmp(a, b, 57); }
static int _memcmp58(const void *a, const void *b) { return memcmp(a, b, 58); }
static int _memcmp59(const void *a, const void *b) { return memcmp(a, b, 59); }
static int _memcmp60(const void *a, const void *b) { return memcmp(a, b, 60); }
static int _memcmp61(const void *a, const void *b) { return memcmp(a, b, 61); }
static int _memcmp62(const void *a, const void *b) { return memcmp(a, b, 62); }
static int _memcmp63(const void *a, const void *b) { return memcmp(a, b, 63); }
static int _memcmp64(const void *a, const void *b) { return memcmp(a, b, 64); }
static int _memcmp65(const void *a, const void *b) { return memcmp(a, b, 65); }
static int _memcmp66(const void *a, const void *b) { return memcmp(a, b, 66); }
static int _memcmp67(const void *a, const void *b) { return memcmp(a, b, 67); }
static int _memcmp68(const void *a, const void *b) { return memcmp(a, b, 68); }
static int _memcmp69(const void *a, const void *b) { return memcmp(a, b, 69); }
static int _memcmp70(const void *a, const void *b) { return memcmp(a, b, 70); }
static int _memcmp71(const void *a, const void *b) { return memcmp(a, b, 71); }
static int _memcmp72(const void *a, const void *b) { return memcmp(a, b, 72); }
static int _memcmp73(const void *a, const void *b) { return memcmp(a, b, 73); }
static int _memcmp74(const void *a, const void *b) { return memcmp(a, b, 74); }
static int _memcmp75(const void *a, const void *b) { return memcmp(a, b, 75); }
static int _memcmp76(const void *a, const void *b) { return memcmp(a, b, 76); }
static int _memcmp77(const void *a, const void *b) { return memcmp(a, b, 77); }
static int _memcmp78(const void *a, const void *b) { return memcmp(a, b, 78); }
static int _memcmp79(const void *a, const void *b) { return memcmp(a, b, 79); }
static int _memcmp80(const void *a, const void *b) { return memcmp(a, b, 80); }
static int _memcmp81(const void *a, const void *b) { return memcmp(a, b, 81); }
static int _memcmp82(const void *a, const void *b) { return memcmp(a, b, 82); }
static int _memcmp83(const void *a, const void *b) { return memcmp(a, b, 83); }
static int _memcmp84(const void *a, const void *b) { return memcmp(a, b, 84); }
static int _memcmp85(const void *a, const void *b) { return memcmp(a, b, 85); }
static int _memcmp86(const void *a, const void *b) { return memcmp(a, b, 86); }
static int _memcmp87(const void *a, const void *b) { return memcmp(a, b, 87); }
static int _memcmp88(const void *a, const void *b) { return memcmp(a, b, 88); }
static int _memcmp89(const void *a, const void *b) { return memcmp(a, b, 89); }
static int _memcmp90(const void *a, const void *b) { return memcmp(a, b, 90); }
static int _memcmp91(const void *a, const void *b) { return memcmp(a, b, 91); }
static int _memcmp92(const void *a, const void *b) { return memcmp(a, b, 92); }
static int _memcmp93(const void *a, const void *b) { return memcmp(a, b, 93); }
static int _memcmp94(const void *a, const void *b) { return memcmp(a, b, 94); }
static int _memcmp95(const void *a, const void *b) { return memcmp(a, b, 95); }
static int _memcmp96(const void *a, const void *b) { return memcmp(a, b, 96); }
static int _memcmp97(const void *a, const void *b) { return memcmp(a, b, 97); }
static int _memcmp98(const void *a, const void *b) { return memcmp(a, b, 98); }
static int _memcmp99(const void *a, const void *b) { return memcmp(a, b, 99); }
static int _memcmp100(const void *a, const void *b) { return memcmp(a, b, 100); }
static int _memcmp101(const void *a, const void *b) { return memcmp(a, b, 101); }
static int _memcmp102(const void *a, const void *b) { return memcmp(a, b, 102); }
static int _memcmp103(const void *a, const void *b) { return memcmp(a, b, 103); }
static int _memcmp104(const void *a, const void *b) { return memcmp(a, b, 104); }
static int _memcmp105(const void *a, const void *b) { return memcmp(a, b, 105); }
static int _memcmp106(const void *a, const void *b) { return memcmp(a, b, 106); }
static int _memcmp107(const void *a, const void *b) { return memcmp(a, b, 107); }
static int _memcmp108(const void *a, const void *b) { return memcmp(a, b, 108); }
static int _memcmp109(const void *a, const void *b) { return memcmp(a, b, 109); }
static int _memcmp110(const void *a, const void *b) { return memcmp(a, b, 110); }
static int _memcmp111(const void *a, const void *b) { return memcmp(a, b, 111); }
static int _memcmp112(const void *a, const void *b) { return memcmp(a, b, 112); }
static int _memcmp113(const void *a, const void *b) { return memcmp(a, b, 113); }
static int _memcmp114(const void *a, const void *b) { return memcmp(a, b, 114); }
static int _memcmp115(const void *a, const void *b) { return memcmp(a, b, 115); }
static int _memcmp116(const void *a, const void *b) { return memcmp(a, b, 116); }
static int _memcmp117(const void *a, const void *b) { return memcmp(a, b, 117); }
static int _memcmp118(const void *a, const void *b) { return memcmp(a, b, 118); }
static int _memcmp119(const void *a, const void *b) { return memcmp(a, b, 119); }
static int _memcmp120(const void *a, const void *b) { return memcmp(a, b, 120); }
static int _memcmp121(const void *a, const void *b) { return memcmp(a, b, 121); }
static int _memcmp122(const void *a, const void *b) { return memcmp(a, b, 122); }
static int _memcmp123(const void *a, const void *b) { return memcmp(a, b, 123); }
static int _memcmp124(const void *a, const void *b) { return memcmp(a, b, 124); }
static int _memcmp125(const void *a, const void *b) { return memcmp(a, b, 125); }
static int _memcmp126(const void *a, const void *b) { return memcmp(a, b, 126); }
static int _memcmp127(const void *a, const void *b) { return memcmp(a, b, 127); }
static int _memcmp128(const void *a, const void *b) { return memcmp(a, b, 128); }
static int _memcmp129(const void *a, const void *b) { return memcmp(a, b, 129); }
static int _memcmp130(const void *a, const void *b) { return memcmp(a, b, 130); }
static int _memcmp131(const void *a, const void *b) { return memcmp(a, b, 131); }
static int _memcmp132(const void *a, const void *b) { return memcmp(a, b, 132); }
static int _memcmp133(const void *a, const void *b) { return memcmp(a, b, 133); }
static int _memcmp134(const void *a, const void *b) { return memcmp(a, b, 134); }
static int _memcmp135(const void *a, const void *b) { return memcmp(a, b, 135); }
static int _memcmp136(const void *a, const void *b) { return memcmp(a, b, 136); }
static int _memcmp137(const void *a, const void *b) { return memcmp(a, b, 137); }
static int _memcmp138(const void *a, const void *b) { return memcmp(a, b, 138); }
static int _memcmp139(const void *a, const void *b) { return memcmp(a, b, 139); }
static int _memcmp140(const void *a, const void *b) { return memcmp(a, b, 140); }
static int _memcmp141(const void *a, const void *b) { return memcmp(a, b, 141); }
static int _memcmp142(const void *a, const void *b) { return memcmp(a, b, 142); }
static int _memcmp143(const void *a, const void *b) { return memcmp(a, b, 143); }
static int _memcmp144(const void *a, const void *b) { return memcmp(a, b, 144); }
static int _memcmp145(const void *a, const void *b) { return memcmp(a, b, 145); }
static int _memcmp146(const void *a, const void *b) { return memcmp(a, b, 146); }
static int _memcmp147(const void *a, const void *b) { return memcmp(a, b, 147); }
static int _memcmp148(const void *a, const void *b) { return memcmp(a, b, 148); }
static int _memcmp149(const void *a, const void *b) { return memcmp(a, b, 149); }
static int _memcmp150(const void *a, const void *b) { return memcmp(a, b, 150); }
static int _memcmp151(const void *a, const void *b) { return memcmp(a, b, 151); }
static int _memcmp152(const void *a, const void *b) { return memcmp(a, b, 152); }
static int _memcmp153(const void *a, const void *b) { return memcmp(a, b, 153); }
static int _memcmp154(const void *a, const void *b) { return memcmp(a, b, 154); }
static int _memcmp155(const void *a, const void *b) { return memcmp(a, b, 155); }
static int _memcmp156(const void *a, const void *b) { return memcmp(a, b, 156); }
static int _memcmp157(const void *a, const void *b) { return memcmp(a, b, 157); }
static int _memcmp158(const void *a, const void *b) { return memcmp(a, b, 158); }
static int _memcmp159(const void *a, const void *b) { return memcmp(a, b, 159); }
static int _memcmp160(const void *a, const void *b) { return memcmp(a, b, 160); }
static int _memcmp161(const void *a, const void *b) { return memcmp(a, b, 161); }
static int _memcmp162(const void *a, const void *b) { return memcmp(a, b, 162); }
static int _memcmp163(const void *a, const void *b) { return memcmp(a, b, 163); }
static int _memcmp164(const void *a, const void *b) { return memcmp(a, b, 164); }
static int _memcmp165(const void *a, const void *b) { return memcmp(a, b, 165); }
static int _memcmp166(const void *a, const void *b) { return memcmp(a, b, 166); }
static int _memcmp167(const void *a, const void *b) { return memcmp(a, b, 167); }
static int _memcmp168(const void *a, const void *b) { return memcmp(a, b, 168); }
static int _memcmp169(const void *a, const void *b) { return memcmp(a, b, 169); }
static int _memcmp170(const void *a, const void *b) { return memcmp(a, b, 170); }
static int _memcmp171(const void *a, const void *b) { return memcmp(a, b, 171); }
static int _memcmp172(const void *a, const void *b) { return memcmp(a, b, 172); }
static int _memcmp173(const void *a, const void *b) { return memcmp(a, b, 173); }
static int _memcmp174(const void *a, const void *b) { return memcmp(a, b, 174); }
static int _memcmp175(const void *a, const void *b) { return memcmp(a, b, 175); }
static int _memcmp176(const void *a, const void *b) { return memcmp(a, b, 176); }
static int _memcmp177(const void *a, const void *b) { return memcmp(a, b, 177); }
static int _memcmp178(const void *a, const void *b) { return memcmp(a, b, 178); }
static int _memcmp179(const void *a, const void *b) { return memcmp(a, b, 179); }
static int _memcmp180(const void *a, const void *b) { return memcmp(a, b, 180); }
static int _memcmp181(const void *a, const void *b) { return memcmp(a, b, 181); }
static int _memcmp182(const void *a, const void *b) { return memcmp(a, b, 182); }
static int _memcmp183(const void *a, const void *b) { return memcmp(a, b, 183); }
static int _memcmp184(const void *a, const void *b) { return memcmp(a, b, 184); }
static int _memcmp185(const void *a, const void *b) { return memcmp(a, b, 185); }
static int _memcmp186(const void *a, const void *b) { return memcmp(a, b, 186); }
static int _memcmp187(const void *a, const void *b) { return memcmp(a, b, 187); }
static int _memcmp188(const void *a, const void *b) { return memcmp(a, b, 188); }
static int _memcmp189(const void *a, const void *b) { return memcmp(a, b, 189); }
static int _memcmp190(const void *a, const void *b) { return memcmp(a, b, 190); }
static int _memcmp191(const void *a, const void *b) { return memcmp(a, b, 191); }
static int _memcmp192(const void *a, const void *b) { return memcmp(a, b, 192); }
static int _memcmp193(const void *a, const void *b) { return memcmp(a, b, 193); }
static int _memcmp194(const void *a, const void *b) { return memcmp(a, b, 194); }
static int _memcmp195(const void *a, const void *b) { return memcmp(a, b, 195); }
static int _memcmp196(const void *a, const void *b) { return memcmp(a, b, 196); }
static int _memcmp197(const void *a, const void *b) { return memcmp(a, b, 197); }
static int _memcmp198(const void *a, const void *b) { return memcmp(a, b, 198); }
static int _memcmp199(const void *a, const void *b) { return memcmp(a, b, 199); }
static int _memcmp200(const void *a, const void *b) { return memcmp(a, b, 200); }
static int _memcmp201(const void *a, const void *b) { return memcmp(a, b, 201); }
static int _memcmp202(const void *a, const void *b) { return memcmp(a, b, 202); }
static int _memcmp203(const void *a, const void *b) { return memcmp(a, b, 203); }
static int _memcmp204(const void *a, const void *b) { return memcmp(a, b, 204); }
static int _memcmp205(const void *a, const void *b) { return memcmp(a, b, 205); }
static int _memcmp206(const void *a, const void *b) { return memcmp(a, b, 206); }
static int _memcmp207(const void *a, const void *b) { return memcmp(a, b, 207); }
static int _memcmp208(const void *a, const void *b) { return memcmp(a, b, 208); }
static int _memcmp209(const void *a, const void *b) { return memcmp(a, b, 209); }
static int _memcmp210(const void *a, const void *b) { return memcmp(a, b, 210); }
static int _memcmp211(const void *a, const void *b) { return memcmp(a, b, 211); }
static int _memcmp212(const void *a, const void *b) { return memcmp(a, b, 212); }
static int _memcmp213(const void *a, const void *b) { return memcmp(a, b, 213); }
static int _memcmp214(const void *a, const void *b) { return memcmp(a, b, 214); }
static int _memcmp215(const void *a, const void *b) { return memcmp(a, b, 215); }
static int _memcmp216(const void *a, const void *b) { return memcmp(a, b, 216); }
static int _memcmp217(const void *a, const void *b) { return memcmp(a, b, 217); }
static int _memcmp218(const void *a, const void *b) { return memcmp(a, b, 218); }
static int _memcmp219(const void *a, const void *b) { return memcmp(a, b, 219); }
static int _memcmp220(const void *a, const void *b) { return memcmp(a, b, 220); }
static int _memcmp221(const void *a, const void *b) { return memcmp(a, b, 221); }
static int _memcmp222(const void *a, const void *b) { return memcmp(a, b, 222); }
static int _memcmp223(const void *a, const void *b) { return memcmp(a, b, 223); }
static int _memcmp224(const void *a, const void *b) { return memcmp(a, b, 224); }
static int _memcmp225(const void *a, const void *b) { return memcmp(a, b, 225); }
static int _memcmp226(const void *a, const void *b) { return memcmp(a, b, 226); }
static int _memcmp227(const void *a, const void *b) { return memcmp(a, b, 227); }
static int _memcmp228(const void *a, const void *b) { return memcmp(a, b, 228); }
static int _memcmp229(const void *a, const void *b) { return memcmp(a, b, 229); }
static int _memcmp230(const void *a, const void *b) { return memcmp(a, b, 230); }
static int _memcmp231(const void *a, const void *b) { return memcmp(a, b, 231); }
static int _memcmp232(const void *a, const void *b) { return memcmp(a, b, 232); }
static int _memcmp233(const void *a, const void *b) { return memcmp(a, b, 233); }
static int _memcmp234(const void *a, const void *b) { return memcmp(a, b, 234); }
static int _memcmp235(const void *a, const void *b) { return memcmp(a, b, 235); }
static int _memcmp236(const void *a, const void *b) { return memcmp(a, b, 236); }
static int _memcmp237(const void *a, const void *b) { return memcmp(a, b, 237); }
static int _memcmp238(const void *a, const void *b) { return memcmp(a, b, 238); }
static int _memcmp239(const void *a, const void *b) { return memcmp(a, b, 239); }
static int _memcmp240(const void *a, const void *b) { return memcmp(a, b, 240); }
static int _memcmp241(const void *a, const void *b) { return memcmp(a, b, 241); }
static int _memcmp242(const void *a, const void *b) { return memcmp(a, b, 242); }
static int _memcmp243(const void *a, const void *b) { return memcmp(a, b, 243); }
static int _memcmp244(const void *a, const void *b) { return memcmp(a, b, 244); }
static int _memcmp245(const void *a, const void *b) { return memcmp(a, b, 245); }
static int _memcmp246(const void *a, const void *b) { return memcmp(a, b, 246); }
static int _memcmp247(const void *a, const void *b) { return memcmp(a, b, 247); }
static int _memcmp248(const void *a, const void *b) { return memcmp(a, b, 248); }
static int _memcmp249(const void *a, const void *b) { return memcmp(a, b, 249); }
static int _memcmp250(const void *a, const void *b) { return memcmp(a, b, 250); }
static int _memcmp251(const void *a, const void *b) { return memcmp(a, b, 251); }
static int _memcmp252(const void *a, const void *b) { return memcmp(a, b, 252); }
static int _memcmp253(const void *a, const void *b) { return memcmp(a, b, 253); }
static int _memcmp254(const void *a, const void *b) { return memcmp(a, b, 254); }
static int _memcmp255(const void *a, const void *b) { return memcmp(a, b, 255); }
static int _memcmp256(const void *a, const void *b) { return memcmp(a, b, 256); }
static int _memcmp257(const void *a, const void *b) { return memcmp(a, b, 257); }
static int _memcmp258(const void *a, const void *b) { return memcmp(a, b, 258); }
static int _memcmp259(const void *a, const void *b) { return memcmp(a, b, 259); }
static int _memcmp260(const void *a, const void *b) { return memcmp(a, b, 260); }
static int _memcmp261(const void *a, const void *b) { return memcmp(a, b, 261); }
static int _memcmp262(const void *a, const void *b) { return memcmp(a, b, 262); }
static int _memcmp263(const void *a, const void *b) { return memcmp(a, b, 263); }
static int _memcmp264(const void *a, const void *b) { return memcmp(a, b, 264); }
static int _memcmp265(const void *a, const void *b) { return memcmp(a, b, 265); }
static int _memcmp266(const void *a, const void *b) { return memcmp(a, b, 266); }
static int _memcmp267(const void *a, const void *b) { return memcmp(a, b, 267); }
static int _memcmp268(const void *a, const void *b) { return memcmp(a, b, 268); }
static int _memcmp269(const void *a, const void *b) { return memcmp(a, b, 269); }
static int _memcmp270(const void *a, const void *b) { return memcmp(a, b, 270); }
static int _memcmp271(const void *a, const void *b) { return memcmp(a, b, 271); }
static int _memcmp272(const void *a, const void *b) { return memcmp(a, b, 272); }
static int _memcmp273(const void *a, const void *b) { return memcmp(a, b, 273); }
static int _memcmp274(const void *a, const void *b) { return memcmp(a, b, 274); }
static int _memcmp275(const void *a, const void *b) { return memcmp(a, b, 275); }
static int _memcmp276(const void *a, const void *b) { return memcmp(a, b, 276); }
static int _memcmp277(const void *a, const void *b) { return memcmp(a, b, 277); }
static int _memcmp278(const void *a, const void *b) { return memcmp(a, b, 278); }
static int _memcmp279(const void *a, const void *b) { return memcmp(a, b, 279); }
static int _memcmp280(const void *a, const void *b) { return memcmp(a, b, 280); }
static int _memcmp281(const void *a, const void *b) { return memcmp(a, b, 281); }
static int _memcmp282(const void *a, const void *b) { return memcmp(a, b, 282); }
static int _memcmp283(const void *a, const void *b) { return memcmp(a, b, 283); }
static int _memcmp284(const void *a, const void *b) { return memcmp(a, b, 284); }
static int _memcmp285(const void *a, const void *b) { return memcmp(a, b, 285); }
static int _memcmp286(const void *a, const void *b) { return memcmp(a, b, 286); }
static int _memcmp287(const void *a, const void *b) { return memcmp(a, b, 287); }
static int _memcmp288(const void *a, const void *b) { return memcmp(a, b, 288); }
static int _memcmp289(const void *a, const void *b) { return memcmp(a, b, 289); }
static int _memcmp290(const void *a, const void *b) { return memcmp(a, b, 290); }
static int _memcmp291(const void *a, const void *b) { return memcmp(a, b, 291); }
static int _memcmp292(const void *a, const void *b) { return memcmp(a, b, 292); }
static int _memcmp293(const void *a, const void *b) { return memcmp(a, b, 293); }
static int _memcmp294(const void *a, const void *b) { return memcmp(a, b, 294); }
static int _memcmp295(const void *a, const void *b) { return memcmp(a, b, 295); }
static int _memcmp296(const void *a, const void *b) { return memcmp(a, b, 296); }
static int _memcmp297(const void *a, const void *b) { return memcmp(a, b, 297); }
static int _memcmp298(const void *a, const void *b) { return memcmp(a, b, 298); }
static int _memcmp299(const void *a, const void *b) { return memcmp(a, b, 299); }
static int _memcmp300(const void *a, const void *b) { return memcmp(a, b, 300); }
static int _memcmp301(const void *a, const void *b) { return memcmp(a, b, 301); }
static int _memcmp302(const void *a, const void *b) { return memcmp(a, b, 302); }
static int _memcmp303(const void *a, const void *b) { return memcmp(a, b, 303); }
static int _memcmp304(const void *a, const void *b) { return memcmp(a, b, 304); }
static int _memcmp305(const void *a, const void *b) { return memcmp(a, b, 305); }
static int _memcmp306(const void *a, const void *b) { return memcmp(a, b, 306); }
static int _memcmp307(const void *a, const void *b) { return memcmp(a, b, 307); }
static int _memcmp308(const void *a, const void *b) { return memcmp(a, b, 308); }
static int _memcmp309(const void *a, const void *b) { return memcmp(a, b, 309); }
static int _memcmp310(const void *a, const void *b) { return memcmp(a, b, 310); }
static int _memcmp311(const void *a, const void *b) { return memcmp(a, b, 311); }
static int _memcmp312(const void *a, const void *b) { return memcmp(a, b, 312); }
static int _memcmp313(const void *a, const void *b) { return memcmp(a, b, 313); }
static int _memcmp314(const void *a, const void *b) { return memcmp(a, b, 314); }
static int _memcmp315(const void *a, const void *b) { return memcmp(a, b, 315); }
static int _memcmp316(const void *a, const void *b) { return memcmp(a, b, 316); }
static int _memcmp317(const void *a, const void *b) { return memcmp(a, b, 317); }
static int _memcmp318(const void *a, const void *b) { return memcmp(a, b, 318); }
static int _memcmp319(const void *a, const void *b) { return memcmp(a, b, 319); }
static int _memcmp320(const void *a, const void *b) { return memcmp(a, b, 320); }
static int _memcmp321(const void *a, const void *b) { return memcmp(a, b, 321); }
static int _memcmp322(const void *a, const void *b) { return memcmp(a, b, 322); }
static int _memcmp323(const void *a, const void *b) { return memcmp(a, b, 323); }
static int _memcmp324(const void *a, const void *b) { return memcmp(a, b, 324); }
static int _memcmp325(const void *a, const void *b) { return memcmp(a, b, 325); }
static int _memcmp326(const void *a, const void *b) { return memcmp(a, b, 326); }
static int _memcmp327(const void *a, const void *b) { return memcmp(a, b, 327); }
static int _memcmp328(const void *a, const void *b) { return memcmp(a, b, 328); }
static int _memcmp329(const void *a, const void *b) { return memcmp(a, b, 329); }
static int _memcmp330(const void *a, const void *b) { return memcmp(a, b, 330); }
static int _memcmp331(const void *a, const void *b) { return memcmp(a, b, 331); }
static int _memcmp332(const void *a, const void *b) { return memcmp(a, b, 332); }
static int _memcmp333(const void *a, const void *b) { return memcmp(a, b, 333); }
static int _memcmp334(const void *a, const void *b) { return memcmp(a, b, 334); }
static int _memcmp335(const void *a, const void *b) { return memcmp(a, b, 335); }
static int _memcmp336(const void *a, const void *b) { return memcmp(a, b, 336); }
static int _memcmp337(const void *a, const void *b) { return memcmp(a, b, 337); }
static int _memcmp338(const void *a, const void *b) { return memcmp(a, b, 338); }
static int _memcmp339(const void *a, const void *b) { return memcmp(a, b, 339); }
static int _memcmp340(const void *a, const void *b) { return memcmp(a, b, 340); }
static int _memcmp341(const void *a, const void *b) { return memcmp(a, b, 341); }
static int _memcmp342(const void *a, const void *b) { return memcmp(a, b, 342); }
static int _memcmp343(const void *a, const void *b) { return memcmp(a, b, 343); }
static int _memcmp344(const void *a, const void *b) { return memcmp(a, b, 344); }
static int _memcmp345(const void *a, const void *b) { return memcmp(a, b, 345); }
static int _memcmp346(const void *a, const void *b) { return memcmp(a, b, 346); }
static int _memcmp347(const void *a, const void *b) { return memcmp(a, b, 347); }
static int _memcmp348(const void *a, const void *b) { return memcmp(a, b, 348); }
static int _memcmp349(const void *a, const void *b) { return memcmp(a, b, 349); }
static int _memcmp350(const void *a, const void *b) { return memcmp(a, b, 350); }
static int _memcmp351(const void *a, const void *b) { return memcmp(a, b, 351); }
static int _memcmp352(const void *a, const void *b) { return memcmp(a, b, 352); }
static int _memcmp353(const void *a, const void *b) { return memcmp(a, b, 353); }
static int _memcmp354(const void *a, const void *b) { return memcmp(a, b, 354); }
static int _memcmp355(const void *a, const void *b) { return memcmp(a, b, 355); }
static int _memcmp356(const void *a, const void *b) { return memcmp(a, b, 356); }
static int _memcmp357(const void *a, const void *b) { return memcmp(a, b, 357); }
static int _memcmp358(const void *a, const void *b) { return memcmp(a, b, 358); }
static int _memcmp359(const void *a, const void *b) { return memcmp(a, b, 359); }
static int _memcmp360(const void *a, const void *b) { return memcmp(a, b, 360); }
static int _memcmp361(const void *a, const void *b) { return memcmp(a, b, 361); }
static int _memcmp362(const void *a, const void *b) { return memcmp(a, b, 362); }
static int _memcmp363(const void *a, const void *b) { return memcmp(a, b, 363); }
static int _memcmp364(const void *a, const void *b) { return memcmp(a, b, 364); }
static int _memcmp365(const void *a, const void *b) { return memcmp(a, b, 365); }
static int _memcmp366(const void *a, const void *b) { return memcmp(a, b, 366); }
static int _memcmp367(const void *a, const void *b) { return memcmp(a, b, 367); }
static int _memcmp368(const void *a, const void *b) { return memcmp(a, b, 368); }
static int _memcmp369(const void *a, const void *b) { return memcmp(a, b, 369); }
static int _memcmp370(const void *a, const void *b) { return memcmp(a, b, 370); }
static int _memcmp371(const void *a, const void *b) { return memcmp(a, b, 371); }
static int _memcmp372(const void *a, const void *b) { return memcmp(a, b, 372); }
static int _memcmp373(const void *a, const void *b) { return memcmp(a, b, 373); }
static int _memcmp374(const void *a, const void *b) { return memcmp(a, b, 374); }
static int _memcmp375(const void *a, const void *b) { return memcmp(a, b, 375); }
static int _memcmp376(const void *a, const void *b) { return memcmp(a, b, 376); }
static int _memcmp377(const void *a, const void *b) { return memcmp(a, b, 377); }
static int _memcmp378(const void *a, const void *b) { return memcmp(a, b, 378); }
static int _memcmp379(const void *a, const void *b) { return memcmp(a, b, 379); }
static int _memcmp380(const void *a, const void *b) { return memcmp(a, b, 380); }
static int _memcmp381(const void *a, const void *b) { return memcmp(a, b, 381); }
static int _memcmp382(const void *a, const void *b) { return memcmp(a, b, 382); }
static int _memcmp383(const void *a, const void *b) { return memcmp(a, b, 383); }
static int _memcmp384(const void *a, const void *b) { return memcmp(a, b, 384); }
static int _memcmp385(const void *a, const void *b) { return memcmp(a, b, 385); }
static int _memcmp386(const void *a, const void *b) { return memcmp(a, b, 386); }
static int _memcmp387(const void *a, const void *b) { return memcmp(a, b, 387); }
static int _memcmp388(const void *a, const void *b) { return memcmp(a, b, 388); }
static int _memcmp389(const void *a, const void *b) { return memcmp(a, b, 389); }
static int _memcmp390(const void *a, const void *b) { return memcmp(a, b, 390); }
static int _memcmp391(const void *a, const void *b) { return memcmp(a, b, 391); }
static int _memcmp392(const void *a, const void *b) { return memcmp(a, b, 392); }
static int _memcmp393(const void *a, const void *b) { return memcmp(a, b, 393); }
static int _memcmp394(const void *a, const void *b) { return memcmp(a, b, 394); }
static int _memcmp395(const void *a, const void *b) { return memcmp(a, b, 395); }
static int _memcmp396(const void *a, const void *b) { return memcmp(a, b, 396); }
static int _memcmp397(const void *a, const void *b) { return memcmp(a, b, 397); }
static int _memcmp398(const void *a, const void *b) { return memcmp(a, b, 398); }
static int _memcmp399(const void *a, const void *b) { return memcmp(a, b, 399); }
static int _memcmp400(const void *a, const void *b) { return memcmp(a, b, 400); }
static int _memcmp401(const void *a, const void *b) { return memcmp(a, b, 401); }
static int _memcmp402(const void *a, const void *b) { return memcmp(a, b, 402); }
static int _memcmp403(const void *a, const void *b) { return memcmp(a, b, 403); }
static int _memcmp404(const void *a, const void *b) { return memcmp(a, b, 404); }
static int _memcmp405(const void *a, const void *b) { return memcmp(a, b, 405); }
static int _memcmp406(const void *a, const void *b) { return memcmp(a, b, 406); }
static int _memcmp407(const void *a, const void *b) { return memcmp(a, b, 407); }
static int _memcmp408(const void *a, const void *b) { return memcmp(a, b, 408); }
static int _memcmp409(const void *a, const void *b) { return memcmp(a, b, 409); }
static int _memcmp410(const void *a, const void *b) { return memcmp(a, b, 410); }
static int _memcmp411(const void *a, const void *b) { return memcmp(a, b, 411); }
static int _memcmp412(const void *a, const void *b) { return memcmp(a, b, 412); }
static int _memcmp413(const void *a, const void *b) { return memcmp(a, b, 413); }
static int _memcmp414(const void *a, const void *b) { return memcmp(a, b, 414); }
static int _memcmp415(const void *a, const void *b) { return memcmp(a, b, 415); }
static int _memcmp416(const void *a, const void *b) { return memcmp(a, b, 416); }
static int _memcmp417(const void *a, const void *b) { return memcmp(a, b, 417); }
static int _memcmp418(const void *a, const void *b) { return memcmp(a, b, 418); }
static int _memcmp419(const void *a, const void *b) { return memcmp(a, b, 419); }
static int _memcmp420(const void *a, const void *b) { return memcmp(a, b, 420); }
static int _memcmp421(const void *a, const void *b) { return memcmp(a, b, 421); }
static int _memcmp422(const void *a, const void *b) { return memcmp(a, b, 422); }
static int _memcmp423(const void *a, const void *b) { return memcmp(a, b, 423); }
static int _memcmp424(const void *a, const void *b) { return memcmp(a, b, 424); }
static int _memcmp425(const void *a, const void *b) { return memcmp(a, b, 425); }
static int _memcmp426(const void *a, const void *b) { return memcmp(a, b, 426); }
static int _memcmp427(const void *a, const void *b) { return memcmp(a, b, 427); }
static int _memcmp428(const void *a, const void *b) { return memcmp(a, b, 428); }
static int _memcmp429(const void *a, const void *b) { return memcmp(a, b, 429); }
static int _memcmp430(const void *a, const void *b) { return memcmp(a, b, 430); }
static int _memcmp431(const void *a, const void *b) { return memcmp(a, b, 431); }
static int _memcmp432(const void *a, const void *b) { return memcmp(a, b, 432); }
static int _memcmp433(const void *a, const void *b) { return memcmp(a, b, 433); }
static int _memcmp434(const void *a, const void *b) { return memcmp(a, b, 434); }
static int _memcmp435(const void *a, const void *b) { return memcmp(a, b, 435); }
static int _memcmp436(const void *a, const void *b) { return memcmp(a, b, 436); }
static int _memcmp437(const void *a, const void *b) { return memcmp(a, b, 437); }
static int _memcmp438(const void *a, const void *b) { return memcmp(a, b, 438); }
static int _memcmp439(const void *a, const void *b) { return memcmp(a, b, 439); }
static int _memcmp440(const void *a, const void *b) { return memcmp(a, b, 440); }
static int _memcmp441(const void *a, const void *b) { return memcmp(a, b, 441); }
static int _memcmp442(const void *a, const void *b) { return memcmp(a, b, 442); }
static int _memcmp443(const void *a, const void *b) { return memcmp(a, b, 443); }
static int _memcmp444(const void *a, const void *b) { return memcmp(a, b, 444); }
static int _memcmp445(const void *a, const void *b) { return memcmp(a, b, 445); }
static int _memcmp446(const void *a, const void *b) { return memcmp(a, b, 446); }
static int _memcmp447(const void *a, const void *b) { return memcmp(a, b, 447); }
static int _memcmp448(const void *a, const void *b) { return memcmp(a, b, 448); }
static int _memcmp449(const void *a, const void *b) { return memcmp(a, b, 449); }
static int _memcmp450(const void *a, const void *b) { return memcmp(a, b, 450); }
static int _memcmp451(const void *a, const void *b) { return memcmp(a, b, 451); }
static int _memcmp452(const void *a, const void *b) { return memcmp(a, b, 452); }
static int _memcmp453(const void *a, const void *b) { return memcmp(a, b, 453); }
static int _memcmp454(const void *a, const void *b) { return memcmp(a, b, 454); }
static int _memcmp455(const void *a, const void *b) { return memcmp(a, b, 455); }
static int _memcmp456(const void *a, const void *b) { return memcmp(a, b, 456); }
static int _memcmp457(const void *a, const void *b) { return memcmp(a, b, 457); }
static int _memcmp458(const void *a, const void *b) { return memcmp(a, b, 458); }
static int _memcmp459(const void *a, const void *b) { return memcmp(a, b, 459); }
static int _memcmp460(const void *a, const void *b) { return memcmp(a, b, 460); }
static int _memcmp461(const void *a, const void *b) { return memcmp(a, b, 461); }
static int _memcmp462(const void *a, const void *b) { return memcmp(a, b, 462); }
static int _memcmp463(const void *a, const void *b) { return memcmp(a, b, 463); }
static int _memcmp464(const void *a, const void *b) { return memcmp(a, b, 464); }
static int _memcmp465(const void *a, const void *b) { return memcmp(a, b, 465); }
static int _memcmp466(const void *a, const void *b) { return memcmp(a, b, 466); }
static int _memcmp467(const void *a, const void *b) { return memcmp(a, b, 467); }
static int _memcmp468(const void *a, const void *b) { return memcmp(a, b, 468); }
static int _memcmp469(const void *a, const void *b) { return memcmp(a, b, 469); }
static int _memcmp470(const void *a, const void *b) { return memcmp(a, b, 470); }
static int _memcmp471(const void *a, const void *b) { return memcmp(a, b, 471); }
static int _memcmp472(const void *a, const void *b) { return memcmp(a, b, 472); }
static int _memcmp473(const void *a, const void *b) { return memcmp(a, b, 473); }
static int _memcmp474(const void *a, const void *b) { return memcmp(a, b, 474); }
static int _memcmp475(const void *a, const void *b) { return memcmp(a, b, 475); }
static int _memcmp476(const void *a, const void *b) { return memcmp(a, b, 476); }
static int _memcmp477(const void *a, const void *b) { return memcmp(a, b, 477); }
static int _memcmp478(const void *a, const void *b) { return memcmp(a, b, 478); }
static int _memcmp479(const void *a, const void *b) { return memcmp(a, b, 479); }
static int _memcmp480(const void *a, const void *b) { return memcmp(a, b, 480); }
static int _memcmp481(const void *a, const void *b) { return memcmp(a, b, 481); }
static int _memcmp482(const void *a, const void *b) { return memcmp(a, b, 482); }
static int _memcmp483(const void *a, const void *b) { return memcmp(a, b, 483); }
static int _memcmp484(const void *a, const void *b) { return memcmp(a, b, 484); }
static int _memcmp485(const void *a, const void *b) { return memcmp(a, b, 485); }
static int _memcmp486(const void *a, const void *b) { return memcmp(a, b, 486); }
static int _memcmp487(const void *a, const void *b) { return memcmp(a, b, 487); }
static int _memcmp488(const void *a, const void *b) { return memcmp(a, b, 488); }
static int _memcmp489(const void *a, const void *b) { return memcmp(a, b, 489); }
static int _memcmp490(const void *a, const void *b) { return memcmp(a, b, 490); }
static int _memcmp491(const void *a, const void *b) { return memcmp(a, b, 491); }
static int _memcmp492(const void *a, const void *b) { return memcmp(a, b, 492); }
static int _memcmp493(const void *a, const void *b) { return memcmp(a, b, 493); }
static int _memcmp494(const void *a, const void *b) { return memcmp(a, b, 494); }
static int _memcmp495(const void *a, const void *b) { return memcmp(a, b, 495); }
static int _memcmp496(const void *a, const void *b) { return memcmp(a, b, 496); }
static int _memcmp497(const void *a, const void *b) { return memcmp(a, b, 497); }
static int _memcmp498(const void *a, const void *b) { return memcmp(a, b, 498); }
static int _memcmp499(const void *a, const void *b) { return memcmp(a, b, 499); }
static int _memcmp500(const void *a, const void *b) { return memcmp(a, b, 500); }
static int _memcmp501(const void *a, const void *b) { return memcmp(a, b, 501); }
static int _memcmp502(const void *a, const void *b) { return memcmp(a, b, 502); }
static int _memcmp503(const void *a, const void *b) { return memcmp(a, b, 503); }
static int _memcmp504(const void *a, const void *b) { return memcmp(a, b, 504); }
static int _memcmp505(const void *a, const void *b) { return memcmp(a, b, 505); }
static int _memcmp506(const void *a, const void *b) { return memcmp(a, b, 506); }
static int _memcmp507(const void *a, const void *b) { return memcmp(a, b, 507); }
static int _memcmp508(const void *a, const void *b) { return memcmp(a, b, 508); }
static int _memcmp509(const void *a, const void *b) { return memcmp(a, b, 509); }
static int _memcmp510(const void *a, const void *b) { return memcmp(a, b, 510); }
static int _memcmp511(const void *a, const void *b) { return memcmp(a, b, 511); }
static int _memcmp512(const void *a, const void *b) { return memcmp(a, b, 512); }
static CSTL_COMPARE _memcmp_funcs[513] = {
    NULL,
    _memcmp1,
    _memcmp2,
    _memcmp3,
    _memcmp4,
    _memcmp5,
    _memcmp6,
    _memcmp7,
    _memcmp8,
    _memcmp9,
    _memcmp10,
    _memcmp11,
    _memcmp12,
    _memcmp13,
    _memcmp14,
    _memcmp15,
    _memcmp16,
    _memcmp17,
    _memcmp18,
    _memcmp19,
    _memcmp20,
    _memcmp21,
    _memcmp22,
    _memcmp23,
    _memcmp24,
    _memcmp25,
    _memcmp26,
    _memcmp27,
    _memcmp28,
    _memcmp29,
    _memcmp30,
    _memcmp31,
    _memcmp32,
    _memcmp33,
    _memcmp34,
    _memcmp35,
    _memcmp36,
    _memcmp37,
    _memcmp38,
    _memcmp39,
    _memcmp40,
    _memcmp41,
    _memcmp42,
    _memcmp43,
    _memcmp44,
    _memcmp45,
    _memcmp46,
    _memcmp47,
    _memcmp48,
    _memcmp49,
    _memcmp50,
    _memcmp51,
    _memcmp52,
    _memcmp53,
    _memcmp54,
    _memcmp55,
    _memcmp56,
    _memcmp57,
    _memcmp58,
    _memcmp59,
    _memcmp60,
    _memcmp61,
    _memcmp62,
    _memcmp63,
    _memcmp64,
    _memcmp65,
    _memcmp66,
    _memcmp67,
    _memcmp68,
    _memcmp69,
    _memcmp70,
    _memcmp71,
    _memcmp72,
    _memcmp73,
    _memcmp74,
    _memcmp75,
    _memcmp76,
    _memcmp77,
    _memcmp78,
    _memcmp79,
    _memcmp80,
    _memcmp81,
    _memcmp82,
    _memcmp83,
    _memcmp84,
    _memcmp85,
    _memcmp86,
    _memcmp87,
    _memcmp88,
    _memcmp89,
    _memcmp90,
    _memcmp91,
    _memcmp92,
    _memcmp93,
    _memcmp94,
    _memcmp95,
    _memcmp96,
    _memcmp97,
    _memcmp98,
    _memcmp99,
    _memcmp100,
    _memcmp101,
    _memcmp102,
    _memcmp103,
    _memcmp104,
    _memcmp105,
    _memcmp106,
    _memcmp107,
    _memcmp108,
    _memcmp109,
    _memcmp110,
    _memcmp111,
    _memcmp112,
    _memcmp113,
    _memcmp114,
    _memcmp115,
    _memcmp116,
    _memcmp117,
    _memcmp118,
    _memcmp119,
    _memcmp120,
    _memcmp121,
    _memcmp122,
    _memcmp123,
    _memcmp124,
    _memcmp125,
    _memcmp126,
    _memcmp127,
    _memcmp128,
    _memcmp129,
    _memcmp130,
    _memcmp131,
    _memcmp132,
    _memcmp133,
    _memcmp134,
    _memcmp135,
    _memcmp136,
    _memcmp137,
    _memcmp138,
    _memcmp139,
    _memcmp140,
    _memcmp141,
    _memcmp142,
    _memcmp143,
    _memcmp144,
    _memcmp145,
    _memcmp146,
    _memcmp147,
    _memcmp148,
    _memcmp149,
    _memcmp150,
    _memcmp151,
    _memcmp152,
    _memcmp153,
    _memcmp154,
    _memcmp155,
    _memcmp156,
    _memcmp157,
    _memcmp158,
    _memcmp159,
    _memcmp160,
    _memcmp161,
    _memcmp162,
    _memcmp163,
    _memcmp164,
    _memcmp165,
    _memcmp166,
    _memcmp167,
    _memcmp168,
    _memcmp169,
    _memcmp170,
    _memcmp171,
    _memcmp172,
    _memcmp173,
    _memcmp174,
    _memcmp175,
    _memcmp176,
    _memcmp177,
    _memcmp178,
    _memcmp179,
    _memcmp180,
    _memcmp181,
    _memcmp182,
    _memcmp183,
    _memcmp184,
    _memcmp185,
    _memcmp186,
    _memcmp187,
    _memcmp188,
    _memcmp189,
    _memcmp190,
    _memcmp191,
    _memcmp192,
    _memcmp193,
    _memcmp194,
    _memcmp195,
    _memcmp196,
    _memcmp197,
    _memcmp198,
    _memcmp199,
    _memcmp200,
    _memcmp201,
    _memcmp202,
    _memcmp203,
    _memcmp204,
    _memcmp205,
    _memcmp206,
    _memcmp207,
    _memcmp208,
    _memcmp209,
    _memcmp210,
    _memcmp211,
    _memcmp212,
    _memcmp213,
    _memcmp214,
    _memcmp215,
    _memcmp216,
    _memcmp217,
    _memcmp218,
    _memcmp219,
    _memcmp220,
    _memcmp221,
    _memcmp222,
    _memcmp223,
    _memcmp224,
    _memcmp225,
    _memcmp226,
    _memcmp227,
    _memcmp228,
    _memcmp229,
    _memcmp230,
    _memcmp231,
    _memcmp232,
    _memcmp233,
    _memcmp234,
    _memcmp235,
    _memcmp236,
    _memcmp237,
    _memcmp238,
    _memcmp239,
    _memcmp240,
    _memcmp241,
    _memcmp242,
    _memcmp243,
    _memcmp244,
    _memcmp245,
    _memcmp246,
    _memcmp247,
    _memcmp248,
    _memcmp249,
    _memcmp250,
    _memcmp251,
    _memcmp252,
    _memcmp253,
    _memcmp254,
    _memcmp255,
    _memcmp256,
    _memcmp257,
    _memcmp258,
    _memcmp259,
    _memcmp260,
    _memcmp261,
    _memcmp262,
    _memcmp263,
    _memcmp264,
    _memcmp265,
    _memcmp266,
    _memcmp267,
    _memcmp268,
    _memcmp269,
    _memcmp270,
    _memcmp271,
    _memcmp272,
    _memcmp273,
    _memcmp274,
    _memcmp275,
    _memcmp276,
    _memcmp277,
    _memcmp278,
    _memcmp279,
    _memcmp280,
    _memcmp281,
    _memcmp282,
    _memcmp283,
    _memcmp284,
    _memcmp285,
    _memcmp286,
    _memcmp287,
    _memcmp288,
    _memcmp289,
    _memcmp290,
    _memcmp291,
    _memcmp292,
    _memcmp293,
    _memcmp294,
    _memcmp295,
    _memcmp296,
    _memcmp297,
    _memcmp298,
    _memcmp299,
    _memcmp300,
    _memcmp301,
    _memcmp302,
    _memcmp303,
    _memcmp304,
    _memcmp305,
    _memcmp306,
    _memcmp307,
    _memcmp308,
    _memcmp309,
    _memcmp310,
    _memcmp311,
    _memcmp312,
    _memcmp313,
    _memcmp314,
    _memcmp315,
    _memcmp316,
    _memcmp317,
    _memcmp318,
    _memcmp319,
    _memcmp320,
    _memcmp321,
    _memcmp322,
    _memcmp323,
    _memcmp324,
    _memcmp325,
    _memcmp326,
    _memcmp327,
    _memcmp328,
    _memcmp329,
    _memcmp330,
    _memcmp331,
    _memcmp332,
    _memcmp333,
    _memcmp334,
    _memcmp335,
    _memcmp336,
    _memcmp337,
    _memcmp338,
    _memcmp339,
    _memcmp340,
    _memcmp341,
    _memcmp342,
    _memcmp343,
    _memcmp344,
    _memcmp345,
    _memcmp346,
    _memcmp347,
    _memcmp348,
    _memcmp349,
    _memcmp350,
    _memcmp351,
    _memcmp352,
    _memcmp353,
    _memcmp354,
    _memcmp355,
    _memcmp356,
    _memcmp357,
    _memcmp358,
    _memcmp359,
    _memcmp360,
    _memcmp361,
    _memcmp362,
    _memcmp363,
    _memcmp364,
    _memcmp365,
    _memcmp366,
    _memcmp367,
    _memcmp368,
    _memcmp369,
    _memcmp370,
    _memcmp371,
    _memcmp372,
    _memcmp373,
    _memcmp374,
    _memcmp375,
    _memcmp376,
    _memcmp377,
    _memcmp378,
    _memcmp379,
    _memcmp380,
    _memcmp381,
    _memcmp382,
    _memcmp383,
    _memcmp384,
    _memcmp385,
    _memcmp386,
    _memcmp387,
    _memcmp388,
    _memcmp389,
    _memcmp390,
    _memcmp391,
    _memcmp392,
    _memcmp393,
    _memcmp394,
    _memcmp395,
    _memcmp396,
    _memcmp397,
    _memcmp398,
    _memcmp399,
    _memcmp400,
    _memcmp401,
    _memcmp402,
    _memcmp403,
    _memcmp404,
    _memcmp405,
    _memcmp406,
    _memcmp407,
    _memcmp408,
    _memcmp409,
    _memcmp410,
    _memcmp411,
    _memcmp412,
    _memcmp413,
    _memcmp414,
    _memcmp415,
    _memcmp416,
    _memcmp417,
    _memcmp418,
    _memcmp419,
    _memcmp420,
    _memcmp421,
    _memcmp422,
    _memcmp423,
    _memcmp424,
    _memcmp425,
    _memcmp426,
    _memcmp427,
    _memcmp428,
    _memcmp429,
    _memcmp430,
    _memcmp431,
    _memcmp432,
    _memcmp433,
    _memcmp434,
    _memcmp435,
    _memcmp436,
    _memcmp437,
    _memcmp438,
    _memcmp439,
    _memcmp440,
    _memcmp441,
    _memcmp442,
    _memcmp443,
    _memcmp444,
    _memcmp445,
    _memcmp446,
    _memcmp447,
    _memcmp448,
    _memcmp449,
    _memcmp450,
    _memcmp451,
    _memcmp452,
    _memcmp453,
    _memcmp454,
    _memcmp455,
    _memcmp456,
    _memcmp457,
    _memcmp458,
    _memcmp459,
    _memcmp460,
    _memcmp461,
    _memcmp462,
    _memcmp463,
    _memcmp464,
    _memcmp465,
    _memcmp466,
    _memcmp467,
    _memcmp468,
    _memcmp469,
    _memcmp470,
    _memcmp471,
    _memcmp472,
    _memcmp473,
    _memcmp474,
    _memcmp475,
    _memcmp476,
    _memcmp477,
    _memcmp478,
    _memcmp479,
    _memcmp480,
    _memcmp481,
    _memcmp482,
    _memcmp483,
    _memcmp484,
    _memcmp485,
    _memcmp486,
    _memcmp487,
    _memcmp488,
    _memcmp489,
    _memcmp490,
    _memcmp491,
    _memcmp492,
    _memcmp493,
    _memcmp494,
    _memcmp495,
    _memcmp496,
    _memcmp497,
    _memcmp498,
    _memcmp499,
    _memcmp500,
    _memcmp501,
    _memcmp502,
    _memcmp503,
    _memcmp504,
    _memcmp505,
    _memcmp506,
    _memcmp507,
    _memcmp508,
    _memcmp509,
    _memcmp510,
    _memcmp511,
    _memcmp512,
};
#endif
typedef const void *CVP;
#define _SAFE_COMPARE(TYPE,X,Y)  (*(TYPE *) (X) > *(TYPE *) (Y)) - (*(TYPE *) (X) < *(TYPE *) (Y))
static int less_int32(CVP a, CVP b) {
    return _SAFE_COMPARE(int, a, b);
}
static int less_uint32(CVP a, CVP b) {
    return _SAFE_COMPARE(unsigned int, a, b);
}
static int less_int64(CVP a, CVP b) {
    return _SAFE_COMPARE(long long, a, b);
}
static int less_uint64(CVP a, CVP b) {
    return _SAFE_COMPARE(unsigned long long, a, b);
}
static int less_float(CVP a, CVP b) {
    return (*(float *) a > *(float *) b) - (*(float *) a < *(float *) b);
}
static int less_double(CVP a, CVP b) {
    return (*(double *) a > *(double *) b) - (*(double *) a < *(double *) b);
}
static int less_string(CVP a, CVP b) {
    return strcmp(*(char **) a, *(char **) b);
}
static int greater_int32(CVP a, CVP b) {
    return less_int32(b, a);
}
static int greater_uint32(CVP a, CVP b) {
    return less_uint32(b, a);
}
static int greater_int64(CVP a, CVP b) {
    return less_int64(b, a);
}
static int greater_uint64(CVP a, CVP b) {
    return less_uint64(b, a);
}
static int greater_float(CVP a, CVP b) {
    return less_float(b, a);
}
static int greater_double(CVP a, CVP b) {
    return less_double(b, a);
}
static int greater_string(CVP a, CVP b) {
    return less_string(b, a);
}
static CSTL_COMPARE CSTL_LESS(const char *type_str) {
    while (*type_str == ' ') type_str++;
    const char *end = type_str + strlen(type_str);
    while (end > type_str && *(end - 1) == ' ') end--;
    char buf[256];
    size_type64 len = end - type_str;
    if (len >= sizeof(buf)) return NULL;
    memcpy(buf, type_str, len);
    buf[len] = '\0';
    if (strcmp(buf, "float") == 0) return less_float;
    if (strcmp(buf, "double") == 0) return less_double;
    if (strcmp(buf, "int") == 0) return less_int32;
    if (strcmp(buf, "long long") == 0) return less_int64;
    if (strcmp(buf, "unsigned long long") == 0) return less_uint64;
    if (strcmp(buf, "unsigned int") == 0) return less_uint32;
    if (strcmp(buf, "char*") == 0) return less_string;
    if (strcmp(buf, "char *") == 0) return less_string;
    return NULL;
}
static CSTL_COMPARE CSTL_GREATER(const char *type_str) {
    while (*type_str == ' ') type_str++;
    const char *end = type_str + strlen(type_str);
    while (end > type_str && *(end - 1) == ' ') end--;
    char buf[256];
    size_type64 len = end - type_str;
    if (len >= sizeof(buf)) return NULL;
    memcpy(buf, type_str, len);
    buf[len] = '\0';
    if (strcmp(buf, "float") == 0) return greater_float;
    if (strcmp(buf, "double") == 0) return greater_double;
    if (strcmp(buf, "int") == 0) return greater_int32;
    if (strcmp(buf, "long long") == 0) return greater_int64;
    if (strcmp(buf, "unsigned long long") == 0) return greater_uint64;
    if (strcmp(buf, "unsigned int") == 0) return greater_uint32;
    if (strcmp(buf, "char*") == 0) return greater_string;
    if (strcmp(buf, "char *") == 0) return greater_string;
    return NULL;
}
#define LESS(TYPE)    CSTL_LESS(#TYPE)
#define GREATER(TYPE) CSTL_GREATER(#TYPE)
#define CSTL_FLOAT_EPS   1e-6f
#define CSTL_DOUBLE_EPS  1e-9
static int _cstl_equals_float(CVP a, CVP b, size_t dummy) {
    float a1 = *(float *) a;
    float b1 = *(float *) b;
    float diff = a1 - b1;
    if (diff < 0)diff = -diff;
    return diff < CSTL_FLOAT_EPS;
}
static int _cstl_equals_double(CVP a, CVP b, size_t dummy) {
    double a1 = *(double *) a;
    double b1 = *(double *) b;
    double diff = a1 - b1;
    if (diff < 0)diff = -diff;
    return diff < CSTL_DOUBLE_EPS;
}
static int _cstl_equals_str(CVP a, CVP b, size_t dummy) {
    return strcmp(*(char **) a, *(char **) b) == 0;
}
static CSTL_COMPARE_BYTES CSTL_EQUALS(const char *type_str) {
    while (*type_str == ' ') type_str++;
    const char *end = type_str + strlen(type_str);
    while (end > type_str && *(end - 1) == ' ') end--;
    char buf[256];
    size_type64 len = end - type_str;
    if (len >= sizeof(buf)) return NULL;
    memcpy(buf, type_str, len);
    buf[len] = '\0';
    if (strcmp(buf, "float") == 0) return _cstl_equals_float;
    if (strcmp(buf, "double") == 0) return _cstl_equals_double;
    if (strcmp(buf, "char*") == 0) return _cstl_equals_str;
    if (strcmp(buf, "char *") == 0) return _cstl_equals_str;
    return memcmp;
}
#endif
OPENCSTL_FUNC ptrdiff_t __is_deque(void **container) {
    if (OPENCSTL_NIDX(container, -1) < 0)
        return 1;
    return 0;
}
OPENCSTL_FUNC size_type64 __opencstl_container_type(void **container, ptrdiff_t *distance) {
    *distance = 0;
    if (iveb == NULL) return 0;
    Interval *it = iveb_find(iveb, *container);
    if (it == NULL) return 0;
    if (it->ctype == CT_DEQUE) {
        *distance = OPENCSTL_NIDX(container, -1) + 1;
    }
    return *(_opencstl_ll_ua *) ((char *) *container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + *distance);
}
#define cstl_deque(TYPE) __cstl_deque(sizeof(TYPE),#TYPE)
OPENCSTL_FUNC void *__cstl_deque(size_type64 type_size, char *type) {
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    void *block = calloc(header_sz + type_size * 2, 1);
    verify(block != NULL);
    void *ptr = (char *) block + header_sz;
    void **container = &ptr;
    OPENCSTL_NIDX(container, NIDX_CTYPE) = OPENCSTL_DEQUE;
    OPENCSTL_NIDX(container, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(container, NIDX_TSIZE) = type_size;
    OPENCSTL_NIDX(container, -8) = !strcmp(type, "float");
    OPENCSTL_NIDX(container, -4) = (size_type64) type;
    OPENCSTL_NIDX(container, -3) = 2;
    OPENCSTL_NIDX(container, -2) = 0;
    void *buf_start = ptr;
    *container = (char *) ptr + type_size;
    OPENCSTL_NIDX(container, -1) = -type_size - 1;
    bool iveb_init = false;
    if (iveb == NULL) {
        iveb = iveb_new();
        iveb_init = true;
    }
    iveb_insert(iveb, buf_start, (char *) buf_start + (type_size * 2), CT_DEQUE, type_size, type);
    if (iveb_init) {
        atexit(__opencstl_iveb_destroy);
    }
    return ptr;
}
OPENCSTL_FUNC void __cstl_deque_assign(void **container, size_type64 n, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 header_sz = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_HSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 capacity = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance);
    char *type = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    capacity = n;
    iveb_erase(iveb, (char *) *container + distance);
    void *b = calloc(1, header_sz + capacity * type_size);
    memcpy(b, (char *) *container - header_sz + distance, header_sz);
    free(((char *) *container) - header_sz + distance);
    *container = ((char *) b) + header_sz;
    OPENCSTL_NIDX(container, -1) = -1;
    distance = 0;
    *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance) = n;
    *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance) = n;
    iveb_insert(iveb, *container, (char *) (*container) + (type_size * n), CT_DEQUE, type_size, type);
    if (value == NULL) {
        memset((char *) *container, 0, n * type_size);
    } else {
        for (size_type64 i = 0; i < n; i++) {
            memcpy((char *) *container + type_size * (i), value, type_size);
        }
    }
}
OPENCSTL_FUNC void __cstl_deque_push_back(void **container, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 header_sz = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_HSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 capacity = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance);
    char *type = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-8) * (ptrdiff_t) sizeof(size_type64) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (length == capacity + distance / (ptrdiff_t) type_size) {
        size_type64 distance_sz = -distance;
        size_type64 new_capacity = capacity * 2;
        iveb_erase(iveb, (char *) *container + distance);
        void *b = calloc(1, header_sz + new_capacity * type_size);
        memcpy(b, (char *) *container - (header_sz + distance_sz), header_sz);
        distance = new_capacity / 4;
        memcpy((char *) b + header_sz + distance * type_size, *container, length * type_size);
        free((char *) *container - (header_sz + distance_sz));
        *container = ((char *) b + (header_sz + distance * type_size));
        distance = -distance * type_size;
        *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance) *= 2;
        OPENCSTL_NIDX(container, -1) = distance - 1;
        iveb_insert(iveb, (char *) *container + distance,
                    (char *) *container + distance + (type_size * new_capacity), CT_DEQUE, type_size, type);
    }
    memcpy((char *) *container + type_size * length, value, type_size);
    (*(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance))++;
}
OPENCSTL_FUNC void __cstl_deque_push_front(void **container, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 header_sz = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_HSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 capacity = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance);
    char *type = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-8) * (ptrdiff_t) sizeof(size_type64) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (distance == 0) {
        size_type64 new_capacity = capacity * 2;
        iveb_erase(iveb, (char *) *container);
        void *b = calloc(1, header_sz + new_capacity * type_size);
        memcpy(b, (char *) *container - header_sz, header_sz);
        distance = new_capacity / 4;
        memcpy((char *) b + header_sz + distance * type_size, *container, length * type_size);
        free((char *) *container - header_sz);
        *container = ((char *) b + (header_sz + distance * type_size));
        distance = -distance * type_size;
        *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance) *= 2;
        iveb_insert(iveb, (char *) *container + distance,
                    (char *) *container + distance + (type_size * new_capacity), CT_DEQUE, type_size, type);
    }
    memcpy((char *) *container - type_size * 2, (char *) *container - type_size, type_size);
    memcpy((char *) *container - type_size, value, type_size);
    *container = (char *) *container - type_size;
    OPENCSTL_NIDX(container, -1) = distance + type_size - 1;
    *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance + type_size) += 1;
}
OPENCSTL_FUNC void __cstl_deque_pop_back(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    verify(length > 0);
    *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance) -= 1;
}
OPENCSTL_FUNC void __cstl_deque_pop_front(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    verify(*(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t)(-2) * (ptrdiff_t)sizeof(size_type64) + distance - type_size) > 0);
    memcpy(*container, (char *) *container - type_size, type_size);
    *container = (char *) *container + type_size;
    OPENCSTL_NIDX(container, -1) = distance - type_size - 1;
    *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance - type_size) -= 1;
}
OPENCSTL_FUNC void __cstl_deque_insert(void **container, void *it, size_type64 n, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 header_sz = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_HSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 capacity = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance);
    char *type = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-8) * (ptrdiff_t) sizeof(size_type64) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    size_type64 pos = (*(char **) it - *(char **) container) / type_size;
    if (length + n > capacity + distance / (ptrdiff_t) type_size) {
        iveb_erase(iveb, (char *) *container + distance);
        capacity += n;
        size_type64 alloc_sz = header_sz + capacity * type_size - distance;
        void *b = realloc((char *) *container - header_sz + distance, alloc_sz);
        *container = (char *) b + header_sz - distance;
        *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance) += n;
        iveb_insert(iveb, (char *) *container + distance,
                    (char *) b + alloc_sz, CT_DEQUE, type_size, type);
    }
    memcpy((char *) *container + (pos + n) * type_size, (char *) *container + pos * type_size,
           (length - pos) * type_size);
    for (size_type64 i = 0; i < n; i++) {
        memcpy((char *) *container + (pos + i) * type_size, value, type_size);
    }
    *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance) += n;
}
OPENCSTL_FUNC void __cstl_deque_erase(void **container, void *begin, void *end) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 pos = (*(char **) end - *(char **) begin) / type_size;
    memmove(*(char **) begin, *(char **) end, (char *) *container + (length + 1) * type_size - *(char **) end);
    *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance) -= pos;
}
OPENCSTL_FUNC size_type __cstl_deque_size(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    return (size_type) (*(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance));
}
OPENCSTL_FUNC size_type __cstl_deque_capacity(void **container) {
    size_type64 capacity = OPENCSTL_NIDX(container, -3);
    return (size_type) capacity;
}
OPENCSTL_FUNC void __cstl_deque_resize(void **container, size_type64 n, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 header_sz = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_HSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 capacity = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance);
    char *type = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-8) * (ptrdiff_t) sizeof(size_type64) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (capacity + distance / (ptrdiff_t) type_size < n) {
        capacity = n;
        iveb_erase(iveb, (char *) *container + distance);
        void *b = calloc(1, header_sz + capacity * type_size);
        memcpy(b, (char *) *container - header_sz + distance, header_sz);
        memcpy((char *) b + header_sz, *container, length * type_size);
        free((char *) *container - header_sz + distance);
        *container = (char *) b + header_sz;
        OPENCSTL_NIDX(container, -1) = -1;
        distance = 0;
        *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance) = n;
        iveb_insert(iveb, *container, (char *) (*container) + (type_size * n), CT_DEQUE, type_size, type);
    }
    *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance) = n;
    if (length < n) {
        if (*(void **) value == NULL) {
            memset((char *) *container + length * type_size, 0, (n - length) * type_size);
        } else {
            for (size_type64 i = length; i < n; i++) {
                memcpy((char *) *container + i * type_size, value, type_size);
            }
        }
    }
}
OPENCSTL_FUNC void *__cstl_deque_begin(void **container) {
    return *container;
}
OPENCSTL_FUNC void *__cstl_deque_end(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    return (char *) *container + length * type_size;
}
OPENCSTL_FUNC void *__cstl_deque_rbegin(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    return (char *) *container + (length - 1) * type_size;
}
OPENCSTL_FUNC void *__cstl_deque_rend(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    return (char *) *container - type_size;
}
OPENCSTL_FUNC void __cstl_deque_clear(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance) = 0;
}
OPENCSTL_FUNC void __cstl_deque_free(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 header_sz = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_HSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    iveb_erase(iveb, (char *) *container + distance);
    free((char *) *container - (header_sz - distance));
}
OPENCSTL_FUNC void *__cstl_deque_find(void **container, void *iter_begin, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-8) * (ptrdiff_t) sizeof(size_type64) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    size_type64 pos = (*(char **) iter_begin - *(char **) container) / type_size;
    for (size_type64 i = pos; i < length; i++) {
        if (memcmp((char *) *container + type_size * (i), value, type_size) == 0) {
            return (char *) *container + type_size * (i);
        }
    }
    return NULL;
}
OPENCSTL_FUNC size_type __cstl_deque_max_size(void **container) {
    return INT_MAX;
}
OPENCSTL_FUNC void __cstl_deque_shrink_to_fit(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 header_sz = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_HSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 capacity = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-3) * (ptrdiff_t) sizeof(size_type64) + distance);
    char *type = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
    if (length == capacity && distance == 0) {
        return;
    }
    size_type64 new_capacity = length > 0 ? length : 1;
    iveb_erase(iveb, (char *) *container + distance);
    void *b = calloc(1, header_sz + new_capacity * type_size);
    verify(b != NULL);
    memcpy(b, (char *) *container - header_sz + distance, header_sz);
    memcpy((char *) b + header_sz, *container, length * type_size);
    free((char *) *container - header_sz + distance);
    *container = (char *) b + header_sz;
    OPENCSTL_NIDX(container, -1) = -1;
    OPENCSTL_NIDX(container, -3) = new_capacity;
    OPENCSTL_NIDX(container, -2) = length;
    iveb_insert(iveb, *container,
                (char *) *container + (type_size * new_capacity),
                CT_DEQUE, type_size, type);
}
OPENCSTL_FUNC void __cstl_deque_reverse(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    if (length < 2) {
        return;
    }
    unsigned char stackbuf[128];
    unsigned char *tmp = (type_size <= sizeof(stackbuf))
                             ? stackbuf
                             : (unsigned char *) calloc(type_size, 1);
    verify(tmp != NULL);
    char *base = (char *) *container;
    for (size_type64 i = 0, j = length - 1; i < j; i++, j--) {
        memcpy(tmp, base + i * type_size, type_size);
        memcpy(base + i * type_size, base + j * type_size, type_size);
        memcpy(base + j * type_size, tmp, type_size);
    }
    if (tmp != stackbuf) {
        free(tmp);
    }
}
OPENCSTL_FUNC size_type64 __cstl_deque_count(void **container, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    char *type = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-8) * (ptrdiff_t) sizeof(size_type64) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    CSTL_EQUALS_FN is_equal = CSTL_EQUALS(type);
    size_type64 cnt = 0;
    for (size_type64 i = 0; i < length; i++) {
        void *ptr = (char *) *container + (type_size * i);
        if (is_equal(ptr, value, type_size) == 0) {
            cnt++;
        }
    }
    return cnt;
}
OPENCSTL_FUNC size_type64 __cstl_deque_count_if(void **container, CSTL_COND cond) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 cnt = 0;
    for (size_type64 i = 0; i < length; i++) {
        void *ptr = (char *) *container + (type_size * i);
        if (cond(ptr)) {
            cnt++;
        }
    }
    return cnt;
}
OPENCSTL_FUNC void *__cstl_deque_lower_bound(void **container, void *value, CSTL_COMPARE compare) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-8) * (ptrdiff_t) sizeof(size_type64) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (length == 0) return NULL;
    size_type64 L = 0;
    size_type64 R = length;
    while (L < R) {
        size_type64 M = L + (R - L) / 2;
        void *Mptr = ((char *) *container) + (type_size * M);
        if (compare(Mptr, value) < 0)
            L = M + 1;
        else
            R = M;
    }
    if (L >= length) return NULL;
    return ((char *) *container) + (type_size * L);
}
OPENCSTL_FUNC void *__cstl_deque_upper_bound(void **container, void *value, CSTL_COMPARE compare) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-8) * (ptrdiff_t) sizeof(size_type64) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (length == 0) return NULL;
    size_type64 L = 0;
    size_type64 R = length;
    while (L < R) {
        size_type64 M = L + (R - L) / 2;
        void *Mptr = ((char *) *container) + (type_size * M);
        if (compare(value, Mptr) < 0)
            R = M;
        else
            L = M + 1;
    }
    if (L >= length) return NULL;
    return ((char *) *container) + (type_size * L);
}
#endif
#if !defined(_OPENCSTL_VECTOR_H)
#define _OPENCSTL_VECTOR_H
#ifndef OPENCSTL_SWAP_H
#define OPENCSTL_SWAP_H
#include <stddef.h>
#include <string.h>
#include <stdint.h>
#define SWAP_STACK_BUF_SIZE 256
static void swap(void *a, void *b, size_type64 sz) {
    unsigned char stack_buf[SWAP_STACK_BUF_SIZE];
    unsigned char *tmp;
    size_type64 i;
    if (a == NULL || b == NULL || a == b || sz == 0) {
        return;
    }
    if (sz <= SWAP_STACK_BUF_SIZE) {
        tmp = stack_buf;
        memcpy(tmp, a, sz);
        memcpy(a, b, sz);
        memcpy(b, tmp, sz);
    } else {
        unsigned char *pa = (unsigned char *) a;
        unsigned char *pb = (unsigned char *) b;
        for (i = 0; i < sz; ++i) {
            unsigned char t = pa[i];
            pa[i] = pb[i];
            pb[i] = t;
        }
    }
}
#endif
#ifndef OPENCSTL_UTILITY_H
#define OPENCSTL_UTILITY_H
static unsigned int fast_sqrt(unsigned int x) {
    unsigned int res = 0;
    unsigned int bit = 1u << 30;
    while (bit > x) bit >>= 2;
    while (bit != 0) {
        if (x >= res + bit) {
            x -= res + bit;
            res = (res >> 1) + bit;
        } else {
            res >>= 1;
        }
        bit >>= 2;
    }
    return res;
}
static int get_new_capacity(int _capacity) {
    if (_capacity < 2) return 2;
    enum {
        SQRT2_Q16 = 92682,
        DIFF_Q16 = 103926,
        K = 16
    };
    unsigned int s = fast_sqrt((unsigned int) _capacity);
    int ratio_q16 = SQRT2_Q16 + (int) ((unsigned int) DIFF_Q16 * K / (K + s));
    long long grown = ((long long) _capacity * ratio_q16) >> 16;
    if (grown <= _capacity) grown = _capacity + 1;
    if (grown > 2147483647LL) grown = 2147483647LL;
    return (int) grown;
}
#endif
#define cstl_vector(TYPE)	__cstl_vector(sizeof(TYPE),#TYPE)
OPENCSTL_FUNC void *__cstl_vector(size_type64 type_size, char *type) {
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    void *block = calloc(header_sz + type_size, 1);
    if (block == NULL) {
        fault("Failed to allocate memory for vector");
    }
    void *ptr = ((char *) block) + header_sz;
    void **container = &ptr;
    OPENCSTL_NIDX(container, NIDX_CTYPE) = OPENCSTL_VECTOR;
    OPENCSTL_NIDX(container, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(container, NIDX_TSIZE) = type_size;
    OPENCSTL_NIDX(container, -8) = !strcmp(type, "float");
    OPENCSTL_NIDX(container, -4) = (size_type64) type;
    OPENCSTL_NIDX(container, -3) = 0;
    OPENCSTL_NIDX(container, -2) = 1;
    OPENCSTL_NIDX(container, -1) = 0;
    bool iveb_init = false;
    if (iveb == NULL) {
        iveb = iveb_new();
        iveb_init = true;
    }
    iveb_insert(iveb, ptr, (char *) ptr + (type_size), CT_VECTOR, type_size, type);
    if (iveb_init) {
        atexit(__opencstl_iveb_destroy);
    }
    return ptr;
}
OPENCSTL_FUNC void __cstl_vector_assign(void **container, size_type64 n, void *value) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (capacity < n) {
        iveb_erase(iveb, *container);
        void *b = realloc((char *) *container - header_sz, header_sz + n * type_size);
        if (b == NULL) {
            fault("Reallocation failed at vector assign");
        }
        *container = ((char *) b + header_sz);
        OPENCSTL_NIDX(container, -2) = n;
        iveb_insert(iveb, *container, (char *) (*container) + (type_size * n), CT_VECTOR, type_size, type);
    }
    if (value == NULL) {
        memset(*container, 0, type_size * n);
    } else {
        for (size_type64 i = 0; i < n; i++) {
            memcpy((char *) *container + type_size * (i), value, type_size);
        }
    }
    OPENCSTL_NIDX(container, -1) = n;
}
OPENCSTL_FUNC void __cstl_vector_push_back(void **container, void *value) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (length == capacity) {
        iveb_erase(iveb, *container);
        size_type64 new_capaciy = get_new_capacity(capacity);
        void *b = realloc((char *) *container - header_sz, header_sz + new_capaciy * type_size);
        if (b == NULL) {
            fault("Reallocation failed at vector push_back");
        }
        *container = ((char *) b + header_sz);
        OPENCSTL_NIDX(container, -2) = new_capaciy;
        iveb_insert(iveb, *container, (char *) (*container) + (type_size * new_capaciy), CT_VECTOR, type_size, type);
    }
    memcpy((char *) *container + type_size * length, value, type_size);
    OPENCSTL_NIDX(container, -1)++;
}
OPENCSTL_FUNC void __cstl_vector_pop_back(void **container) {
    if (OPENCSTL_NIDX(container, -1) <= 0) {
        fault("No elements in cstl_vector");
    }
    OPENCSTL_NIDX(container, -1)--;
}
OPENCSTL_FUNC size_type __cstl_vector_size(void **container) {
    return (size_type) OPENCSTL_NIDX(container, -1);
}
OPENCSTL_FUNC size_type __cstl_vector_capacity(void **container) {
    return (size_type) OPENCSTL_NIDX(container, -2);
}
OPENCSTL_FUNC void __cstl_vector_insert(void **container, void *iter, size_type64 N, void *value) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    size_type64 pos = (*(char **) iter - *(char **) container) / type_size;
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (length + N >= capacity) {
        iveb_erase(iveb, *container);
        size_type64 new_capaciy = get_new_capacity(capacity + N);
        void *b = realloc((char *) *container - header_sz, header_sz + new_capaciy * type_size);
        if (b == NULL) {
            fault("Reallocation failed at vector insert");
        }
        *container = ((char *) b + header_sz);
        OPENCSTL_NIDX(container, -2) = new_capaciy;
        iveb_insert(iveb, *container, (char *) (*container) + (type_size * new_capaciy), CT_VECTOR, type_size, type);
    }
    memmove((char *) *container + type_size * (pos + N), (char *) *container + type_size * pos,
            (length - pos) * type_size);
    for (size_type64 i = 0; i < N; i++) {
        memcpy((char *) *container + type_size * (pos + i), value, type_size);
    }
    OPENCSTL_NIDX(container, -1) += N;
}
OPENCSTL_FUNC void __cstl_vector_erase(void **container, void *iter_begin, void *iter_end) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 pos_begin = (*(char **) iter_begin - *(char **) container) / type_size;
    size_type64 pos_end = (*(char **) iter_end - *(char **) container) / type_size;
    memmove((char *) *container + type_size * (pos_begin), (char *) *container + type_size * (pos_end),
            (length - pos_end) * type_size);
    OPENCSTL_NIDX(container, -1) -= (pos_end - pos_begin);
}
OPENCSTL_FUNC void *__cstl_vector_begin(void **container) {
    return (void *) *container;
}
OPENCSTL_FUNC void *__cstl_vector_end(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    return (void *) ((char *) *container + (type_size * length));
}
OPENCSTL_FUNC void *__cstl_vector_rbegin(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    return (void *) ((char *) *container + (type_size * (length - 1)));
}
OPENCSTL_FUNC void *__cstl_vector_rend(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    return (void *) ((char *) *container - (type_size));
}
OPENCSTL_FUNC void __cstl_vector_resize(void **container, size_type64 n, void *value) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (capacity < n) {
        iveb_erase(iveb, *container);
        void *b = realloc((char *) *container - header_sz, header_sz + n * type_size);
        if (b == NULL) {
            fault("Reallocation failed at vector resize");
        }
        *container = ((char *) b + header_sz);
        OPENCSTL_NIDX(container, -2) = n;
        iveb_insert(iveb, *container, (char *) (*container) + (type_size * n), CT_VECTOR, type_size, type);
    }
    if (n > length) {
        if (value == NULL) {
            memset((char *) *container + type_size * length, 0, type_size * (n - length));
        } else {
            for (size_type64 i = length; i < n; i++) {
                memcpy((char *) *container + type_size * (i), value, type_size);
            }
        }
    }
    OPENCSTL_NIDX(container, -1) = n;
}
OPENCSTL_FUNC void *__cstl_vector_find(void **container, void *iter_begin, void *value) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 pos = (*(char **) iter_begin - *(char **) container) / type_size;
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    for (size_type64 i = pos; i < length; i++) {
        if (memcmp((char *) *container + type_size * (i), value, type_size) == 0) {
            return (char *) *container + type_size * (i);
        }
    }
    return NULL;
}
OPENCSTL_FUNC void __cstl_vector_clear(void **container) {
    OPENCSTL_NIDX(container, -1) = 0;
}
OPENCSTL_FUNC void __cstl_vector_free(void **container) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    iveb_erase(iveb, *container);
    free((char *) (*container) - header_sz);
    *container = NULL;
}
OPENCSTL_FUNC void __cstl_vector_reserve(void **container, size_type64 n) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
    if (capacity < n) {
        iveb_erase(iveb, *container);
        void *b = realloc((char *) *container - header_sz, header_sz + n * type_size);
        if (b == NULL) {
            fault("Reallocation failed at vector reserve");
        }
        *container = ((char *) b + header_sz);
        OPENCSTL_NIDX(container, -2) = n;
        iveb_insert(iveb, *container, (char *) (*container) + (type_size * n), CT_VECTOR, type_size, type);
    }
}
OPENCSTL_FUNC void *__cstl_vector_next(void *it, size_type64 type_size) {
    return (char *) it + type_size;
}
OPENCSTL_FUNC void *__cstl_vector_prev(void *it, size_type64 type_size) {
    return (char *) it - type_size;
}
OPENCSTL_FUNC size_type __cstl_vector_max_size(void **container) {
    return INT_MAX;
}
OPENCSTL_FUNC void __cstl_vector_shrink_to_fit(void **container) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
    if (capacity == length) {
        return;
    }
    size_type64 new_capacity = length > 0 ? length : 1;
    iveb_erase(iveb, *container);
    void *b = realloc((char *) *container - header_sz, header_sz + new_capacity * type_size);
    if (b == NULL) {
        fault("Reallocation failed at vector shrink_to_fit");
    }
    *container = ((char *) b + header_sz);
    OPENCSTL_NIDX(container, -2) = new_capacity;
    iveb_insert(iveb, *container, (char *) (*container) + (type_size * new_capacity), CT_VECTOR, type_size, type);
}
OPENCSTL_FUNC void __cstl_vector_reverse(void **container) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
    int idx = 0;
    int idx_r = length - 1;
    while (idx < idx_r) {
        swap((char *) *container + type_size * (idx), (char *) *container + type_size * (idx_r), type_size);
        idx++;
        idx_r--;
    }
}
OPENCSTL_FUNC size_type64 __cstl_vector_count(void **container, void *value) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    CSTL_EQUALS_FN is_equal = CSTL_EQUALS(type);
    size_type64 cnt = 0;
    for (int i = 0; i < length; i++) {
        void *ptr = ((char *) *container) + (type_size * i);
        if (is_equal(ptr, value, type_size) == 0) {
            cnt++;
        }
    }
    return cnt;
}
OPENCSTL_FUNC size_type64 __cstl_vector_count_if(void **container, CSTL_COND cond) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
    size_type64 cnt = 0;
    for (int i = 0; i < length; i++) {
        void *ptr = ((char *) *container) + (type_size * i);
        if (cond(ptr)) {
            cnt++;
        }
    }
    return cnt;
}
OPENCSTL_FUNC void *__cstl_vector_lower_bound(void **container, void *value, CSTL_COMPARE compare) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (length == 0) return NULL;
    size_type64 L = 0;
    size_type64 R = length;
    while (L < R) {
        size_type64 M = L + (R - L) / 2;
        void *Mptr = ((char *) *container) + (type_size * M);
        if (compare(Mptr, value) < 0)
            L = M + 1;
        else
            R = M;
    }
    if (L >= length) return NULL;
    return ((char *) *container) + (type_size * L);
}
OPENCSTL_FUNC void *__cstl_vector_upper_bound(void **container, void *value, CSTL_COMPARE compare) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (length == 0) return NULL;
    size_type64 L = 0;
    size_type64 R = length;
    while (L < R) {
        size_type64 M = L + (R - L) / 2;
        void *Mptr = ((char *) *container) + (type_size * M);
        if (compare(value, Mptr) < 0)
            R = M;
        else
            L = M + 1;
    }
    if (L >= length) return NULL;
    return ((char *) *container) + (type_size * L);
}
#endif
#if !defined(_OPENCSTL_LIST_H)
#define _OPENCSTL_LIST_H
#ifndef OPENCSTL_ERROR_H
#define OPENCSTL_ERROR_H
#endif
#define cstl_list(TYPE)		__cstl_list(sizeof(TYPE),#TYPE)
#define NTAIL(N)	(N==-1?-2:N)
OPENCSTL_FUNC void *__cstl_list(size_type64 type_size, char *type) {
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    void *block = calloc(header_sz + sizeof(size_type64), 1);
    verify(block != NULL);
    void *ptr = ((char *) block) + header_sz;
    void **container = &ptr;
    OPENCSTL_NIDX(container, NIDX_CTYPE) = OPENCSTL_LIST;
    OPENCSTL_NIDX(container, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(container, NIDX_TSIZE) = type_size;
    OPENCSTL_NIDX(container, -8) = !strcmp(type, "float");
    OPENCSTL_NIDX(container, -4) = (size_type64) type;
    OPENCSTL_NIDX(container, -2) = 0;
    OPENCSTL_NIDX(container, -1) = 0;
    OPENCSTL_NIDX(container, 0) = 0;
    bool iveb_init = false;
    if (iveb == NULL) {
        iveb = iveb_new();
        iveb_init = true;
    }
    iveb_insert(iveb, ptr, (char *) ptr + sizeof(size_type64), CT_LIST, type_size, type);
    if (iveb_init) {
        atexit(__opencstl_iveb_destroy);
    }
    return ptr;
}
OPENCSTL_FUNC void *__cstl_list_node(size_type64 type_size) {
    size_type64 header_sz = sizeof(void *) * NIDX_LIST_NODE_SIZE;
    size_type64 node_sz = type_size + header_sz;
    void *ptr = (char *) calloc(node_sz, 1) + header_sz;
    void **node = &ptr;
    OPENCSTL_NIDX(node, -3) = OPENCSTL_LIST;
    return ptr;
}
OPENCSTL_FUNC void __cstl_list_push_back_front(void **container, void *value, int ntail, int nhead) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    void **tail = (void **) &OPENCSTL_NIDX(container, NTAIL(ntail));
    void **head = (void **) &OPENCSTL_NIDX(container, nhead);
    void *n = __cstl_list_node(type_size);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (value)
        memcpy(n, value, type_size);
    if (*head == NULL && *tail == NULL) {
        *head = *tail = n;
    } else {
        OPENCSTL_NIDX(tail, -(ntail + 2)) = (size_type64) n;
        OPENCSTL_NIDX(&n, -(nhead + 2)) = (size_type64) *tail;
        *tail = n;
    }
    OPENCSTL_NIDX(container, -1)++;
}
OPENCSTL_FUNC void __cstl_list_pop_back_front(void **container, int ntail, int nhead) {
    void **tail = (void **) &OPENCSTL_NIDX(container, NTAIL(ntail));
    void **head = (void **) &OPENCSTL_NIDX(container, nhead);
    verify(*head != NULL && *tail != NULL);
    if (*head == *tail) {
        free(&OPENCSTL_NIDX(tail, -3));
        *head = *tail = 0;
    } else {
        *tail = (void *) OPENCSTL_NIDX(tail, -(nhead + 2));
        void *fb = (void *) OPENCSTL_NIDX(tail, -(ntail + 2));
        free(&OPENCSTL_NIDX(&fb, -3));
        OPENCSTL_NIDX(tail, -(ntail + 2)) = 0;
    }
    OPENCSTL_NIDX(container, -1)--;
}
OPENCSTL_FUNC void *__cstl_list_next_prev(void *it, int n) {
    return (void *) OPENCSTL_NIDX(&it, n);
}
OPENCSTL_FUNC size_type __cstl_list_size(void **container) {
    return (size_type) OPENCSTL_NIDX(container, -1);
}
OPENCSTL_FUNC void __cstl_list_resize(void **container, size_type64 n, void *value) {
    size_type64 length = OPENCSTL_NIDX(container, -1);
    if (n < length) {
        while (n < length) {
            __cstl_list_pop_back_front((void **) container, -1, 0);
            length--;
        }
    } else {
        while (n >= length) {
            __cstl_list_push_back_front((void **) container, value, -1, 0);
            length++;
        }
    }
    OPENCSTL_NIDX(container, -1) = n;
}
OPENCSTL_FUNC void __cstl_list_insert(void **container, void **iter, size_type64 N, void *value) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    void **tail = (void **) &OPENCSTL_NIDX(container, -2);
    void **head = (void **) &OPENCSTL_NIDX(container, 0);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    void *nhead = __cstl_list_node(type_size);
    memcpy(nhead, value, type_size);
    void *ntail = nhead;
    for (size_type64 i = 1; i < N; i++) {
        void *n = __cstl_list_node(type_size);
        memcpy(n, value, type_size);
        OPENCSTL_NIDX(&n, -2) = (size_type64) ntail;
        OPENCSTL_NIDX(&ntail, -1) = (size_type64) n;
        ntail = n;
    }
    OPENCSTL_NIDX(&ntail, -1) = (size_type64) *iter;
    if (*head == NULL && *tail == NULL) {
        *head = nhead;
        *tail = ntail;
    } else if (*iter != NULL) {
        if (OPENCSTL_NIDX(iter, -2) != 0) {
            OPENCSTL_NIDX(&(OPENCSTL_NIDX(iter, -2)), -1) = (size_type64) nhead;
        }
        OPENCSTL_NIDX(&nhead, -2) = OPENCSTL_NIDX(iter, -2);
        OPENCSTL_NIDX(iter, -2) = (size_type64) ntail;
        if (*iter == *head) {
            *head = nhead;
        }
    } else {
        OPENCSTL_NIDX(tail, -1) = (size_type64) nhead;
        OPENCSTL_NIDX(&nhead, -2) = (size_type64) *tail;
        *tail = ntail;
    }
    OPENCSTL_NIDX(container, -1) += N;
}
OPENCSTL_FUNC void __cstl_list_erase(void **container, void **iter_begin, void **iter_end) {
    void **tail = (void **) &OPENCSTL_NIDX(container, -2);
    void **head = (void **) &OPENCSTL_NIDX(container, 0);
    verify(*iter_begin != NULL);
    if (*iter_begin == *head) {
        *head = *iter_end;
        if (*head != NULL) {
            OPENCSTL_NIDX(head, -2) = 0;
        }
    } else {
        OPENCSTL_NIDX(&OPENCSTL_NIDX(iter_begin, -2), -1) = (size_type64) *iter_end;
        if (*iter_end != NULL) {
            OPENCSTL_NIDX(iter_end, -2) = OPENCSTL_NIDX(iter_begin, -2);
        }
    }
    void *it = *iter_begin;
    while (it != *iter_end) {
        void *tmp = (void *) OPENCSTL_NIDX(&it, -1);
        free(&OPENCSTL_NIDX(&it, -3));
        OPENCSTL_NIDX(container, -1)--;
        it = tmp;
    }
    if (*iter_end == NULL) {
        *tail = 0;
    }
}
OPENCSTL_FUNC void *__cstl_list_begin(void **container) {
    return (void *) OPENCSTL_NIDX(container, 0);
}
OPENCSTL_FUNC void *__cstl_list_end_rend(void **container) {
    (void) container;
    return NULL;
}
OPENCSTL_FUNC void *__cstl_list_rbegin(void **container) {
    return (void *) OPENCSTL_NIDX(container, -2);
}
OPENCSTL_FUNC void __cstl_list_clear(void **container) {
    void **tail = (void **) &OPENCSTL_NIDX(container, -2);
    void **head = (void **) &OPENCSTL_NIDX(container, 0);
    void *it = *head;
    while (it != NULL) {
        void *tmp = (void *) OPENCSTL_NIDX(&it, -1);
        free(&OPENCSTL_NIDX(&it, -3));
        it = tmp;
    }
    *head = *tail = NULL;
    OPENCSTL_NIDX(container, -1) = 0;
}
OPENCSTL_FUNC void __cstl_list_free(void **container) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    __cstl_list_clear(container);
    free((char *) (*container) - header_sz);
    *container = NULL;
}
OPENCSTL_FUNC void *__cstl_list_find(void **container, void **iter_begin, void *value) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    void *it = *iter_begin;
    while (it != NULL) {
        if (memcmp(it, value, type_size) == 0) {
            return it;
        }
        it = (void *) OPENCSTL_NIDX(&it, -1);
    }
    return NULL;
}
OPENCSTL_FUNC void __cstl_list_msort(void **container, int (*cmp)(const void *, const void *)) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    void **tail = (void **) &OPENCSTL_NIDX(container, -2);
    void **head = (void **) &OPENCSTL_NIDX(container, 0);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    (void) header_sz;
    (void) type_size;
    (void) type;
    verify(cmp != NULL);
    if (*head == NULL || *tail == NULL || length < 2) {
        return;
    }
    for (size_type64 width = 1; width < length; width <<= 1) {
        void *curr = *head;
        void *new_head = NULL;
        void *new_tail = NULL;
        while (curr != NULL) {
            void *left = curr;
            void *right = NULL;
            void *next_run = NULL;
            size_type64 left_count = 0;
            size_type64 right_count = 0;
            for (; curr != NULL && left_count < width; ++left_count) {
                curr = (void *) OPENCSTL_NIDX(&curr, -1);
            }
            right = curr;
            for (; curr != NULL && right_count < width; ++right_count) {
                curr = (void *) OPENCSTL_NIDX(&curr, -1);
            }
            next_run = curr;
            while (left_count > 0 || right_count > 0) {
                void *pick = NULL;
                if (left_count == 0) {
                    pick = right;
                    right = (void *) OPENCSTL_NIDX(&right, -1);
                    --right_count;
                } else if (right_count == 0 || right == NULL) {
                    pick = left;
                    left = (void *) OPENCSTL_NIDX(&left, -1);
                    --left_count;
                } else if (cmp(left, right) <= 0) {
                    pick = left;
                    left = (void *) OPENCSTL_NIDX(&left, -1);
                    --left_count;
                } else {
                    pick = right;
                    right = (void *) OPENCSTL_NIDX(&right, -1);
                    --right_count;
                }
                if (new_tail == NULL) {
                    new_head = pick;
                    OPENCSTL_NIDX(&pick, -2) = 0;
                } else {
                    OPENCSTL_NIDX(&new_tail, -1) = (size_type64) pick;
                    OPENCSTL_NIDX(&pick, -2) = (size_type64) new_tail;
                }
                new_tail = pick;
            }
            if (new_tail != NULL) {
                OPENCSTL_NIDX(&new_tail, -1) = 0;
            }
            curr = next_run;
        }
        *head = new_head;
        *tail = new_tail;
    }
}
typedef struct {
    void *low;
    void *high;
} __cstl_qsort_range;
OPENCSTL_FUNC void __cstl_list_swap_data(void *a, void *b, size_type64 n) {
    unsigned char buf[128];
    unsigned char *tmp = (n <= sizeof(buf)) ? buf : (unsigned char *) calloc(n, 1);
    verify(tmp != NULL);
    memcpy(tmp, a, n);
    memcpy(a, b, n);
    memcpy(b, tmp, n);
    if (tmp != buf)
        free(tmp);
}
OPENCSTL_FUNC void *__cstl_list_mid_node(void *low, void *high) {
    void *slow = low;
    void *fast = low;
    while (fast != high) {
        fast = (void *) OPENCSTL_NIDX(&fast, -1);
        if (fast == high) break;
        fast = (void *) OPENCSTL_NIDX(&fast, -1);
        slow = (void *) OPENCSTL_NIDX(&slow, -1);
    }
    return slow;
}
OPENCSTL_FUNC void __cstl_list_median_of_three(void *low, void *high, size_type64 type_size,
                                               int (*cmp)(const void *, const void *)) {
    void *mid = __cstl_list_mid_node(low, high);
    if (mid == low || mid == high) return;
    if (cmp(low, mid) > 0) __cstl_list_swap_data(low, mid, type_size);
    if (cmp(low, high) > 0) __cstl_list_swap_data(low, high, type_size);
    if (cmp(mid, high) > 0) __cstl_list_swap_data(mid, high, type_size);
    __cstl_list_swap_data(mid, high, type_size);
}
OPENCSTL_FUNC void *__cstl_list_partition(void *low, void *high, size_type64 type_size,
                                          int (*cmp)(const void *, const void *)) {
    void *i = NULL;
    void *j = low;
    while (j != high) {
        if (cmp(j, high) <= 0) {
            i = (i == NULL) ? low : (void *) OPENCSTL_NIDX(&i, -1);
            if (i != j) {
                __cstl_list_swap_data(i, j, type_size);
            }
        }
        j = (void *) OPENCSTL_NIDX(&j, -1);
    }
    i = (i == NULL) ? low : (void *) OPENCSTL_NIDX(&i, -1);
    if (i != high) {
        __cstl_list_swap_data(i, high, type_size);
    }
    return i;
}
OPENCSTL_FUNC void __cstl_list_qsort(void **container, int (*cmp)(const void *, const void *)) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    void **tail = (void **) &OPENCSTL_NIDX(container, -2);
    void **head = (void **) &OPENCSTL_NIDX(container, 0);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    (void) header_sz;
    (void) type_size;
    (void) type;
    verify(cmp != NULL);
    if (*head == NULL || *tail == NULL || length < 2) {
        return;
    }
    size_type64 stack_cap = 64;
    __cstl_qsort_range *stack = (__cstl_qsort_range *) calloc(sizeof(__cstl_qsort_range), stack_cap);
    verify(stack != NULL);
    size_type64 top = 0;
    stack[top].low = *head;
    stack[top].high = *tail;
    top++;
    while (top > 0) {
        top--;
        void *lo = stack[top].low;
        void *hi = stack[top].high;
        if (lo == NULL || hi == NULL || lo == hi) {
            continue;
        }
        __cstl_list_median_of_three(lo, hi, type_size, cmp);
        void *pivot = __cstl_list_partition(lo, hi, type_size, cmp);
        void *left_lo = NULL;
        void *left_hi = NULL;
        if (pivot != lo) {
            void *pp = (void *) OPENCSTL_NIDX(&pivot, -2);
            if (pp != NULL) {
                left_lo = lo;
                left_hi = pp;
            }
        }
        void *right_lo = NULL;
        void *right_hi = NULL;
        if (pivot != hi) {
            void *pn = (void *) OPENCSTL_NIDX(&pivot, -1);
            if (pn != NULL) {
                right_lo = pn;
                right_hi = hi;
            }
        }
        size_type64 left_cnt = 0;
        size_type64 right_cnt = 0;
        if (left_lo != NULL) {
            void *it = left_lo;
            while (it != left_hi) {
                left_cnt++;
                it = (void *) OPENCSTL_NIDX(&it, -1);
            }
            left_cnt++;
        }
        if (right_lo != NULL) {
            void *it = right_lo;
            while (it != right_hi) {
                right_cnt++;
                it = (void *) OPENCSTL_NIDX(&it, -1);
            }
            right_cnt++;
        }
        if (left_cnt >= right_cnt) {
            if (left_lo != NULL && left_cnt >= 2) {
                stack[top].low = left_lo;
                stack[top].high = left_hi;
                top++;
            }
            if (right_lo != NULL && right_cnt >= 2) {
                stack[top].low = right_lo;
                stack[top].high = right_hi;
                top++;
            }
        } else {
            if (right_lo != NULL && right_cnt >= 2) {
                stack[top].low = right_lo;
                stack[top].high = right_hi;
                top++;
            }
            if (left_lo != NULL && left_cnt >= 2) {
                stack[top].low = left_lo;
                stack[top].high = left_hi;
                top++;
            }
        }
    }
    free(stack);
}
OPENCSTL_FUNC size_type __cstl_list_max_size(void **container) {
    return INT_MAX;
}
OPENCSTL_FUNC void __cstl_list_reverse(void **container) {
    void **tail = (void **) &OPENCSTL_NIDX(container, -2);
    void **head = (void **) &OPENCSTL_NIDX(container, 0);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    if (*head == NULL || *tail == NULL || length < 2) {
        return;
    }
    void *curr = *head;
    while (curr != NULL) {
        void *next = (void *) OPENCSTL_NIDX(&curr, -1);
        OPENCSTL_NIDX(&curr, -1) = OPENCSTL_NIDX(&curr, -2);
        OPENCSTL_NIDX(&curr, -2) = (size_type64) next;
        curr = next;
    }
    void *tmp = *head;
    *head = *tail;
    *tail = tmp;
}
#endif
#if !defined(_OPENCSTL_TREE_H)
#define _OPENCSTL_TREE_H
#define P	    (-4)
#define R       (-1)
#define L       (-2)
#define RED     ((size_type64)1)
#define BLACK   ((size_type64)0)
#define _(N,V)	OPENCSTL_NIDX(&N, V)
#define COLOR(N)	_(N, -5)
#define CSTL_ARENA_CHUNK_SIZE 256
typedef struct cstl_arena_chunk cstl_arena_chunk;
struct cstl_arena_chunk {
    cstl_arena_chunk *next;
    size_type64 used;
    size_type64 capacity;
    size_type64 node_size;
};
OPENCSTL_FUNC cstl_arena_chunk *__cstl_arena_new_chunk(size_type64 node_size, size_type64 capacity) {
    cstl_arena_chunk *chunk = (cstl_arena_chunk *) calloc(
        sizeof(cstl_arena_chunk) + node_size * capacity, 1
    );
    chunk->next = NULL;
    chunk->used = 0;
    chunk->capacity = capacity;
    chunk->node_size = node_size;
    return chunk;
}
OPENCSTL_FUNC void *__cstl_arena_alloc(cstl_arena_chunk **arena, void **freelist, size_type64 node_size) {
    if (*freelist != NULL) {
        void *reused = *freelist;
        *freelist = *(void **) reused;
        memset(reused, 0, node_size);
        return reused;
    }
    if (*arena == NULL || (*arena)->used >= (*arena)->capacity) {
        cstl_arena_chunk *new_chunk = __cstl_arena_new_chunk(node_size, CSTL_ARENA_CHUNK_SIZE);
        new_chunk->next = *arena;
        *arena = new_chunk;
    }
    void *ptr = (char *) (*arena + 1) + (*arena)->node_size * (*arena)->used;
    memset(ptr, 0, node_size);
    (*arena)->used++;
    return ptr;
}
OPENCSTL_FUNC void __cstl_arena_dealloc(void **freelist, void *raw_ptr) {
    *(void **) raw_ptr = *freelist;
    *freelist = raw_ptr;
}
OPENCSTL_FUNC void __cstl_arena_free_all(cstl_arena_chunk **arena, void **freelist) {
    cstl_arena_chunk *c = *arena;
    while (c != NULL) {
        cstl_arena_chunk *next = c->next;
        free(c);
        c = next;
    }
    *arena = NULL;
    *freelist = NULL;
}
SELECT_ANY char nil_buffer[sizeof(void *) * NIDX_TREE_NODE_SIZE] = {0};
SELECT_ANY void *nil = NULL;
OPENCSTL_FUNC void *__cstl_tree_node(size_type64 type_size, size_type64 node_type) {
    size_type64 node_sz = type_size + sizeof(void *) * NIDX_TREE_NODE_SIZE;
    node_sz = (node_sz + sizeof(void *) - 1) & ~(sizeof(void *) - 1);
    void *ptr = (char *) calloc(node_sz, 1) + sizeof(void *) * NIDX_TREE_NODE_SIZE;
    OPENCSTL_NIDX(&ptr, -3) = node_type;
    COLOR(ptr) = BLACK;
    return ptr;
}
OPENCSTL_FUNC void *__cstl_tree_node_pooled(void **container, size_type64 type_size, size_type64 node_type) {
    size_type64 raw_node_sz = type_size + sizeof(void *) * NIDX_TREE_NODE_SIZE;
    raw_node_sz = (raw_node_sz + sizeof(void *) - 1) & ~(sizeof(void *) - 1);
    cstl_arena_chunk **arena = (cstl_arena_chunk **) &OPENCSTL_NIDX(container, -7);
    void **freelist = (void **) &OPENCSTL_NIDX(container, -6);
    char *raw = (char *) __cstl_arena_alloc(arena, freelist, raw_node_sz);
    void *ptr = raw + sizeof(void *) * NIDX_TREE_NODE_SIZE;
    OPENCSTL_NIDX(&ptr, -3) = (size_type64) node_type;
    COLOR(ptr) = BLACK;
    return ptr;
}
#define _CSTL_SET_EXPAND(x) x
#define cstl_set         _cstl_set
#define _cstl_set(...)	    _CSTL_SET_EXPAND(_CSTL_SET_DISPATCH(__VA_ARGS__, NULL, NULL))
#define _CSTL_SET_DISPATCH(KEY, COMP, ...) __cstl_set(sizeof(KEY),#KEY,(void*)(COMP))
OPENCSTL_FUNC void *__cstl_set(size_type64 key_size, char *type_key, void *compare) {
    if (nil == NULL) {
        nil = nil_buffer + sizeof(void *) * NIDX_TREE_NODE_SIZE;
        _(nil, -1) = _(nil, -2) = _(nil, -4) = (size_type64) nil;
    }
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    void *ptr = (char *) calloc(header_sz + sizeof(size_type64), 1) + header_sz;
    void **container = &ptr;
    OPENCSTL_NIDX(container, NIDX_CTYPE) = OPENCSTL_SET;
    OPENCSTL_NIDX(container, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(container, NIDX_TSIZE) = key_size;
    OPENCSTL_NIDX(container, -9) = 0;
    OPENCSTL_NIDX(container, -8) = !strcmp(type_key, "float");
    OPENCSTL_NIDX(container, -7) = 0;
    OPENCSTL_NIDX(container, -6) = 0;
    OPENCSTL_NIDX(container, -4) = 0;
    OPENCSTL_NIDX(container, -3) = (size_type64) type_key;
    OPENCSTL_NIDX(container, -2) = (size_type64) compare;
    OPENCSTL_NIDX(container, -1) = 0;
    OPENCSTL_NIDX(container, 0) = (size_type64) nil;
    return ptr;
}
#define _CSTL_MAP_EXPAND(x) x
#define cstl_map         _cstl_map
#define _cstl_map(...)	_CSTL_MAP_EXPAND(_CSTL_MAP_DISPATCH(__VA_ARGS__, NULL, NULL))
#define _CSTL_MAP_DISPATCH(KEY, VALUE, COMP, ...) __cstl_map(sizeof(KEY), sizeof(VALUE), #KEY, #VALUE, (void*)(COMP))
OPENCSTL_FUNC void *__cstl_map(size_type64 key_size, size_type64 value_size, char *type_key, char *type_value, void *compare) {
    if (nil == NULL) {
        nil = nil_buffer + sizeof(void *) * 5;
        _(nil, -1) = _(nil, -2) = _(nil, -4) = (size_type64) nil;
    }
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    void *ptr = (char *) calloc(header_sz + sizeof(size_type64), 1) + header_sz;
    void **container = &ptr;
    OPENCSTL_NIDX(container, NIDX_CTYPE) = OPENCSTL_MAP;
    OPENCSTL_NIDX(container, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(container, NIDX_TSIZE) = key_size;
    OPENCSTL_NIDX(container, -9) = !strcmp(type_value, "float");
    OPENCSTL_NIDX(container, -8) = !strcmp(type_key, "float");
    OPENCSTL_NIDX(container, -7) = 0;
    OPENCSTL_NIDX(container, -6) = 0;
    OPENCSTL_NIDX(container, -5) = (size_type64) type_value;
    OPENCSTL_NIDX(container, -4) = value_size;
    OPENCSTL_NIDX(container, -3) = (size_type64) type_key;
    OPENCSTL_NIDX(container, -2) = (size_type64) compare;
    OPENCSTL_NIDX(container, -1) = 0;
    OPENCSTL_NIDX(container, 0) = (size_type64) nil;
    return ptr;
}
OPENCSTL_FUNC void __cstl_tree_left_rotate(void **container, void *x) {
    void ***root = (void ***) *container;
    void *y = (void *) _(x, R);
    _(x, R) = _(y, L);
    if ((void *) _(y, L) != nil) {
        _(_(y, L), P) = (size_type64) x;
    }
    _(y, P) = _(x, P);
    if ((void *) _(x, P) == nil) {
        *root = (void **) y;
    } else if (x == (void *) _(_(x,P), L)) {
        _(_(x, P), L) = (size_type64) y;
    } else {
        _(_(x, P), R) = (size_type64) y;
    }
    _(y, L) = (size_type64) x;
    _(x, P) = (size_type64) y;
}
OPENCSTL_FUNC void __cstl_tree_right_rotate(void **container, void *x) {
    void ***root = (void ***) *container;
    void *y = (void *) _(x, L);
    _(x, L) = _(y, R);
    if ((void *) _(y, R) != nil) {
        _(_(y, R), P) = (size_type64) x;
    }
    _(y, P) = _(x, P);
    if ((void *) _(x, P) == nil) {
        *root = (void **) y;
    } else if (x == (void *) _(_(x, P), R)) {
        _(_(x, P), R) = (size_type64) y;
    } else {
        _(_(x, P), L) = (size_type64) y;
    }
    _(y, R) = (size_type64) x;
    _(x, P) = (size_type64) y;
}
OPENCSTL_FUNC void __cstl_tree_insert_fixup(void **container, void *z) {
    while (COLOR(_(z, P)) == RED) {
        if ((void *) _(z, P) == (void *) _(_(_(z, P), P), L)) {
            void *y = (void *) _(_(_(z, P), P), R);
            if (COLOR(y) == RED) {
                COLOR(_(z, P)) = BLACK;
                COLOR(y) = BLACK;
                COLOR(_(_(z, P), P)) = RED;
                z = (void *) _(_(z, P), P);
            } else {
                if (z == (void *) _(_(z, P), R)) {
                    z = (void *) _(z, P);
                    __cstl_tree_left_rotate(container, z);
                }
                COLOR(_(z, P)) = BLACK;
                COLOR(_(_(z, P),P)) = RED;
                __cstl_tree_right_rotate(container, (void *) _(_(z, P), P));
            }
        } else {
            void *y = (void *) _(_(_(z, P), P), L);
            if (COLOR(y) == RED) {
                COLOR(_(z, P)) = BLACK;
                COLOR(y) = BLACK;
                COLOR(_(_(z, P), P)) = RED;
                z = (void *) _(_(z, P), P);
            } else {
                if (z == (void *) _(_(z, P), L)) {
                    z = (void *) _(z, P);
                    __cstl_tree_right_rotate(container, z);
                }
                COLOR(_(z, P)) = BLACK;
                COLOR(_(_(z, P), P)) = RED;
                __cstl_tree_left_rotate(container, (void *) _(_(z, P), P));
            }
        }
    }
    void ***root = (void ***) *container;
    COLOR(*root) = BLACK;
}
OPENCSTL_FUNC void __cstl_tree_insert(void **container, void *key, void *value) {
    size_type64 container_type = OPENCSTL_NIDX(container, NIDX_CTYPE);
    size_type64 key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 value_size = OPENCSTL_NIDX(container, -4);
    size_type64 type_size = key_size + value_size;
    CSTL_COMPARE compare = (CSTL_COMPARE) OPENCSTL_NIDX(container, -2);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float_key = OPENCSTL_NIDX(container, -8);
    size_type64 is_float_value = OPENCSTL_NIDX(container, -9);
    float keyf = 0.0F;
    if (is_float_key) {
        keyf = (float) *(double *) key;
        key = &keyf;
    }
    float valuef = 0.0F;
    if (is_float_value) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    void ***root = (void ***) *container;
    void *n = __cstl_tree_node_pooled(container, type_size, container_type);
    memcpy(n, key, key_size);
    if (value) {
        memcpy((char *) n + key_size, value, value_size);
    }
    void *p = nil;
    while (*root != nil) {
        p = *root;
        int r = compare ? compare(*root, n) : memcmp(*root, n, type_size);
        if (r == 0) {
            return;
        } else if (r > 0) {
            root = (void ***) &OPENCSTL_NIDX(root, L);
        } else {
            root = (void ***) &OPENCSTL_NIDX(root, R);
        }
    }
    OPENCSTL_NIDX(&n, P) = (size_type64) p;
    OPENCSTL_NIDX(&n, L) = (size_type64) nil;
    OPENCSTL_NIDX(&n, R) = (size_type64) nil;
    COLOR(n) = RED;
    *root = (void **) n;
    __cstl_tree_insert_fixup(container, n);
    OPENCSTL_NIDX(container, -1) = (OPENCSTL_NIDX(container, -1)) + 1;
}
OPENCSTL_FUNC void __cstl_tree_transplant(void **container, void *u, void *v) {
    void ***root = (void ***) *container;
    if ((void *) _(u, P) == nil) {
        *root = (void **) v;
    } else if (u == (void *) _(_(u, P), L)) {
        _(_(u, P), L) = (size_type64) v;
    } else {
        _(_(u, P), R) = (size_type64) v;
    }
    _(v, P) = _(u, P);
}
OPENCSTL_FUNC void *__cstl_tree_toleft(void *n) {
    while ((void *) _(n, L) != nil) {
        n = (void *) _(n, L);
    }
    return n;
}
OPENCSTL_FUNC void *__cstl_tree_toright(void *n) {
    while ((void *) _(n, R) != nil) {
        n = (void *) _(n, R);
    }
    return n;
}
OPENCSTL_FUNC void __cstl_tree_erase_fixup(void **container, void *x) {
    void ***root = (void ***) *container;
    while (x != *root && COLOR(x) == BLACK) {
        intmax_t expression = (x == (void *) _(_(x, P), L));
        intmax_t left = expression ? L : R;
        intmax_t right = expression ? R : L;
        void (*func[2])(void **, void *) = {__cstl_tree_left_rotate, __cstl_tree_right_rotate};
        if (!expression) {
            void (*tmp)(void **, void *) = func[0];
            func[0] = func[1];
            func[1] = tmp;
        }
        void *w = (void *) _(_(x, P), right);
        if (COLOR(w) == RED) {
            COLOR(w) = BLACK;
            COLOR(_(x, P)) = RED;
            func[0](container, (void *) _(x, P));
            w = (void *) _(_(x, P), right);
        }
        if (COLOR(_(w, left)) == BLACK && COLOR(_(w, right)) == BLACK) {
            COLOR(w) = RED;
            x = (void *) _(x, P);
        } else {
            if (COLOR(_(w, right)) == BLACK) {
                COLOR(_(w, left)) = BLACK;
                COLOR(w) = RED;
                func[1](container, w);
                w = (void *) _(_(x, P), right);
            }
            COLOR(w) = COLOR(_(x, P));
            COLOR(_(x, P)) = BLACK;
            COLOR(_(w, right)) = BLACK;
            func[0](container, (void *) _(x, P));
            x = *root;
        }
    }
    COLOR(x) = BLACK;
}
OPENCSTL_FUNC void __cstl_tree_erase(void **container, void **iter) {
    if (iter == NULL)return;
    void *z = iter;
    void *y = z;
    void *x = NULL;
    size_type64 y_original_color = (size_type64) COLOR(y);
    if ((void *) _(z, L) == nil) {
        x = (void *) _(z, R);
        __cstl_tree_transplant(container, z, (void *) _(z, R));
    } else if ((void *) _(z, R) == nil) {
        x = (void *) _(z, L);
        __cstl_tree_transplant(container, z, (void *) _(z, L));
    } else {
        y = __cstl_tree_toleft((void *) _(z, R));
        y_original_color = (size_type64) COLOR(y);
        x = (void *) _(y, R);
        if ((void *) _(y, P) == z) {
            _(x, P) = (size_type64) y;
        } else {
            __cstl_tree_transplant(container, y, (void *) _(y, R));
            _(y, R) = _(z, R);
            _(_(y, R), P) = (size_type64) y;
        }
        __cstl_tree_transplant(container, z, y);
        _(y, L) = _(z, L);
        _(_(y, L), P) = (size_type64) y;
        COLOR(y) = COLOR(z);
    }
    if (y_original_color == (size_type64) BLACK) {
        __cstl_tree_erase_fixup(container, x);
    }
    {
        void **freelist = (void **) &OPENCSTL_NIDX(container, -6);
        __cstl_arena_dealloc(freelist, &OPENCSTL_NIDX(&iter, -5));
        OPENCSTL_NIDX(container, -1) = (OPENCSTL_NIDX(container, -1)) - 1;
    }
}
OPENCSTL_FUNC void *__cstl_tree_find(void **container, void *key) {
    size_type64 key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 value_size = OPENCSTL_NIDX(container, -4);
    size_type64 type_size = key_size + value_size;
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float_key = OPENCSTL_NIDX(container, -8);
    float keyf = 0.0F;
    if (is_float_key) {
        keyf = (float) *(double *) key;
        key = &keyf;
    }
#endif
    CSTL_COMPARE compare = (CSTL_COMPARE) OPENCSTL_NIDX(container, -2);
    void ***root = (void ***) *container;
    while (*root != nil) {
        int r = compare ? compare(*root, key) : memcmp(*root, key, type_size);
        if (r == 0) {
            return *root;
        } else if (r > 0) {
            root = (void ***) &OPENCSTL_NIDX(root, L);
        } else {
            root = (void ***) &OPENCSTL_NIDX(root, R);
        }
    }
    return NULL;
}
OPENCSTL_FUNC void *__cstl_tree_begin(void **container) {
    void ***root = (void ***) *container;
    return *root != nil ? __cstl_tree_toleft(*root) : nil;
}
OPENCSTL_FUNC void *__cstl_tree_rbegin(void **container) {
    void ***root = (void ***) *container;
    return *root != nil ? __cstl_tree_toright(*root) : nil;
}
OPENCSTL_FUNC void *__cstl_tree_end_rend(void **container) {
    (void) container;
    return nil;
}
OPENCSTL_FUNC void __cstl_tree_clear(void **container) {
    cstl_arena_chunk **arena = (cstl_arena_chunk **) &OPENCSTL_NIDX(container, -7);
    void **freelist = (void **) &OPENCSTL_NIDX(container, -6);
    void ***root = (void ***) *container;
    __cstl_arena_free_all(arena, freelist);
    OPENCSTL_NIDX(container, -1) = 0;
    *root = (void **) nil;
}
OPENCSTL_FUNC void __cstl_tree_free(void **container) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    __cstl_tree_clear(container);
    free((char *) (*container) - header_sz);
    *container = NULL;
}
OPENCSTL_FUNC void *__cstl_tree_next_prev(void *it, int r, int l, void *(todeep)(void *)) {
    if ((void *) _(it, r) != nil) {
        it = todeep((void *) _(it, r));
    } else {
        if ((void *) _(_(it, P), l) == it) {
            it = (void *) _(it, P);
        } else {
            while ((void *) _(_(it, P), r) == it) {
                it = (void *) _(it, P);
            }
            it = (void *) _(it, P);
        }
    }
    return it;
}
OPENCSTL_FUNC size_type __cstl_tree_size(void **container) {
    size_type64 length = OPENCSTL_NIDX(container, -1);
    return (size_type) length;
}
#undef P
#undef L
#undef R
#undef _
#undef RED
#undef BLACK
#endif
#if !defined(_OPENCSTL_STACK_H)
#define _OPENCSTL_STACK_H
#define cstl_stack(TYPE)	__cstl_stack(sizeof(TYPE),#TYPE)
OPENCSTL_FUNC void *__cstl_stack(size_type64 type_size, char *type) {
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    void *ptr = (char *) malloc(header_sz + type_size * 2) + header_sz;
    void **container = &ptr;
    OPENCSTL_NIDX(container, NIDX_CTYPE) = OPENCSTL_STACK;
    OPENCSTL_NIDX(container, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(container, NIDX_TSIZE) = type_size;
    OPENCSTL_NIDX(container, -4) = (size_type64) type;
    OPENCSTL_NIDX(container, -3) = 2;
    OPENCSTL_NIDX(container, -2) = 0;
    *container = (char *) ptr + type_size;
    OPENCSTL_NIDX(container, -1) = -type_size - 1;
    return ptr;
}
#endif
#if !defined(_OPENCSTL_QUEUE_H)
#define _OPENCSTL_QUEUE_H
#define cstl_queue(TYPE)	__cstl_queue(sizeof(TYPE),#TYPE)
OPENCSTL_FUNC void *__cstl_queue(size_type64 type_size, char *type) {
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    void *ptr = (char *) malloc(header_sz + type_size * 2) + header_sz;
    void **container = &ptr;
    OPENCSTL_NIDX(container, NIDX_CTYPE) = OPENCSTL_QUEUE;
    OPENCSTL_NIDX(container, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(container, NIDX_TSIZE) = type_size;
    OPENCSTL_NIDX(container, -8) = !strcmp(type, "float");
    OPENCSTL_NIDX(container, -4) = (size_type64) type;
    OPENCSTL_NIDX(container, -3) = 2;
    OPENCSTL_NIDX(container, -2) = 0;
    *container = (char *) ptr + type_size;
    OPENCSTL_NIDX(container, -1) = -type_size - 1;
    return ptr;
}
#define _CSTL_PQ_EXPAND(x) x
#define cstl_priority_queue(...)	_CSTL_PQ_EXPAND(_CSTL_PQ_DISPATCH(__VA_ARGS__, NULL, NULL))
#define _CSTL_PQ_DISPATCH(TYPE, COMP, ...) __cstl_priority_queue(sizeof(TYPE),#TYPE,(void*)(COMP))
OPENCSTL_FUNC void *__cstl_priority_queue(size_type64 type_size, char *type, void *compare) {
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    void *ptr = (char *) malloc(header_sz + type_size * 1) + header_sz;
    void **container = &ptr;
    OPENCSTL_NIDX(container, NIDX_CTYPE) = OPENCSTL_PRIORITY_QUEUE;
    OPENCSTL_NIDX(container, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(container, NIDX_TSIZE) = type_size;
    OPENCSTL_NIDX(container, -8) = !strcmp(type, "float");
    OPENCSTL_NIDX(container, -4) = (size_type64) type;
    OPENCSTL_NIDX(container, -3) = (size_type64) compare;
    OPENCSTL_NIDX(container, -2) = 1;
    OPENCSTL_NIDX(container, -1) = 0;
    return ptr;
}
OPENCSTL_FUNC void __cstl_priority_queue_push(void **container, void *value) {
    __cstl_vector_push_back(container, value);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    CSTL_COMPARE compare = (CSTL_COMPARE) OPENCSTL_NIDX(container, -3);
    void *tmp = salloc(type_size);
    size_type64 idx = length - 1;
    memcpy(tmp, ((char *) *container) + type_size * idx, type_size);
    while (idx > 0) {
        void *c = ((char *) *container) + type_size * idx;
        void *p = ((char *) *container) + type_size * HEAP_PARENT(idx);
        int r = compare ? compare(tmp, p) : memcmp(tmp, p, type_size);
        if (r <= 0)break;
        memcpy(c, p, type_size);
        idx = HEAP_PARENT(idx);
    }
    memcpy(((char *) *container) + type_size * idx, tmp, type_size);
}
OPENCSTL_FUNC void __cstl_priority_queue_pop(void **container) {
    verify(OPENCSTL_NIDX(container, -1) > 0);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    CSTL_COMPARE compare = (CSTL_COMPARE) OPENCSTL_NIDX(container, -3);
    memcpy(*container, ((char *) *container) + type_size * (length - 1), type_size);
    OPENCSTL_NIDX(container, -1)--;
    length--;
    size_type64 idx = 0;
    void *tmp = salloc(type_size);
    size_type64 L, R, C;
    memcpy(tmp, *container, type_size);
    void *ptr = tmp;
    do {
        L = HEAP_LEFT(idx);
        R = HEAP_RIGHT(idx);
        void *L_node = ((char *) *container) + type_size * L;
        void *R_node = ((char *) *container) + type_size * R;
        int r = compare ? compare(L_node, tmp) : memcmp(L_node, tmp, type_size);
        if (L < length && r > 0) {
            C = L;
            ptr = L_node;
        } else {
            C = idx;
            ptr = tmp;
        }
        r = compare ? compare(R_node, ptr) : memcmp(R_node, ptr, type_size);
        if (R < length && r > 0) {
            C = R;
        }
        if (C == idx)break;
        memcpy(((char *) *container) + type_size * idx, ((char *) *container) + type_size * C, type_size);
        idx = C;
    } while (1);
    memcpy(((char *) *container) + type_size * idx, tmp, type_size);
}
#endif
#if !defined(_OPENCSTL_HASHTABLE_H)
#define _OPENCSTL_HASHTABLE_H
#define HT_CTRL_EMPTY 0u
#define HT_LOAD_NUM   7
#define HT_LOAD_DEN   8
#define HT_MIN_CAP    8u
#define HTM_VEBT
#define HT_THRESHOLD(cap) ((cap) - ((cap) >> 3))
#if defined(__GNUC__) || defined(__clang__)
#define OPENCSTL_ALWAYS_INLINE static inline __attribute__((always_inline))
#define OPENCSTL_LIKELY(x)   __builtin_expect(!!(x), 1)
#define OPENCSTL_UNLIKELY(x) __builtin_expect(!!(x), 0)
#define OPENCSTL_PREFETCH(p) __builtin_prefetch((p))
#elif defined(_MSC_VER)
#define OPENCSTL_ALWAYS_INLINE static __forceinline
#define OPENCSTL_LIKELY(x)   (x)
#define OPENCSTL_UNLIKELY(x) (x)
#define OPENCSTL_PREFETCH(p) ((void)0)
#else
#define OPENCSTL_ALWAYS_INLINE static inline
#define OPENCSTL_LIKELY(x)   (x)
#define OPENCSTL_UNLIKELY(x) (x)
#define OPENCSTL_PREFETCH(p) ((void)0)
#endif
#if defined(_MSC_VER) && defined(_M_X64)
#include <intrin.h>
#pragma intrinsic(_umul128)
#endif
static inline size_type64 __ht_next_pow2(size_type64 n) {
    size_type64 p = HT_MIN_CAP;
    while (p < n) p <<= 1;
    return p;
}
OPENCSTL_ALWAYS_INLINE bool __ht_key_eq(const void *a, const void *b, size_type64 ks) {
    switch (ks) {
        case 1: return *(const uint8_t *) a == *(const uint8_t *) b;
        case 2: return *(const uint16_t *) a == *(const uint16_t *) b;
        case 4: return *(const uint32_t *) a == *(const uint32_t *) b;
        case 8: return *(const uint64_t *) a == *(const uint64_t *) b;
        default: return memcmp(a, b, ks) == 0;
    }
}
#define OPENCSTL_XXH_ROTL32(x, r) (((x) << (r)) | ((x) >> (32 - (r))))
#define OPENCSTL_XXH_ROTL64(x, r) (((x) << (r)) | ((x) >> (64 - (r))))
#define OPENCSTL_XXH32_P2 2246822519U
#define OPENCSTL_XXH32_P3 3266489917U
#define OPENCSTL_XXH64_P1 11400714785074694791ULL
#define OPENCSTL_XXH64_P2 14029467366897019727ULL
#define OPENCSTL_XXH64_P3  1609587929392839161ULL
#define OPENCSTL_XXH64_P4  9650029242287828579ULL
#define OPENCSTL_XXH64_P5  2870177450012600261ULL
OPENCSTL_FUNC size_type64 _cstl_hash32(void *_key) {
    unsigned int h = *(unsigned int *) _key;
    h ^= h >> 15;
    h *= OPENCSTL_XXH32_P2;
    h ^= h >> 13;
    h *= OPENCSTL_XXH32_P3;
    h ^= h >> 16;
    return (size_type64) h;
}
OPENCSTL_FUNC size_type64 _cstl_hash64(void *_key) {
    unsigned long long x = *(unsigned long long *) _key;
    x ^= x >> 33;
    x *= OPENCSTL_XXH64_P2;
    x ^= x >> 29;
    x *= OPENCSTL_XXH64_P3;
    x ^= x >> 32;
    return (size_type64) x;
}
OPENCSTL_FUNC size_type64 _cstl_hash(void *_key, size_type64 len) {
    const unsigned char *p = (const unsigned char *) _key;
    const unsigned char *end = p + len;
    unsigned long long h64;
    unsigned long long k;
    if (len >= 32) {
        unsigned long long v1 = OPENCSTL_XXH64_P1 + OPENCSTL_XXH64_P2;
        unsigned long long v2 = OPENCSTL_XXH64_P2;
        unsigned long long v3 = 0ULL;
        unsigned long long v4 = 0ULL - OPENCSTL_XXH64_P1;
        const unsigned char *limit = end - 32;
        do {
            memcpy(&k, p, 8);
            v1 += k * OPENCSTL_XXH64_P2;
            v1 = OPENCSTL_XXH_ROTL64(v1, 31) * OPENCSTL_XXH64_P1;
            p += 8;
            memcpy(&k, p, 8);
            v2 += k * OPENCSTL_XXH64_P2;
            v2 = OPENCSTL_XXH_ROTL64(v2, 31) * OPENCSTL_XXH64_P1;
            p += 8;
            memcpy(&k, p, 8);
            v3 += k * OPENCSTL_XXH64_P2;
            v3 = OPENCSTL_XXH_ROTL64(v3, 31) * OPENCSTL_XXH64_P1;
            p += 8;
            memcpy(&k, p, 8);
            v4 += k * OPENCSTL_XXH64_P2;
            v4 = OPENCSTL_XXH_ROTL64(v4, 31) * OPENCSTL_XXH64_P1;
            p += 8;
        } while (p <= limit);
        h64 = OPENCSTL_XXH_ROTL64(v1, 1)
              + OPENCSTL_XXH_ROTL64(v2, 7)
              + OPENCSTL_XXH_ROTL64(v3, 12)
              + OPENCSTL_XXH_ROTL64(v4, 18);
        v1 = OPENCSTL_XXH_ROTL64(v1, 31) * OPENCSTL_XXH64_P1;
        h64 ^= v1;
        h64 = h64 * OPENCSTL_XXH64_P1 + OPENCSTL_XXH64_P4;
        v2 = OPENCSTL_XXH_ROTL64(v2, 31) * OPENCSTL_XXH64_P1;
        h64 ^= v2;
        h64 = h64 * OPENCSTL_XXH64_P1 + OPENCSTL_XXH64_P4;
        v3 = OPENCSTL_XXH_ROTL64(v3, 31) * OPENCSTL_XXH64_P1;
        h64 ^= v3;
        h64 = h64 * OPENCSTL_XXH64_P1 + OPENCSTL_XXH64_P4;
        v4 = OPENCSTL_XXH_ROTL64(v4, 31) * OPENCSTL_XXH64_P1;
        h64 ^= v4;
        h64 = h64 * OPENCSTL_XXH64_P1 + OPENCSTL_XXH64_P4;
    } else {
        h64 = OPENCSTL_XXH64_P5;
    }
    h64 += (unsigned long long) len;
    while (p + 8 <= end) {
        memcpy(&k, p, 8);
        k = OPENCSTL_XXH_ROTL64(k * OPENCSTL_XXH64_P2, 31) * OPENCSTL_XXH64_P1;
        h64 ^= k;
        h64 = OPENCSTL_XXH_ROTL64(h64, 27) * OPENCSTL_XXH64_P1 + OPENCSTL_XXH64_P4;
        p += 8;
    }
    if (p + 4 <= end) {
        unsigned int k32;
        memcpy(&k32, p, 4);
        h64 ^= (unsigned long long) k32 * OPENCSTL_XXH64_P1;
        h64 = OPENCSTL_XXH_ROTL64(h64, 23) * OPENCSTL_XXH64_P2 + OPENCSTL_XXH64_P3;
        p += 4;
    }
    while (p < end) {
        h64 ^= (unsigned long long) (*p) * OPENCSTL_XXH64_P5;
        h64 = OPENCSTL_XXH_ROTL64(h64, 11) * OPENCSTL_XXH64_P1;
        p++;
    }
    h64 ^= h64 >> 33;
    h64 *= OPENCSTL_XXH64_P2;
    h64 ^= h64 >> 29;
    h64 *= OPENCSTL_XXH64_P3;
    h64 ^= h64 >> 32;
    return (size_type64) h64;
}
OPENCSTL_ALWAYS_INLINE uint64_t __ht_mum(uint64_t a, uint64_t b) {
#if defined(__SIZEOF_INT128__)
    __uint128_t r = (__uint128_t) a * b;
    return (uint64_t) r ^ (uint64_t) (r >> 64);
#elif defined(_MSC_VER) && defined(_M_X64)
    uint64_t hi;
    uint64_t lo = _umul128(a, b, &hi);
    return lo ^ hi;
#else
    uint64_t ha = a >> 32, la = (uint32_t) a;
    uint64_t hb = b >> 32, lb = (uint32_t) b;
    return ha * hb ^ ((ha * lb + hb * la) >> 32) ^ (la * lb >> 32);
#endif
}
OPENCSTL_ALWAYS_INLINE size_type64 hash_mixer(void *key, size_type64 n) {
    static const uint64_t s0 = 0xa0761d6478bd642fULL;
    static const uint64_t s1 = 0xe7037ed1a0b428dbULL;
    if (n == 4) {
        uint32_t v;
        memcpy(&v, key, 4);
        return (size_type64) __ht_mum((uint64_t) v ^ s1, s0);
    }
    if (n == 8) {
        uint64_t v;
        memcpy(&v, key, 8);
        return (size_type64) __ht_mum(v ^ s1, s0);
    }
    return (size_type64) _cstl_hash(key, n);
}
OPENCSTL_ALWAYS_INLINE uint8_t __ht_ctrl(size_type64 h) {
    return (uint8_t) ((h >> 56) | 0x80u);
}
#define __HASHTABLE_DEFAULT_SIZE__ HT_MIN_CAP
static uint8_t *__ht_alloc_ctrl(size_type64 cap) {
    uint8_t *m = (uint8_t *) calloc(cap, 1);
    verify(m!=NULL);
    return m;
}
static void __ht_reinsert(
    void *base, uint8_t *ctrl, size_type64 cap_mask,
    const void *key, const void *value,
    size_type64 key_size, size_type64 value_size, size_type64 type_size, size_type64 h
) {
    size_type64 idx = h & cap_mask;
    uint8_t c = __ht_ctrl(h);
    while (ctrl[idx] != HT_CTRL_EMPTY) idx = (idx + 1) & cap_mask;
    ctrl[idx] = c;
    memcpy((char *) base + idx * type_size, key, key_size);
    if (value_size && value)
        memcpy((char *) base + idx * type_size + key_size, value, value_size);
}
static void __ht_do_rehash(
    void **container, size_type64 header_sz,
    size_type64 key_size, size_type64 value_size, size_type64 type_size,
    size_type64 old_cap, uint8_t *old_ctrl
) {
    size_type64 new_cap = old_cap * 2;
    void *new_raw = calloc(header_sz + new_cap * type_size, 1);
    verify(new_raw!=NULL);
    memcpy(new_raw, (char *) *container - header_sz, header_sz);
    uint8_t *new_ctrl = __ht_alloc_ctrl(new_cap);
    void *nb = (char *) new_raw + header_sz;
    size_type64 new_mask = new_cap - 1;
    for (size_type64 i = 0; i < old_cap; i++) {
        if (old_ctrl[i] != HT_CTRL_EMPTY) {
            const void *ok = (const char *) *container + i * type_size;
            const void *ov = value_size > 0 ? (const char *) ok + key_size : NULL;
            size_type64 h = hash_mixer((void *) ok, key_size);
            __ht_reinsert(nb, new_ctrl, new_mask, ok, ov,
                          key_size, value_size, type_size, h);
        }
    }
    void *old_ptr = *container;
    free((char *) *container - header_sz);
    free(old_ctrl);
    *container = nb;
    OPENCSTL_NIDX(container, -7) = new_mask;
    OPENCSTL_NIDX(container, -6) = (size_type64) (uintptr_t) new_ctrl;
    htm_erase(htm, old_ptr);
    htm_insert(htm, *container,
               (char *) *container + type_size * new_cap,
               (char *) new_ctrl, (int) type_size);
}
OPENCSTL_FUNC
void __cstl_hashtable_insert(void **container, void *key, void *value) {
    size_type64 key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 value_size = OPENCSTL_NIDX(container, -4);
    size_type64 type_size = key_size + value_size;
    size_type64 cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float_key = OPENCSTL_NIDX(container, -8);
    size_type64 is_float_value = OPENCSTL_NIDX(container, -9);
    float kf = 0.f, vf = 0.f;
    if (is_float_key) {
        kf = (float) *(double *) key;
        key = &kf;
    }
    if (is_float_value) {
        vf = (float) *(double *) value;
        value = &vf;
    }
#endif
    size_type64 h = hash_mixer(key, key_size);
    uint8_t c = __ht_ctrl(h);
    size_type64 idx = h & cap_mask;
    char *base = (char *) *container;
    while (true) {
        uint8_t m = ctrl[idx];
        if (m == HT_CTRL_EMPTY) break;
        if (m == c && __ht_key_eq(base + idx * type_size, key, key_size))
            return;
        idx = (idx + 1) & cap_mask;
    }
    size_type64 length = OPENCSTL_NIDX(container, -1);
    if (OPENCSTL_UNLIKELY(length + 1 > HT_THRESHOLD(cap_mask + 1))) {
        size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
        __ht_do_rehash(container, header_sz, key_size, value_size, type_size,
                       cap_mask + 1, ctrl);
        cap_mask = OPENCSTL_NIDX(container, -7);
        ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
        base = (char *) *container;
        idx = h & cap_mask;
        while (ctrl[idx] != HT_CTRL_EMPTY) idx = (idx + 1) & cap_mask;
    }
    ctrl[idx] = c;
    memcpy(base + idx * type_size, key, key_size);
    if (value_size && value)
        memcpy(base + idx * type_size + key_size, value, value_size);
    OPENCSTL_NIDX(container, -1) = length + 1;
}
OPENCSTL_FUNC
void __cstl_hashtable_erase(void **container, void *key) {
    size_type64 key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    size_type64 value_size = OPENCSTL_NIDX(container, -4);
    size_type64 type_size = key_size + value_size;
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float_key = OPENCSTL_NIDX(container, -8);
    float kf = 0.f;
    if (is_float_key) {
        kf = (float) *(double *) key;
        key = &kf;
    }
#endif
    size_type64 h = hash_mixer(key, key_size);
    uint8_t c = __ht_ctrl(h);
    size_type64 idx = h & cap_mask;
    char *base = (char *) *container;
    while (true) {
        uint8_t m = ctrl[idx];
        if (m == HT_CTRL_EMPTY) return;
        if (m == c && __ht_key_eq(base + idx * type_size, key, key_size))
            break;
        idx = (idx + 1) & cap_mask;
    }
    size_type64 hole = idx;
    size_type64 j = (idx + 1) & cap_mask;
    while (ctrl[j] != HT_CTRL_EMPTY) {
        size_type64 nh = hash_mixer(base + j * type_size, key_size) & cap_mask;
        size_type64 dist_j = (j - nh) & cap_mask;
        size_type64 dist_hole = (hole - nh) & cap_mask;
        if (dist_hole < dist_j) {
            memcpy(base + hole * type_size, base + j * type_size, type_size);
            ctrl[hole] = ctrl[j];
            hole = j;
        }
        j = (j + 1) & cap_mask;
    }
    ctrl[hole] = HT_CTRL_EMPTY;
    OPENCSTL_NIDX(container, -1)--;
}
OPENCSTL_FUNC
void *__cstl_hashtable_find(void **container, void *key) {
    size_type64 key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    size_type64 value_size = OPENCSTL_NIDX(container, -4);
    size_type64 type_size = key_size + value_size;
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float_key = OPENCSTL_NIDX(container, -8);
    float kf = 0.f;
    if (is_float_key) {
        kf = (float) *(double *) key;
        key = &kf;
    }
#endif
    size_type64 h = hash_mixer(key, key_size);
    uint8_t c = __ht_ctrl(h);
    size_type64 idx = h & cap_mask;
    char *base = (char *) *container;
    while (true) {
        uint8_t m = ctrl[idx];
        if (m == HT_CTRL_EMPTY) return NULL;
        if (m == c && __ht_key_eq(base + idx * type_size, key, key_size))
            return base + idx * type_size;
        idx = (idx + 1) & cap_mask;
    }
}
OPENCSTL_FUNC
void __cstl_hashtable_clear(void **container) {
    size_type64 cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    memset(ctrl, 0, cap_mask + 1);
    OPENCSTL_NIDX(container, -1) = 0;
}
OPENCSTL_FUNC
void *__cstl_hashtable_begin(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE) + OPENCSTL_NIDX(container, -4);
    size_type64 cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    for (size_type64 i = 0; i <= cap_mask; i++)
        if (ctrl[i] != HT_CTRL_EMPTY)
            return (char *) *container + i * type_size;
    return NULL;
}
OPENCSTL_FUNC
void *__cstl_hashtable_end(void **container) { return NULL; }
OPENCSTL_FUNC
void *__cstl_hashtable_rbegin(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE) + OPENCSTL_NIDX(container, -4);
    size_type64 cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    for (int i = (int) cap_mask; i >= 0; i--)
        if (ctrl[i] != HT_CTRL_EMPTY)
            return (char *) *container + i * type_size;
    return NULL;
}
OPENCSTL_FUNC
void *__cstl_hashtable_rend(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE) + OPENCSTL_NIDX(container, -4);
    return (char *) *container - type_size;
}
OPENCSTL_FUNC
void *__cstl_hashtable_empty(void **container) {
    return __cstl_hashtable_rend(container);
}
OPENCSTL_FUNC size_type __cstl_hashtable_size(void **container) {
    return (size_type) OPENCSTL_NIDX(container, -1);
}
OPENCSTL_FUNC size_type __cstl_hashtable_capacity(void **container) {
    return (size_type) OPENCSTL_NIDX(container, -7) + 1;
}
OPENCSTL_FUNC
void *__cstl_hashtable_next_prev(void *it, int n) {
    HashtableManager *chtm = htm_find(htm, it);
    size_type64 ts = (size_type64) chtm->type_size;
    size_type64 cap = ((char *) chtm->p2 - (char *) chtm->p1) / ts;
    uint8_t *ctrl = (uint8_t *) chtm->tombstone;
    if (n == -1) {
        size_type64 pos = ((char *) it - (char *) chtm->p1) / ts + 1;
        for (; pos < cap; pos++)
            if (ctrl[pos] != HT_CTRL_EMPTY)
                return (char *) chtm->p1 + pos * ts;
        return NULL;
    }
    if (n == -2) {
        size_type64 pos = ((char *) it - (char *) chtm->p1) / ts;
        if (pos == 0) return (char *) chtm->p1 - ts;
        for (size_type64 i = pos - 1; ; i--) {
            if (ctrl[i] != HT_CTRL_EMPTY)
                return (char *) chtm->p1 + i * ts;
            if (i == 0) break;
        }
        return (char *) chtm->p1 - ts;
    }
    return NULL;
}
OPENCSTL_FUNC
void __cstl_hashtable_free(void **container) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    HashtableManager *chtm = htm_find(htm, *container);
    htm_erase(htm, chtm->p1);
    free(ctrl);
    free((char *) (*container) - header_sz);
    *container = NULL;
}
OPENCSTL_FUNC
void __cstl_hashtable_reserve(void **container, size_type64 n) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 value_size = OPENCSTL_NIDX(container, -4);
    size_type64 type_size = key_size + value_size;
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 cap_mask_old = OPENCSTL_NIDX(container, -7);
    uint8_t *old_ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    size_type64 want = length + n;
    size_type64 min_cap = (want * HT_LOAD_DEN + (HT_LOAD_NUM - 1)) / HT_LOAD_NUM;
    if (min_cap < __HASHTABLE_DEFAULT_SIZE__) min_cap = __HASHTABLE_DEFAULT_SIZE__;
    size_type64 new_cap = __ht_next_pow2(min_cap);
    if (new_cap <= cap_mask_old + 1) return;
    void *new_raw = calloc(header_sz + new_cap * type_size, 1);
    verify(new_raw!=NULL);
    memcpy(new_raw, (char *) *container - header_sz, header_sz);
    uint8_t *new_ctrl = __ht_alloc_ctrl(new_cap);
    void *nb = (char *) new_raw + header_sz;
    size_type64 new_mask = new_cap - 1;
    for (size_type64 i = 0; i <= cap_mask_old; i++) {
        if (old_ctrl[i] != HT_CTRL_EMPTY) {
            const void *ok = (const char *) *container + i * type_size;
            const void *ov = value_size > 0 ? (const char *) ok + key_size : NULL;
            size_type64 h = hash_mixer((void *) ok, key_size);
            __ht_reinsert(nb, new_ctrl, new_mask, ok, ov,
                          key_size, value_size, type_size, h);
        }
    }
    void *old_ptr = *container;
    free((char *) *container - header_sz);
    free(old_ctrl);
    *container = nb;
    OPENCSTL_NIDX(container, -7) = new_mask;
    OPENCSTL_NIDX(container, -6) = (size_type64) (uintptr_t) new_ctrl;
    htm_erase(htm, old_ptr);
    htm_insert(htm, *container,
               (char *) *container + type_size * new_cap,
               (char *) new_ctrl, (int) type_size);
}
#define _CSTL_USET_EXPAND(x) x
#define cstl_unordered_set _cstl_unordered_set
#define _cstl_unordered_set(...) _CSTL_USET_EXPAND(_CSTL_USET_DISPATCH(__VA_ARGS__, NULL, NULL))
#define _CSTL_USET_DISPATCH(KEY, FUNC, ...) __cstl_unordered_set(sizeof(KEY),#KEY,(void*)(FUNC))
OPENCSTL_FUNC
void *__cstl_unordered_set(size_type64 key_size, const char *type_key, void *hash_func) {
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    size_type64 cap = __HASHTABLE_DEFAULT_SIZE__;
    void *ptr = (char *) calloc(header_sz + key_size * cap, 1) + header_sz;
    void **c = &ptr;
    uint8_t *ctrl = __ht_alloc_ctrl(cap);
    OPENCSTL_NIDX(c, NIDX_CTYPE) = OPENCSTL_UNORDERED_SET;
    OPENCSTL_NIDX(c, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(c, NIDX_TSIZE) = key_size;
    OPENCSTL_NIDX(c, -9) = 0;
    OPENCSTL_NIDX(c, -8) = !strcmp(type_key, "float");
    OPENCSTL_NIDX(c, -7) = cap - 1;
    OPENCSTL_NIDX(c, -6) = (size_type64) (uintptr_t) ctrl;
    OPENCSTL_NIDX(c, -4) = 0;
    OPENCSTL_NIDX(c, -3) = (size_type64) type_key;
    OPENCSTL_NIDX(c, -2) = (size_type64) hash_func;
    OPENCSTL_NIDX(c, -1) = 0;
    OPENCSTL_NIDX(c, 0) = 0;
    bool htm_init = false;
    if (htm == NULL) {
        htm = htm_new();
        htm_init = true;
    }
    htm_insert(htm, ptr, (char *) ptr + (key_size * cap), (char *) ctrl, (int) key_size);
    if (htm_init) {
        atexit(__cstl_htm_destroy);
    }
    return ptr;
}
#define _CSTL_UMAP_EXPAND(x) x
#define cstl_unordered_map(...) _CSTL_UMAP_EXPAND(_CSTL_UMAP_DISPATCH(__VA_ARGS__, NULL, NULL))
#define _cstl_unordered_map(...) _CSTL_UMAP_EXPAND(_CSTL_UMAP_DISPATCH(__VA_ARGS__, NULL, NULL))
#define _CSTL_UMAP_DISPATCH(KEY,VALUE,FUNC,...) __cstl_unordered_map(sizeof(KEY),sizeof(VALUE),#KEY,#VALUE,(void*)(FUNC))
OPENCSTL_FUNC
void *__cstl_unordered_map(size_type64 key_size, size_type64 value_size,
                           const char *type_key, const char *type_value,
                           void *hash_func) {
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    size_type64 type_size = key_size + value_size;
    size_type64 cap = __HASHTABLE_DEFAULT_SIZE__;
    void *ptr = (char *) calloc(header_sz + type_size * cap, 1) + header_sz;
    void **c = &ptr;
    uint8_t *ctrl = __ht_alloc_ctrl(cap);
    OPENCSTL_NIDX(c, NIDX_CTYPE) = OPENCSTL_UNORDERED_MAP;
    OPENCSTL_NIDX(c, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(c, NIDX_TSIZE) = key_size;
    OPENCSTL_NIDX(c, -9) = !strcmp(type_value, "float");
    OPENCSTL_NIDX(c, -8) = !strcmp(type_key, "float");
    OPENCSTL_NIDX(c, -7) = cap - 1;
    OPENCSTL_NIDX(c, -6) = (size_type64) (uintptr_t) ctrl;
    OPENCSTL_NIDX(c, -4) = value_size;
    OPENCSTL_NIDX(c, -3) = (size_type64) type_key;
    OPENCSTL_NIDX(c, -2) = (size_type64) hash_func;
    OPENCSTL_NIDX(c, -1) = 0;
    OPENCSTL_NIDX(c, 0) = 0;
    bool htm_init = false;
    if (htm == NULL) {
        htm = htm_new();
        htm_init = true;
    }
    htm_insert(htm, ptr, (char *) ptr + (type_size * cap), (char *) ctrl, (int) type_size);
    if (htm_init) {
        atexit(__cstl_htm_destroy);
    }
    return ptr;
}
#endif
#ifndef OPENCSTL_ARRAY_H
#define OPENCSTL_ARRAY_H
#define cstl_array(TYPE,COUNT)	__cstl_array(sizeof(TYPE),#TYPE,COUNT)
OPENCSTL_FUNC void *__cstl_array(size_type64 type_size, char *type, size_type64 _count) {
    verify(_count !=0);
    size_type64 header_sz = sizeof(size_type64) * OPENCSTL_HEADER;
    void *block = galloc(header_sz + (type_size * _count), type_size);
    if (block == NULL) {
        fault("Failed to allocate memory for array");
        return NULL;
    }
    void *ptr = ((char *) block) + header_sz;
    void **container = &ptr;
    OPENCSTL_NIDX(container, NIDX_CTYPE) = OPENCSTL_ARRAY;
    OPENCSTL_NIDX(container, NIDX_HSIZE) = header_sz;
    OPENCSTL_NIDX(container, NIDX_TSIZE) = type_size;
    OPENCSTL_NIDX(container, -8) = !strcmp(type, "float");
    OPENCSTL_NIDX(container, -4) = (size_type64) type;
    OPENCSTL_NIDX(container, -3) = 0;
    OPENCSTL_NIDX(container, -2) = _count;
    OPENCSTL_NIDX(container, -1) = _count;
    return ptr;
}
OPENCSTL_FUNC size_type __cstl_array_size(void **container) {
    return (size_type) OPENCSTL_NIDX(container, -1);
}
OPENCSTL_FUNC size_type __cstl_array_capacity(void **container) {
    return (size_type) OPENCSTL_NIDX(container, -2);
}
OPENCSTL_FUNC size_type __cstl_array_max_size(void **container) {
    return (size_type) OPENCSTL_NIDX(container, -2);
}
OPENCSTL_FUNC void *__cstl_array_begin(void **container) {
    return (void *) *container;
}
OPENCSTL_FUNC void *__cstl_array_end(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    return (void *) ((char *) *container + (type_size * length));
}
OPENCSTL_FUNC void *__cstl_array_rbegin(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    return (void *) ((char *) *container + (type_size * (length - 1)));
}
OPENCSTL_FUNC void *__cstl_array_rend(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    return (void *) ((char *) *container - (type_size));
}
OPENCSTL_FUNC void *__cstl_array_find(void **container, void *iter_begin, void *value) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 pos = (*(char **) iter_begin - *(char **) container) / type_size;
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    for (size_type64 i = pos; i < length; i++) {
        if (memcmp((char *) *container + type_size * (i), value, type_size) == 0) {
            return (char *) *container + type_size * (i);
        }
    }
    return NULL;
}
OPENCSTL_FUNC void __cstl_array_free(void **container) {
#ifdef OPENCSTL_TRACER
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    gfree((char *) (*container) - header_sz);
#else
    gfree(*container);
#endif
}
OPENCSTL_FUNC void *__cstl_array_next(void *it, size_type64 type_size) {
    return (char *) it + type_size;
}
OPENCSTL_FUNC void *__cstl_array_prev(void *it, size_type64 type_size) {
    return (char *) it - type_size;
}
OPENCSTL_FUNC void __cstl_array_reverse(void **container) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
    size_type64 idx = 0;
    size_type64 idx_r = length - 1;
    while (idx < idx_r) {
        swap((char *) *container + type_size * (idx), (char *) *container + type_size * (idx_r), type_size);
        idx++;
        idx_r--;
    }
}
OPENCSTL_FUNC size_type64 __cstl_array_count(void **container, void *value) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    CSTL_EQUALS_FN is_equal = CSTL_EQUALS(type);
    size_type64 cnt = 0;
    for (int i = 0; i < length; i++) {
        void *ptr = ((char *) *container) + (type_size * i);
        if (is_equal(ptr, value, type_size) == 0) {
            cnt++;
        }
    }
    return cnt;
}
OPENCSTL_FUNC size_type64 __cstl_array_count_if(void **container, CSTL_COND cond) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
    size_type64 cnt = 0;
    for (int i = 0; i < length; i++) {
        void *ptr = ((char *) *container) + (type_size * i);
        if (cond(ptr)) {
            cnt++;
        }
    }
    return cnt;
}
OPENCSTL_FUNC void *__cstl_array_lower_bound(void **container, void *value, CSTL_COMPARE compare) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (length == 0) return NULL;
    size_type64 L = 0;
    size_type64 R = length;
    while (L < R) {
        size_type64 M = L + (R - L) / 2;
        void *Mptr = ((char *) *container) + (type_size * M);
        if (compare(Mptr, value) < 0)
            L = M + 1;
        else
            R = M;
    }
    if (L >= length) return NULL;
    return ((char *) *container) + (type_size * L);
}
OPENCSTL_FUNC void *__cstl_array_upper_bound(void **container, void *value, CSTL_COMPARE compare) {
    size_type64 header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    size_type64 capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_type64 is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (length == 0) return NULL;
    size_type64 L = 0;
    size_type64 R = length;
    while (L < R) {
        size_type64 M = L + (R - L) / 2;
        void *Mptr = ((char *) *container) + (type_size * M);
        if (compare(value, Mptr) < 0)
            R = M;
        else
            L = M + 1;
    }
    if (L >= length) return NULL;
    return ((char *) *container) + (type_size * L);
}
#endif
#if !defined(HG_F5E8FFEF752BAB76E14F9A1769EAC95C8E92BFF223E1FAA4CABA295E38724C7A_H)
#define HG_F5E8FFEF752BAB76E14F9A1769EAC95C8E92BFF223E1FAA4CABA295E38724C7A_H
#ifndef OPENCSTL_ITERATOR_H
#define OPENCSTL_ITERATOR_H
#define first(IT)                   (*IT)
#define second(IT, TYPE)            ((TYPE)cstl_value(IT, TYPE))
OPENCSTL_FUNC bool __is_hashtable_iter(void *it) {
#ifdef HTM_VEBT
    if (htm == NULL) {
        return false;
    }
    return htm_find(htm, it) != NULL;
#else
    for (size_type64 i = 0; i < htm_length; i++) {
        if (htm[i].p1 <= it && it < htm[i].p2) {
            return true;
        }
    }
    return false;
#endif
}
OPENCSTL_FUNC void *_cstl_next(void *it) {
    if (__is_hashtable_iter(it)) {
        return __cstl_hashtable_next_prev(it, -1);
    }
    Interval *iv = iveb_find(iveb, it);
    if (iv != NULL) {
        if (iv->ctype == CT_VECTOR || iv->ctype == CT_DEQUE) {
            return __cstl_vector_next(it, iv->type_size);
        }
    }
    GInterval *giv = giveb_find(giveb, it);
    if (giv != NULL) {
        return __cstl_array_next(it, giv->type_size);
    }
    size_type64 node_type = OPENCSTL_NIDX(&it, -3);
    switch (node_type) {
        case OPENCSTL_LIST: {
            return __cstl_list_next_prev(it, -1);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            return __cstl_tree_next_prev(it, -1, -2, __cstl_tree_toleft);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            return __cstl_hashtable_next_prev(it, -1);
        }
        break;
        default: {
            fault("Invalid operation");
        }
        break;
    }
    return NULL;
}
OPENCSTL_FUNC void *_cstl_prev(void *it) {
    if (__is_hashtable_iter(it)) {
        return __cstl_hashtable_next_prev(it, -2);
    }
    Interval *iv = iveb_find(iveb, it);
    if (iv != NULL) {
        if (iv->ctype == CT_VECTOR || iv->ctype == CT_DEQUE) {
            return __cstl_vector_prev(it, iv->type_size);
        }
    }
    GInterval *giv = giveb_find(giveb, it);
    if (giv != NULL) {
        return __cstl_array_prev(it, giv->type_size);
    }
    size_type64 node_type = OPENCSTL_NIDX(&it, -3);
    switch (node_type) {
        case OPENCSTL_LIST: {
            return __cstl_list_next_prev(it, -2);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            return __cstl_tree_next_prev(it, -2, -1, __cstl_tree_toright);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            return __cstl_hashtable_next_prev(it, -2);
        }
        break;
        default: {
            fault("Invalid operation");
        }
    }
    return NULL;
}
OPENCSTL_FUNC void *_cstl_begin(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (NIDX_CTYPE) * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            return __cstl_array_begin((void **) container);
        }
        break;
        case OPENCSTL_VECTOR: {
            return __cstl_vector_begin((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            return __cstl_list_begin((void **) container);
        }
        break;
        case OPENCSTL_DEQUE: {
            return __cstl_deque_begin((void **) container);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            return __cstl_tree_begin((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            return __cstl_hashtable_begin((void **) container);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    return NULL;
}
OPENCSTL_FUNC void *_cstl_rbegin(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (NIDX_CTYPE) * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            return __cstl_array_rbegin((void **) container);
        }
        break;
        case OPENCSTL_VECTOR: {
            return __cstl_vector_rbegin((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            return __cstl_list_rbegin((void **) container);
        }
        break;
        case OPENCSTL_DEQUE: {
            return __cstl_deque_rbegin((void **) container);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            return __cstl_tree_rbegin((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            return __cstl_hashtable_rbegin((void **) container);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    return NULL;
}
OPENCSTL_FUNC void *_cstl_end(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (NIDX_CTYPE) * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            return __cstl_array_end((void **) container);
        }
        break;
        case OPENCSTL_VECTOR: {
            return __cstl_vector_end((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            return __cstl_list_end_rend((void **) container);
        }
        break;
        case OPENCSTL_DEQUE: {
            return __cstl_deque_end((void **) container);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            return __cstl_tree_end_rend((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            return __cstl_hashtable_end((void **) container);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    return NULL;
}
OPENCSTL_FUNC void *_cstl_rend(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (NIDX_CTYPE) * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            return __cstl_array_rend((void **) container);
        }
        break;
        case OPENCSTL_VECTOR: {
            return __cstl_vector_rend((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            return __cstl_list_end_rend((void **) container);
        }
        break;
        case OPENCSTL_DEQUE: {
            return __cstl_deque_rend((void **) container);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            return __cstl_tree_end_rend((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            return __cstl_hashtable_rend((void **) container);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    return NULL;
}
#endif
bool is_even(const void *it) {
    int val = *(int *) it;
    return val % 2 == 0;
}
#define fill(_First, _Last, _Value) _cstl_fill(_First, _Last, &(__typeof__(_Value)){_Value}, sizeof(_Value))
OPENCSTL_FUNC void _cstl_fill(void *_begin, void *_end, void *_value, size_type64 _value_size) {
    void *it = _begin;
    while (it != _end) {
        memcpy(it, _value, _value_size);
        it = cstl_next(it);
    }
}
OPENCSTL_FUNC size_type64 _cstl_count(void *container, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, container, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_type64 cnt = 0;
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            cnt = __cstl_vector_count((void **) container, param1);
        }
        break;
        case OPENCSTL_DEQUE: {
            cnt = __cstl_deque_count((void **) container, param1);
        }
        break;
        default: {
            fault("Unsupported container type");
        }
        break;
    }
    __cstl_va_end(vl);
    return cnt;
}
static size_type64 count(void *C, ...) {
    va_list args;
    va_start(args, C);
    size_type64 result = _cstl_count(&C, args);
    va_end(args);
    return result;
}
OPENCSTL_FUNC size_type64 _cstl_count_if(void *container, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, container, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_type64 cnt = 0;
#if CSTL_USE_VAARG
    CSTL_COND cond = (CSTL_COND) param1;
#else
    CSTL_COND cond = *(CSTL_COND *) param1;
#endif
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            cnt = __cstl_vector_count_if((void **) container, cond);
        }
        break;
        case OPENCSTL_DEQUE: {
            cnt = __cstl_deque_count_if((void **) container, cond);
        }
        break;
        default: {
            fault("Unsupported container type");
        }
        break;
    }
    __cstl_va_end(vl);
    return cnt;
}
OPENCSTL_FUNC void *_cstl_lower_bound(void *container, int argc, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, argc, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
    void *param2 = __cstl_va_arg_next(vl);
    void *param3 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
    void *param2 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 1);
    void *param3 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 2);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    void *ret = NULL;
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            if (argc >= 3) {
                fault("Not implemented");
            } else {
                if (argc == 1) {
                    size_type64 type_size = OPENCSTL_NIDX((void**)container, NIDX_TSIZE);
                    param2 = _memcmp_funcs[type_size];
                }
                ret = __cstl_vector_lower_bound((void **) container, param1, param2);
            }
        }
        break;
        case OPENCSTL_DEQUE: {
            if (argc >= 3) {
                fault("Not implemented");
            } else {
                if (argc == 1) {
                    ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
                    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
                    param2 = _memcmp_funcs[type_size];
                }
                ret = __cstl_deque_lower_bound((void **) container, param1, param2);
            }
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    __cstl_va_end(vl);
    return ret;
}
OPENCSTL_FUNC void *_cstl_upper_bound(void *container, int argc, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, argc, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
    void *param2 = __cstl_va_arg_next(vl);
    void *param3 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
    void *param2 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 1);
    void *param3 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 2);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    void *ret = NULL;
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            if (argc >= 3) {
                fault("Not implemented");
            } else {
                if (argc == 1) {
                    size_type64 type_size = OPENCSTL_NIDX((void**)container, NIDX_TSIZE);
                    param2 = _memcmp_funcs[type_size];
                }
                ret = __cstl_vector_upper_bound((void **) container, param1, param2);
            }
        }
        break;
        case OPENCSTL_DEQUE: {
            if (argc >= 3) {
                fault("Not implemented");
            } else {
                if (argc == 1) {
                    ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
                    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_TSIZE * (ptrdiff_t) sizeof(size_type64) + distance);
                    param2 = _memcmp_funcs[type_size];
                }
                ret = __cstl_deque_upper_bound((void **) container, param1, param2);
            }
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    __cstl_va_end(vl);
    return ret;
}
#ifndef MAX
#define MAX(a,b) ((a)>(b)?(a):(b))
#endif
#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif
#ifndef OPENCSTL_USE_PREFIX
#define max_element(C, ...) ocstl_min_max_element(&(C), ##__VA_ARGS__, 1LL, NULL)
#define min_element(C, ...) ocstl_min_max_element(&(C), ##__VA_ARGS__, 0LL, NULL)
#endif
OPENCSTL_FUNC void ocstl_minmax_container_type_check(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_ARRAY:
        case OPENCSTL_VECTOR:
        case OPENCSTL_DEQUE:
        case OPENCSTL_LIST:
        case OPENCSTL_SET:
        case OPENCSTL_MAP:
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP:
            break;
        default:
            fault("max_element/min_element: unsupported container type");
    }
}
static int ocstl_max_cmp(const CSTL_COMPARE cmp, const void *a, const void *b) {
    return cmp(a, b);
}
static int ocstl_min_cmp(const CSTL_COMPARE cmp, const void *a, const void *b) {
    return cmp(b, a);
}
typedef int (*OCSTL_MM_CMP)(const CSTL_COMPARE, const void *, const void *);
OPENCSTL_FUNC void *ocstl_min_max_element(void *container, ...) {
    ocstl_minmax_container_type_check(container);
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, container, va_ptr);
#if CSTL_USE_VAARG
    CSTL_COMPARE cmp = (CSTL_COMPARE) __cstl_va_arg_next(vl);
    size_type64 is_max = (size_type64) __cstl_va_arg_next(vl);
#else
    CSTL_COMPARE cmp = *(CSTL_COMPARE *) __cstl_va_arg(va_ptr);
    size_type64 is_max = *(size_type64 *) __cstl_va_arg((char *) va_ptr + sizeof(void *) * 1);
#endif
    __cstl_va_end(vl);
    OCSTL_MM_CMP wrp_cmp = is_max ? ocstl_max_cmp : ocstl_min_cmp;
    void *_begin = _cstl_begin(container);
    void *_end = _cstl_end(container);
    if (_begin == _end) {
        return _end;
    }
    if (cmp == NULL) {
        Interval *tm = iveb_find(iveb, _begin);
        cmp = LESS(tm->type_name);
        if (cmp == NULL) {
            cmp = _memcmp_funcs[tm->type_size];
        }
        verify(cmp != NULL);
    }
    void *max_it = _begin;
    void *it = cstl_next(_begin);
    while (it != _end) {
        if (wrp_cmp(cmp, it, max_it) > 0) {
            max_it = it;
        }
        it = cstl_next(it);
    }
    return max_it;
}
#endif
#if !defined(OPENCSTL_MT19937_H)
#define OPENCSTL_MT19937_H
#include <stdint.h>
#include <time.h>
#define MT64_N          312
#define MT64_M          156
#define MT64_MATRIX_A   0xB5026F5AA96619E9ULL
#define MT64_UPPER_MASK 0xFFFFFFFF80000000ULL
#define MT64_LOWER_MASK 0x7FFFFFFFULL
typedef struct {
    uint64_t mt[MT64_N];
    int index;
} __mt19937_64_t;
__mt19937_64_t __rng64 = {
    {
        1776098118,
        4095968591,
        2489032677,
        2495002180,
        1521698085,
        3468952409,
        1098923224,
        2876365311,
        3875427246,
        2303920453,
        3481655941,
        3656246169,
        3488737099,
        1911217468,
        3072370164,
        54539853,
        2100673779,
        3365782472,
        3678642746,
        3156232773,
        423872610,
        384980604,
        14136892,
        1456753616,
        237535746,
        3636975731,
        2024840138,
        2028378269,
        1647654370,
        3507099562,
        2984247251,
        2709726729,
        4136871816,
        2050550537,
        819447735,
        3874448673,
        1342874910,
        2832492440,
        2016583134,
        124576301,
        1384715537,
        3530629926,
        671516421,
        2761930297,
        648433457,
        1017100791,
        1981299097,
        3101820692,
        2950834868,
        1756679637,
        584964515,
        4081098669,
        1775854538,
        3437182948,
        1020220836,
        341993995,
        3408141005,
        2904582044,
        94705709,
        1395954468,
        2723919850,
        4100156421,
        4019124044,
        1842129442,
        4079666746,
        3677560224,
        3999536271,
        2893025081,
        4228019062,
        3210991107,
        1390517408,
        662431847,
        1090909027,
        1852368304,
        1200827841,
        521259154,
        2855284515,
        202287130,
        1068495373,
        2234023621,
        3282764785,
        323567790,
        3148296635,
        391185413,
        3058708111,
        3342934558,
        3443548783,
        2861981824,
        2794386527,
        142350258,
        2955638948,
        3162968156,
        3760718351,
        3871919616,
        1645458827,
        1497555060,
        3613359691,
        458681097,
        2981316388,
        713218878,
        3450818032,
        1431683567,
        1600366697,
        1714270684,
        1544611227,
        941048232,
        2087772914,
        907867291,
        4128335230,
        2840844480,
        1774507957,
        2264249920,
        1258670090,
        1947410483,
        2037348156,
        3228252038,
        1761066031,
        2293032587,
        4078238904,
        3236442710,
        2705458281,
        2303876801,
        1926326119,
        3998075151,
        2811251186,
        930843956,
        1144233212,
        3332349131,
        97732309,
        3849002316,
        2915293496,
        2810737890,
        1149413950,
        1535291243,
        3360025429,
        3421309515,
        3433858864,
        1712656768,
        2497877002,
        28081018,
        1500134564,
        1291223784,
        2088311216,
        678941823,
        4050017251,
        804407025,
        3248654108,
        3933873068,
        4007401725,
        2277599457,
        1076301181,
        2622448272,
        3748282735,
        1821610946,
        817739489,
        2234696578,
        1210669987,
        2701425175,
        2214421026,
        486743705,
        761055154,
        2043636369,
        1639492383,
        2540008982,
        892906626,
        3301593260,
        2463924540,
        2304834400,
        2865483490,
        4019518352,
        3388450644,
        2519700470,
        2378632848,
        3859218429,
        41583399,
        3551979613,
        455310134,
        1784672860,
        2439363685,
        1129068494,
        1190855146,
        1219423658,
        1519984024,
        2292587420,
        457621073,
        26485539,
        44862599,
        4036930934,
        1752500768,
        500049802,
        3842075558,
        3846522605,
        1330514793,
        296294288,
        1509560985,
        3534138747,
        871597155,
        3371132114,
        3468519555,
        3117276577,
        771937135,
        879279391,
        1934008381,
        1167355102,
        3585722021,
        2714912251,
        1754911891,
        726519327,
        1643748675,
        3770213438,
        3328598245,
        2760155758,
        2639634685,
        2778091809,
        1699423094,
        659540027,
        2343729207,
        2118446589,
        74406227,
        218555160,
        30856212,
        1167930465,
        3467170840,
        4084379716,
        2016327892,
        1786161279,
        1516085301,
        1338537268,
        530933512,
        3684209364,
        2513271217,
        1475130583,
        4151669683,
        1501144793,
        1340046562,
        2965836453,
        1148330311,
        417665896,
        2097316195,
        2645187881,
        1399929080,
        2659323017,
        1490103303,
        363804462,
        3465020727,
        3639391603,
        1334768429,
        2136970163,
        58803944,
        2115603995,
        1159651724,
        3891861745,
        3070456198,
        142601912,
        3549937283,
        1064205062,
        1475451662,
        1811199306,
        3691353348,
        2849091044,
        3302207000,
        4132176068,
        989617620,
        51194066,
        717904882,
        4168333670,
        2453975333,
        2041085414,
        4005969440,
        3758836276,
        3903149919,
        4189289922,
        548363216,
        973394894,
        1839689710,
        1896955670,
        1636598469,
        1933293750,
        3097838145,
        3857376222,
        2039165214,
        2629174834,
        4288046775,
        3240581823,
        1710208853,
        337962299,
        3788182518,
        2090635011,
        1721836154,
        2416252352,
        3422851855,
        2488421740,
        1397862477,
        1477292673,
        1997234387,
        2430055230,
        2579580596,
        1704015956,
        2216497525,
        2313035196,
        610434450,
        4230676740,
        1885612770,
        3439405078,
        2028271374,
        3388301479,
        3283245152,
        3050416026,
        2302106739,
        2730938597,
        1762153169,
        3610328820
    },
    MT64_N
};
__mt19937_64_t __uuid64 = {0};
static void __mt19937_64_uuid_seed(uint64_t seed) {
    __uuid64.mt[0] = seed;
    for (int i = 1; i < MT64_N; i++) {
        __uuid64.mt[i] = 6364136223846793005ULL * (__uuid64.mt[i - 1] ^ (__uuid64.mt[i - 1] >> 62)) + (uint64_t) i;
    }
    __uuid64.index = MT64_N;
}
static void __mt19937_64_seed(uint64_t seed) {
    __rng64.mt[0] = seed;
    for (int i = 1; i < MT64_N; i++) {
        __rng64.mt[i] = 6364136223846793005ULL * (__rng64.mt[i - 1] ^ (__rng64.mt[i - 1] >> 62)) + (uint64_t) i;
    }
    __rng64.index = MT64_N;
}
static inline uint64_t __mt19937_64_next() {
    uint64_t y;
    if (__rng64.index >= MT64_N) {
        static const uint64_t mag01[2] = {0ULL, MT64_MATRIX_A};
        uint64_t y;
        int i;
        for (i = 0; i < MT64_N - MT64_M; i++) {
            y = (__rng64.mt[i] & MT64_UPPER_MASK) | (__rng64.mt[i + 1] & MT64_LOWER_MASK);
            __rng64.mt[i] = __rng64.mt[i + MT64_M] ^ (y >> 1) ^ mag01[y & 1ULL];
        }
        for (; i < MT64_N - 1; i++) {
            y = (__rng64.mt[i] & MT64_UPPER_MASK) | (__rng64.mt[i + 1] & MT64_LOWER_MASK);
            __rng64.mt[i] = __rng64.mt[i + (MT64_M - MT64_N)] ^ (y >> 1) ^ mag01[y & 1ULL];
        }
        y = (__rng64.mt[MT64_N - 1] & MT64_UPPER_MASK) | (__rng64.mt[0] & MT64_LOWER_MASK);
        __rng64.mt[MT64_N - 1] = __rng64.mt[MT64_M - 1] ^ (y >> 1) ^ mag01[y & 1ULL];
        __rng64.index = 0;
    }
    y = __rng64.mt[__rng64.index++];
    y ^= (y >> 29) & 0x5555555555555555ULL;
    y ^= (y << 17) & 0x71D67FFFEDA60000ULL;
    y ^= (y << 37) & 0xFFF7EEE000000000ULL;
    y ^= (y >> 43);
    return y;
}
static double __mt19937_random(void) {
    return (double) (__mt19937_64_next() >> 11) * (1.0 / 9007199254740992.0);
}
static int64_t __mt19937_randint(int64_t lo, int64_t hi) {
    uint64_t range = (uint64_t) (hi - lo) + 1ULL;
    return lo + (int64_t) (__mt19937_64_next() % range);
}
char *__mt19937_uuid(void) {
    __mt19937_64_uuid_seed(time(NULL));
    static char buf[37];
    static const char hex[] = "0123456789abcdef";
    uint64_t hi = __mt19937_64_next();
    uint64_t lo = __mt19937_64_next();
    hi = (hi & ~((uint64_t) 0xF << 12)) | ((uint64_t) 0x4 << 12);
    lo = (lo & ~((uint64_t) 0x3 << 62)) | ((uint64_t) 0x2 << 62);
    int p = 0;
    for (int i = 60; i >= 32; i -= 4)
        buf[p++] = hex[(hi >> i) & 0xF];
    buf[p++] = '-';
    for (int i = 28; i >= 16; i -= 4)
        buf[p++] = hex[(hi >> i) & 0xF];
    buf[p++] = '-';
    for (int i = 12; i >= 0; i -= 4)
        buf[p++] = hex[(hi >> i) & 0xF];
    buf[p++] = '-';
    for (int i = 60; i >= 48; i -= 4)
        buf[p++] = hex[(lo >> i) & 0xF];
    buf[p++] = '-';
    for (int i = 44; i >= 0; i -= 4)
        buf[p++] = hex[(lo >> i) & 0xF];
    buf[36] = '\0';
    return buf;
}
OPENCSTL_FUNC void __cstl_vector_shuffle(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_type64 length = OPENCSTL_NIDX(container, -1);
    for (size_type64 i = length - 1; i > 0; i--) {
        size_type64 rng_idx = __mt19937_64_next() % (i + 1);
        swap((char *) (*container) + i * type_size, (char *) (*container) + rng_idx * type_size, type_size);
    }
}
OPENCSTL_FUNC void __cstl_deque_shuffle(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (NIDX_TSIZE) * (ptrdiff_t) sizeof(size_type64) + distance);
    size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
    for (size_type64 i = length - 1; i > 0; i--) {
        size_type64 rng_idx = __mt19937_64_next() % (i + 1);
        swap((char *) (*container) + i * type_size, (char *) (*container) + rng_idx * type_size, type_size);
    }
}
OPENCSTL_FUNC void __cstl_list_shuffle(void **container) {
    size_type64 type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    void **head = (void **) &OPENCSTL_NIDX(container, 0);
    size_type length = (size_type) OPENCSTL_NIDX(container, -1);
    if (length <= 1) return;
    void *ptr = malloc(type_size * length);
    void *it = *head;
    for (size_type i = 0; i < length; i++) {
        memcpy((char *) ptr + (i * type_size), it, type_size);
        it = __cstl_list_next_prev(it, -1);
    }
    for (size_type i = length - 1; i > 0; i--) {
        size_type rng_idx = __mt19937_64_next() % (i + 1);
        swap((char *) ptr + i * type_size, (char *) ptr + rng_idx * type_size, type_size);
    }
    it = *head;
    for (size_type i = 0; i < length; i++) {
        memcpy(it, (char *) ptr + (i * type_size), type_size);
        it = __cstl_list_next_prev(it, -1);
    }
    free(ptr);
}
void __mt19937_shuffle(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) &container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)&container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (NIDX_CTYPE) * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)&container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            __cstl_vector_shuffle((void **) &container);
        }
        break;
        case OPENCSTL_DEQUE: {
            __cstl_deque_shuffle((void **) &container);
        }
        break;
        case OPENCSTL_LIST: {
            __cstl_list_shuffle((void **) &container);
        }
        break;
        default: fault("Invalid operator");
            break;
    }
}
typedef void (*seed_fn)(uint64_t);
typedef double (*random_fn)(void);
typedef int64_t (*randint_fn)(int64_t, int64_t);
typedef char *(*uuid_fn)(void);
typedef void (*shuffle_fn)(void *);
typedef struct {
    random_fn random;
    randint_fn randint;
    seed_fn seed;
    uuid_fn uuid;
    shuffle_fn shuffle;
} RANDOM;
RANDOM mt19937 = {
    __mt19937_random,
    __mt19937_randint,
    __mt19937_64_seed,
    __mt19937_uuid,
    __mt19937_shuffle
};
#include <time.h>
#if defined(OCSTL_OS_WINDOWS)
#include <windows.h>
#define RtlGenRandom SystemFunction036
BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
#elif defined(__APPLE__)
#include <sys/types.h>
#elif defined(__linux__)
#include <sys/syscall.h>
#include <unistd.h>
#include <errno.h>
#endif
static uint64_t random_device(void) {
    uint64_t val = 0;
#if defined(OCSTL_CC_TCC)
    val  = (uint64_t)time(NULL);
    val ^= (uint64_t)(uintptr_t)&val;
    val ^= val << 21;
    val ^= val >> 35;
    val ^= val << 4;
#elif defined(OCSTL_OS_WINDOWS)
    RtlGenRandom(&val, sizeof(val));
#elif defined(__APPLE__)
    arc4random_buf(&val, sizeof(val));
#elif defined(__linux__)
    size_t done = 0;
    while (done < sizeof(val)) {
        long ret = syscall(SYS_getrandom,
                           (char *) &val + done, sizeof(val) - done, 0);
        if (ret < 0) {
            if (errno == EINTR) continue;
            FILE *f = fopen("/dev/urandom", "rb");
            if (f) {
                fread((char *) &val + done, 1, sizeof(val) - done, f);
                fclose(f);
            }
            break;
        }
        done += (size_t) ret;
    }
#else
    FILE *f = fopen("/dev/urandom", "rb");
    if (f) {
        fread(&val, sizeof(val), 1, f);
        fclose(f);
    }
#endif
    return val;
}
#endif
#if !defined(_OPENCSTL_CSTL_TICKTOCK_H)
#define _OPENCSTL_CSTL_TICKTOCK_H
#include <stdio.h>
#if defined(OCSTL_OS_WINDOWS) && (defined(OCSTL_CC_MSVC) || defined(OCSTL_CC_TCC) ||defined(OCSTL_CC_CLANG))
#if defined(OCSTL_CC_TCC)
#include <windows.h>
#else
#include <winnt.h>
#include <profileapi.h>
#endif
static double ttime(void) {
    LARGE_INTEGER freq, counter;
    QueryPerformanceFrequency(&freq);
    QueryPerformanceCounter(&counter);
    return (double) counter.QuadPart * 1000.0 / (double) freq.QuadPart;
}
#elif defined(__MINGW32__) || defined(__MINGW64__) || defined(__GNUC__) || defined(__TINYC__)
#include <sys/time.h>
#include <time.h>
static double ttime(void) {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (double) tv.tv_sec * 1000.0 + (double) tv.tv_usec / 1000.0;
}
#else
#error Unsupported compiler/platform
#endif
#endif
#if !defined(_OPENCSTL_CSTL_FILE_H)
#define _OPENCSTL_CSTL_FILE_H
#include <stdio.h>
#include <wchar.h>
typedef struct FPM {
    FILE *fp;
    char *filepath;
} FPM;
static FPM fpm[1024] = {0};
static int fpm_size = 0;
void fpm_append(FILE *fp, char *filepath) {
    verify(fpm_size < 1024);
    fpm[fpm_size].fp = fp;
    fpm[fpm_size].filepath = filepath;
    fpm_size++;
}
void fpm_erase(FILE *fp) {
    int idx = -1;
    for (int i = 0; i < fpm_size; i++) {
        if (fpm[i].fp == fp) {
            idx = i;
            break;
        }
    }
    verify(idx != -1);
    memcpy(fpm + idx, fpm + idx + 1, fpm_size - idx - 1);
    fpm_size--;
}
char *fpm_get(FILE *fp) {
    int idx = -1;
    for (int i = 0; i < fpm_size; i++) {
        if (fpm[i].fp == fp) {
            idx = i;
            break;
        }
    }
    verify(idx != -1);
    return fpm[idx].filepath;
}
FILE *__cstl_fopen( char *filename, const char *mode) {
    FILE *fp = NULL;
#if defined(__TINYC__)
    fp = fopen(filename, mode);
#elif defined(_WIN32) || defined(_WIN64)
    fopen_s(&fp, filename, mode);
#else
    fp = fopen(filename, mode);
#endif
    verify(fp != NULL);
    fpm_append(fp, filename);
    return fp;
}
void __cstl_fclose(FILE *fp) {
    fpm_erase(fp);
    fclose(fp);
}
char *__cstl_get_line(FILE *fp) {
    long start = ftell(fp);
    if (start < 0) return NULL;
    size_type64 len = 0;
    int c;
    int found_any = 0;
    while ((c = fgetc(fp)) != EOF) {
        found_any = 1;
        if (c == '\n') break;
        len++;
    }
    if (!found_any && len == 0) return NULL;
    if (fseek(fp, start, SEEK_SET) != 0) return NULL;
    char *buf = (char *) calloc(len + 1, sizeof(char));
    if (!buf) return NULL;
    for (size_type64 i = 0; i < len; i++) {
        int ch = fgetc(fp);
        if (ch == EOF) {
            free(buf);
            return NULL;
        }
        buf[i] = (char) ch;
    }
    (void) fgetc(fp);
    return buf;
}
char *__cstl_fread_all(FILE *fp) {
    fseek(fp, 0, SEEK_END);
    size_type64 total_size = ftell(fp);
    fseek(fp, 0, SEEK_SET);
    char *buf = (char *) calloc(total_size, sizeof(char));
    fread(buf, 1, total_size, fp);
    return buf;
}
FILE *__cstl_fwrite_all(FILE *fp, const char *buf) {
    char *filepath = fpm_get(fp);
    __cstl_fclose(fp);
    FILE *new_fp = __cstl_fopen(filepath, "wt");
    fpm_append(new_fp, filepath);
    if (!new_fp) return NULL;
    size_type64 len = strlen(buf);
    fwrite(buf, 1, len, new_fp);
    return new_fp;
}
typedef FILE *(*cstl_fopen_fn)( char *filename, const char *mode);
typedef void (*cstl_fclose_fn)(FILE *fp);
typedef char *(*cstl_getline_fn)(FILE *fp);
typedef char *(*cstl_fread_all_fn)(FILE *fp);
typedef char *(*cstl_readall_fn)(FILE *fp, size_type64 *outsize);
typedef FILE * (*cstl_fwrite_all_fn)(FILE *fp, const char *buf);
typedef struct FSTREAM {
    cstl_fopen_fn open;
    cstl_fclose_fn close;
    cstl_getline_fn getline;
    cstl_fread_all_fn read;
    cstl_fwrite_all_fn write;
} FSTREAM;
FSTREAM file = {
    __cstl_fopen,
    __cstl_fclose,
    __cstl_get_line,
    __cstl_fread_all,
    __cstl_fwrite_all
};
#endif
#ifndef OPENCSTL_FILESYSTEM_H
#define OPENCSTL_FILESYSTEM_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#if defined(OCSTL_OS_WINDOWS)
#if !defined(OCSTL_CC_TCC)
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#define CSTL_PATH_SEP '\\'
#else
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <limits.h>
#define CSTL_PATH_SEP '/'
#endif
static bool __cstl_is_sep(char c) {
#if defined(OCSTL_OS_WINDOWS)
    return c == '/' || c == '\\';
#else
    return c == '/';
#endif
}
static bool __cstl_exists(char *path) {
#if defined(OCSTL_OS_WINDOWS)
    DWORD attrs = GetFileAttributesA(path);
    return attrs != INVALID_FILE_ATTRIBUTES;
#else
    struct stat st;
    return stat(path, &st) == 0;
#endif
}
static char *__cstl_join(char *path1, char *path2) {
    if (!path1) path1 = "";
    if (!path2) path2 = "";
    bool p2_abs = false;
    if (path2[0] != '\0') {
        if (__cstl_is_sep(path2[0])) p2_abs = true;
#if defined(OCSTL_OS_WINDOWS)
        if (isalpha((unsigned char) path2[0]) && path2[1] == ':') p2_abs = true;
#endif
    }
    if (p2_abs) {
        size_type64 l = strlen(path2);
        char *ret = (char *) malloc(l + 1);
        memcpy(ret, path2, l + 1);
        return ret;
    }
    size_type64 l1 = strlen(path1);
    size_type64 l2 = strlen(path2);
    if (l1 == 0) {
        char *ret = (char *) malloc(l2 + 1);
        memcpy(ret, path2, l2 + 1);
        return ret;
    }
    bool need_sep = !__cstl_is_sep(path1[l1 - 1]);
    size_type64 total = l1 + (need_sep ? 1 : 0) + l2;
    char *ret = (char *) malloc(total + 1);
    memcpy(ret, path1, l1);
    size_type64 pos = l1;
    if (need_sep) ret[pos++] = CSTL_PATH_SEP;
    memcpy(ret + pos, path2, l2);
    ret[pos + l2] = '\0';
    return ret;
}
static char *__cstl_basename(char *path) {
    size_type64 len = strlen(path);
    size_type64 start = 0;
    for (size_type64 i = 0; i < len; i++) {
        if (__cstl_is_sep(path[i])) start = i + 1;
    }
    size_type64 base_len = len - start;
    char *ret = (char *) malloc(base_len + 1);
    memcpy(ret, path + start, base_len);
    ret[base_len] = '\0';
    return ret;
}
static char **__cstl_splitext(char *path) {
    size_type64 len = strlen(path);
    size_type64 base_start = 0;
    for (size_type64 i = 0; i < len; i++) {
        if (__cstl_is_sep(path[i])) base_start = i + 1;
    }
    size_type64 nonleading = base_start;
    while (nonleading < len && path[nonleading] == '.') nonleading++;
    size_type64 dot_pos = (size_type64) -1;
    for (size_type64 i = nonleading; i < len; i++) {
        if (path[i] == '.') dot_pos = i;
    }
    size_type64 root_len = (dot_pos == (size_type64) -1) ? len : dot_pos;
    size_type64 ext_len = (dot_pos == (size_type64) -1) ? 0 : (len - dot_pos);
    size_type64 total = 2 * sizeof(char *) + root_len + 1 + ext_len + 1;
    char **ret = (char **) malloc(total);
    char *buf = (char *) ret + 2 * sizeof(char *);
    memcpy(buf, path, root_len);
    buf[root_len] = '\0';
    memcpy(buf + root_len + 1, path + root_len, ext_len);
    buf[root_len + 1 + ext_len] = '\0';
    ret[0] = buf;
    ret[1] = buf + root_len + 1;
    return ret;
}
static size_type64 __cstl_getsize(char *path) {
#if defined(OCSTL_OS_WINDOWS)
    WIN32_FILE_ATTRIBUTE_DATA attr;
    if (!GetFileAttributesExA(path, GetFileExInfoStandard, &attr)) return 0;
    ULARGE_INTEGER sz;
    sz.LowPart = attr.nFileSizeLow;
    sz.HighPart = attr.nFileSizeHigh;
    return (size_type64) sz.QuadPart;
#else
    struct stat st;
    if (stat(path, &st) != 0) return 0;
    return (size_type64) st.st_size;
#endif
}
static void __cstl_makedirs(char *path) {
    size_type64 len = strlen(path);
    if (len == 0) return;
    char *tmp = (char *) malloc(len + 1);
    memcpy(tmp, path, len + 1);
    for (size_type64 i = 1; i < len; i++) {
        if (__cstl_is_sep(tmp[i])) {
            char save = tmp[i];
            tmp[i] = '\0';
#if defined(OCSTL_OS_WINDOWS)
            CreateDirectoryA(tmp, NULL);
#else
            mkdir(tmp, 0755);
#endif
            tmp[i] = save;
        }
    }
#if defined(OCSTL_OS_WINDOWS)
    CreateDirectoryA(tmp, NULL);
#else
    mkdir(tmp, 0755);
#endif
    free(tmp);
}
static void __cstl_remove(char *path) {
#if defined(OCSTL_OS_WINDOWS)
    DeleteFileA(path);
#else
    unlink(path);
#endif
}
static void __cstl_rename(char *oldpath, char *newpath) {
    rename(oldpath, newpath);
}
static char *__cstl_dirname(char *path) {
    size_type64 len = strlen(path);
    size_type64 last_sep = (size_type64) -1;
    for (size_type64 i = 0; i < len; i++) {
        if (__cstl_is_sep(path[i])) last_sep = i;
    }
    if (last_sep == (size_type64) -1) {
        char *ret = (char *) malloc(1);
        ret[0] = '\0';
        return ret;
    }
    size_type64 dir_len = last_sep;
    if (dir_len == 0) dir_len = 1;
#if defined(OCSTL_OS_WINDOWS)
    if (last_sep == 2 && isalpha((unsigned char) path[0]) && path[1] == ':') {
        dir_len = 3;
    }
#endif
    char *ret = (char *) malloc(dir_len + 1);
    memcpy(ret, path, dir_len);
    ret[dir_len] = '\0';
    return ret;
}
static char *__cstl_abspath(char *path) {
    if (!path) path = "";
#if defined(OCSTL_OS_WINDOWS)
    DWORD len = GetFullPathNameA(path, 0, NULL, NULL);
    if (len == 0) {
        char *ret = (char *) malloc(strlen(path) + 1);
        memcpy(ret, path, strlen(path) + 1);
        return ret;
    }
    char *ret = (char *) malloc(len);
    GetFullPathNameA(path, len, ret, NULL);
    return ret;
#else
    char resolved[PATH_MAX];
    if (realpath(path, resolved)) {
        size_type64 l = strlen(resolved);
        char *ret = (char *) malloc(l + 1);
        memcpy(ret, resolved, l + 1);
        return ret;
    }
    if (path[0] == '/') {
        size_type64 l = strlen(path);
        char *ret = (char *) malloc(l + 1);
        memcpy(ret, path, l + 1);
        return ret;
    }
    char cwd[PATH_MAX];
    if (!getcwd(cwd, sizeof cwd)) {
        size_type64 l = strlen(path);
        char *ret = (char *) malloc(l + 1);
        memcpy(ret, path, l + 1);
        return ret;
    }
    return __cstl_join(cwd, path);
#endif
}
static bool __cstl_is_dir(char *path) {
#if defined(OCSTL_OS_WINDOWS)
    DWORD a = GetFileAttributesA(path);
    return a != INVALID_FILE_ATTRIBUTES && (a & FILE_ATTRIBUTE_DIRECTORY);
#else
    struct stat st;
    if (stat(path, &st) != 0) return false;
    return S_ISDIR(st.st_mode);
#endif
}
static bool __cstl_is_file(char *path) {
#if defined(OCSTL_OS_WINDOWS)
    DWORD a = GetFileAttributesA(path);
    return a != INVALID_FILE_ATTRIBUTES && !(a & FILE_ATTRIBUTE_DIRECTORY);
#else
    struct stat st;
    if (stat(path, &st) != 0) return false;
    return S_ISREG(st.st_mode);
#endif
}
typedef bool (*cstl_exists_fn)(char *path);
typedef char *(*cstl_join_fn)(char *path1, char *path2);
typedef char *(*cstl_basename_fn)(char *path);
typedef char **(*cstl_splitext_fn)(char *path);
typedef size_type64 (*cstl_getsize_fn)(char *path);
typedef void (*cstl_makedirs_fn)(char *path);
typedef void (*cstl_remove_fn)(char *path);
typedef void (*cstl_rename_fn)(char *oldpath, char *newpath);
typedef char *(*cstl_dirname_fn)(char *path);
typedef char *(*cstl_abspath_fn)(char *path);
typedef bool (*cstl_is_dir_fn)(char *path);
typedef bool (*cstl_is_file_fn)(char *path);
typedef struct {
    cstl_exists_fn exists;
    cstl_join_fn join;
    cstl_basename_fn basename;
    cstl_splitext_fn splitext;
    cstl_getsize_fn getsize;
    cstl_makedirs_fn makedirs;
    cstl_remove_fn remove;
    cstl_rename_fn rename;
    cstl_dirname_fn dirname;
    cstl_abspath_fn abspath;
    cstl_is_dir_fn is_dir;
    cstl_is_file_fn is_file;
} FileSystem;
static FileSystem fs = {
    __cstl_exists,
    __cstl_join,
    __cstl_basename,
    __cstl_splitext,
    __cstl_getsize,
    __cstl_makedirs,
    __cstl_remove,
    __cstl_rename,
    __cstl_dirname,
    __cstl_abspath,
    __cstl_is_dir,
    __cstl_is_file,
};
#endif
#if !defined(_OPENCSTL_SORT_H)
#define _OPENCSTL_SORT_H
#include <stdlib.h>
#include <string.h>
#if !defined(_OPENCSTL_MSORT_H)
#define _OPENCSTL_MSORT_H
#include <stdlib.h>
#include <string.h>
#if !defined(_OPENCSTL_ISORT_H)
#define _OPENCSTL_ISORT_H
#include <stdlib.h>
#include <string.h>
static void isort(void *base, size_type64 number, size_type64 width, CSTL_COMPARE compare) {
    char *arr = (char *) base;
    char sbuf[1024];
    char *tmp = (width <= sizeof(sbuf)) ? sbuf : (char *) malloc(width);
    for (size_type64 i = 1; i < number; i++) {
        memcpy(tmp, arr + i * width, width);
        size_type64 lo = 0, hi = i;
        while (lo < hi) {
            size_type64 mid = lo + ((hi - lo) >> 1);
            if (compare(tmp, arr + mid * width) < 0) hi = mid;
            else lo = mid + 1;
        }
        if (lo < i) {
            memmove(arr + (lo + 1) * width, arr + lo * width, (i - lo) * width);
            memcpy(arr + lo * width, tmp, width);
        }
    }
    if (tmp != sbuf) {
        free(tmp);
    }
}
#endif
#define MSORT_ISORT_THRESH 32
static void msort_merge(char *arr, size_type64 len1, size_type64 len2, size_type64 sz,
                        CSTL_COMPARE cmp, char *buf) {
    if (cmp(arr + (len1 - 1) * sz, arr + len1 * sz) <= 0) return;
    if (len1 <= len2) {
        memcpy(buf, arr, len1 * sz);
        char *c1 = buf, *e1 = buf + len1 * sz;
        char *c2 = arr + len1 * sz, *e2 = c2 + len2 * sz;
        char *d = arr;
        while (c1 < e1 && c2 < e2) {
            if (cmp(c2, c1) < 0) {
                memcpy(d, c2, sz);
                c2 += sz;
            } else {
                memcpy(d, c1, sz);
                c1 += sz;
            }
            d += sz;
        }
        if (c1 < e1)
            memcpy(d, c1, (size_type64) (e1 - c1));
    } else {
        memcpy(buf, arr + len1 * sz, len2 * sz);
        size_type64 i = len1, j = len2, k = len1 + len2;
        while (i > 0 && j > 0) {
            k--;
            if (cmp(buf + (j - 1) * sz, arr + (i - 1) * sz) < 0) {
                memcpy(arr + k * sz, arr + (i - 1) * sz, sz);
                i--;
            } else {
                memcpy(arr + k * sz, buf + (j - 1) * sz, sz);
                j--;
            }
        }
        if (j > 0)
            memcpy(arr, buf, j * sz);
    }
}
static void msort(void *base, size_type64 number, size_type64 width, CSTL_COMPARE compare) {
    if (number < 2) return;
    char *arr = (char *) base;
    size_type64 sz = width;
    for (size_type64 i = 0; i < number; i += MSORT_ISORT_THRESH) {
        size_type64 blk = number - i;
        if (blk > MSORT_ISORT_THRESH) blk = MSORT_ISORT_THRESH;
        isort(arr + i * sz, blk, sz, compare);
    }
    char *buf = (char *) calloc(((number + 1) / 2), sz);
    if (!buf) return;
    for (size_type64 mb = MSORT_ISORT_THRESH; mb < number; mb *= 2) {
        for (size_type64 i = 0; i + mb < number; i += 2 * mb) {
            size_type64 len1 = mb;
            size_type64 len2 = number - i - mb;
            if (len2 > mb) len2 = mb;
            msort_merge(arr + i * sz, len1, len2, sz, compare, buf);
        }
    }
    free(buf);
}
#endif
#if !defined(_OPENCSTL_TSORT_H)
#define _OPENCSTL_TSORT_H
#include <stdlib.h>
#include <string.h>
#define TS_MIN_MERGE   32
#define TS_MIN_GALLOP   7
#define TS_MAX_STACK   85
struct ts_run {
    size_type64 base;
    size_type64 len;
};
static inline size_type64 ts_minrun(size_type64 n) {
    size_type64 r = 0;
    while (n >= TS_MIN_MERGE) {
        r |= (n & 1);
        n >>= 1;
    }
    return n + r;
}
static void ts_binsort(char *arr, size_type64 lo, size_type64 hi, size_type64 start,
                       size_type64 sz, CSTL_COMPARE cmp) {
    char sbuf[1024];
    char *tmp = (sz <= sizeof(sbuf)) ? sbuf : (char *) malloc(sz);
    for (size_type64 i = start; i < hi; i++) {
        memcpy(tmp, arr + i * sz, sz);
        size_type64 left = lo, right = i;
        while (left < right) {
            size_type64 mid = left + ((right - left) >> 1);
            if (cmp(tmp, arr + mid * sz) < 0) right = mid;
            else left = mid + 1;
        }
        if (left < i) {
            memmove(arr + (left + 1) * sz, arr + left * sz, (i - left) * sz);
            memcpy(arr + left * sz, tmp, sz);
        }
    }
    if (tmp != sbuf)
        free(tmp);
}
static size_type64 ts_count_run(char *arr, size_type64 lo, size_type64 hi,
                           size_type64 sz, CSTL_COMPARE cmp) {
    if (hi - lo < 2) return hi - lo;
    size_type64 run_hi = lo + 1;
    if (cmp(arr + run_hi * sz, arr + lo * sz) < 0) {
        while (run_hi + 1 < hi &&
               cmp(arr + (run_hi + 1) * sz, arr + run_hi * sz) < 0)
            run_hi++;
        run_hi++;
        char rbuf[1024];
        char *t = (sz <= sizeof(rbuf)) ? rbuf : (char *) malloc(sz);
        size_type64 a = lo, b = run_hi - 1;
        while (a < b) {
            memcpy(t, arr + a * sz, sz);
            memcpy(arr + a * sz, arr + b * sz, sz);
            memcpy(arr + b * sz, t, sz);
            a++;
            b--;
        }
        if (t != rbuf)
            free(t);
    } else {
        while (run_hi + 1 < hi &&
               cmp(arr + (run_hi + 1) * sz, arr + run_hi * sz) >= 0)
            run_hi++;
        run_hi++;
    }
    return run_hi - lo;
}
static size_type64 ts_gallop_right(const char *key, const char *a, size_type64 n,
                              size_type64 sz, CSTL_COMPARE cmp) {
    if (n == 0 || cmp(key, a) < 0) return 0;
    size_type64 last = 0, ofs = 1;
    while (ofs < n && cmp(key, a + ofs * sz) >= 0) {
        last = ofs;
        ofs = (ofs << 1) + 1;
    }
    if (ofs > n) ofs = n;
    size_type64 lo = last + 1, hi = ofs;
    while (lo < hi) {
        size_type64 m = lo + ((hi - lo) >> 1);
        if (cmp(key, a + m * sz) >= 0) lo = m + 1;
        else hi = m;
    }
    return lo;
}
static size_type64 ts_gallop_left(const char *key, const char *a, size_type64 n,
                             size_type64 sz, CSTL_COMPARE cmp) {
    if (n == 0 || cmp(key, a) <= 0) return 0;
    size_type64 last = 0, ofs = 1;
    while (ofs < n && cmp(key, a + ofs * sz) > 0) {
        last = ofs;
        ofs = (ofs << 1) + 1;
    }
    if (ofs > n) ofs = n;
    size_type64 lo = last + 1, hi = ofs;
    while (lo < hi) {
        size_type64 m = lo + ((hi - lo) >> 1);
        if (cmp(key, a + m * sz) > 0) lo = m + 1;
        else hi = m;
    }
    return lo;
}
static void ts_merge_lo(char *base, size_type64 len1, size_type64 len2,
                        size_type64 sz, CSTL_COMPARE cmp, char *buf) {
    memcpy(buf, base, len1 * sz);
    char *c1 = buf, *e1 = buf + len1 * sz;
    char *c2 = base + len1 * sz, *e2 = c2 + len2 * sz;
    char *d = base;
    size_type64 mg = TS_MIN_GALLOP;
    for (;;) {
        size_type64 cnt1 = 0, cnt2 = 0;
        do {
            if (cmp(c2, c1) < 0) {
                memcpy(d, c2, sz);
                c2 += sz;
                d += sz;
                cnt2++;
                cnt1 = 0;
                if (c2 >= e2) goto tail_lo;
            } else {
                memcpy(d, c1, sz);
                c1 += sz;
                d += sz;
                cnt1++;
                cnt2 = 0;
                if (c1 >= e1) return;
            }
        } while ((cnt1 | cnt2) < mg);
        do {
            cnt1 = ts_gallop_right(c2, c1, (size_type64) (e1 - c1) / sz, sz, cmp);
            if (cnt1) {
                memcpy(d, c1, cnt1 * sz);
                c1 += cnt1 * sz;
                d += cnt1 * sz;
            }
            if (c1 >= e1) return;
            memcpy(d, c2, sz);
            c2 += sz;
            d += sz;
            if (c2 >= e2) goto tail_lo;
            cnt2 = ts_gallop_left(c1, c2, (size_type64) (e2 - c2) / sz, sz, cmp);
            if (cnt2) {
                memmove(d, c2, cnt2 * sz);
                c2 += cnt2 * sz;
                d += cnt2 * sz;
            }
            if (c2 >= e2) goto tail_lo;
            memcpy(d, c1, sz);
            c1 += sz;
            d += sz;
            if (c1 >= e1) return;
            if (mg > 1) mg--;
        } while ((cnt1 | cnt2) >= TS_MIN_GALLOP);
        mg += 2;
    }
tail_lo:
    if (c1 < e1)
        memcpy(d, c1, (size_type64) (e1 - c1));
}
static void ts_merge_hi(char *base, size_type64 len1, size_type64 len2,
                        size_type64 sz, CSTL_COMPARE cmp, char *buf) {
    memcpy(buf, base + len1 * sz, len2 * sz);
    size_type64 i = len1, j = len2;
    size_type64 k = len1 + len2;
    while (i > 0 && j > 0) {
        k--;
        if (cmp(buf + (j - 1) * sz, base + (i - 1) * sz) < 0) {
            memcpy(base + k * sz, base + (i - 1) * sz, sz);
            i--;
        } else {
            memcpy(base + k * sz, buf + (j - 1) * sz, sz);
            j--;
        }
    }
    if (j > 0)
        memcpy(base, buf, j * sz);
}
static inline void ts_do_merge(char *arr, size_type64 base1, size_type64 len1,
                               size_type64 len2, size_type64 sz, CSTL_COMPARE cmp,
                               char *buf) {
    size_type64 mid = base1 + len1;
    if (cmp(arr + (mid - 1) * sz, arr + mid * sz) <= 0) return;
    if (len1 <= len2)
        ts_merge_lo(arr + base1 * sz, len1, len2, sz, cmp, buf);
    else
        ts_merge_hi(arr + base1 * sz, len1, len2, sz, cmp, buf);
}
static void ts_merge_collapse(char *arr, struct ts_run *stk, size_type64 *sp,
                              size_type64 sz, CSTL_COMPARE cmp, char *buf) {
    while (*sp > 1) {
        size_type64 n = *sp - 2;
        int need_merge = 0;
        if (n > 0 && stk[n - 1].len <= stk[n].len + stk[n + 1].len) {
            if (stk[n - 1].len < stk[n + 1].len) n--;
            need_merge = 1;
        } else if (stk[n].len <= stk[n + 1].len) {
            need_merge = 1;
        }
        if (!need_merge) break;
        ts_do_merge(arr, stk[n].base, stk[n].len, stk[n + 1].len,
                    sz, cmp, buf);
        stk[n].len += stk[n + 1].len;
        for (size_type64 i = n + 1; i + 1 < *sp; i++)
            stk[i] = stk[i + 1];
        (*sp)--;
    }
}
static void ts_merge_force(char *arr, struct ts_run *stk, size_type64 *sp,
                           size_type64 sz, CSTL_COMPARE cmp, char *buf) {
    while (*sp > 1) {
        size_type64 n = *sp - 2;
        if (n > 0 && stk[n - 1].len < stk[n + 1].len) n--;
        ts_do_merge(arr, stk[n].base, stk[n].len, stk[n + 1].len,
                    sz, cmp, buf);
        stk[n].len += stk[n + 1].len;
        for (size_type64 i = n + 1; i + 1 < *sp; i++)
            stk[i] = stk[i + 1];
        (*sp)--;
    }
}
static void tsort(void *base, const size_type64 number, const size_type64 width, CSTL_COMPARE cmp) {
    if (number < 2) return;
    char *arr = (char *) base;
    size_type64 sz = width;
    if (number < TS_MIN_MERGE) {
        size_type64 run = ts_count_run(arr, 0, number, sz, cmp);
        ts_binsort(arr, 0, number, run, sz, cmp);
        return;
    }
    char *buf = (char *) malloc(number * sz);
    if (!buf) return;
    struct ts_run stk[TS_MAX_STACK];
    size_type64 sp = 0;
    size_type64 minrun = ts_minrun(number);
    size_type64 lo = 0;
    while (lo < number) {
        size_type64 run_len = ts_count_run(arr, lo, number, sz, cmp);
        if (run_len < minrun) {
            size_type64 force = number - lo;
            if (force > minrun) force = minrun;
            ts_binsort(arr, lo, lo + force, lo + run_len, sz, cmp);
            run_len = force;
        }
        stk[sp].base = lo;
        stk[sp].len = run_len;
        sp++;
        ts_merge_collapse(arr, stk, &sp, sz, cmp, buf);
        lo += run_len;
    }
    ts_merge_force(arr, stk, &sp, sz, cmp, buf);
    free(buf);
}
#undef TS_MIN_MERGE
#undef TS_MIN_GALLOP
#undef TS_MAX_STACK
#endif
#if !defined(_OPENCSTL_PDQSORT_H)
#define _OPENCSTL_PDQSORT_H
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#define PDQ_ISORT_THRESH      24
#define PDQ_NINTHER_THRESH   128
#define PDQ_PARTIAL_LIMIT      8
#define PDQ_MAX_STACK         64
#if defined(_MSC_VER)
#define PDQ_LIKELY(x)   (x)
#define PDQ_UNLIKELY(x) (x)
#else
#define PDQ_LIKELY(x)   __builtin_expect(!!(x), 1)
#define PDQ_UNLIKELY(x) __builtin_expect(!!(x), 0)
#endif
static  void pdq__swap(unsigned char *a, unsigned char *b, size_type64 n) {
    if (PDQ_LIKELY(n == 8)) {
        uint64_t t;
        memcpy(&t, a, 8);
        memcpy(a, b, 8);
        memcpy(b, &t, 8);
    } else if (PDQ_UNLIKELY(n == 4)) {
        uint32_t t;
        memcpy(&t, a, 4);
        memcpy(a, b, 4);
        memcpy(b, &t, 4);
    } else {
        unsigned char t;
        for (size_type64 i = 0; i < n; ++i) {
            t = a[i];
            a[i] = b[i];
            b[i] = t;
        }
    }
}
#define PDQ_ELEM(base, i) ((base) + (i) * sz)
static inline size_type64 pdq_log2(size_type64 n) {
    size_type64 r = 0;
    while (n > 1) {
        n >>= 1;
        ++r;
    }
    return r;
}
static void pdq_isort(unsigned char *base, size_type64 n, size_type64 sz,
                      int (*cmp)(const void *, const void *), unsigned char *tmp) {
    if (n < 2) return;
    for (size_type64 i = 1; i < n; ++i)
        if (cmp(PDQ_ELEM(base, i), base) < 0) {
            pdq__swap(PDQ_ELEM(base, i), base, sz);
        }
    for (size_type64 i = 2; i < n; ++i) {
        unsigned char *c = PDQ_ELEM(base, i);
        if (cmp(c - sz, c) <= 0) continue;
        memcpy(tmp, c, sz);
        unsigned char *j = c;
        do {
            memcpy(j, j - sz, sz);
            j -= sz;
        } while (cmp(j - sz, tmp) > 0);
        memcpy(j, tmp, sz);
    }
}
static void pdq_isort_unguard(unsigned char *base, size_type64 n, size_type64 sz,
                              int (*cmp)(const void *, const void *), unsigned char *tmp) {
    for (size_type64 i = 1; i < n; ++i) {
        unsigned char *c = PDQ_ELEM(base, i);
        if (cmp(c - sz, c) <= 0) continue;
        memcpy(tmp, c, sz);
        unsigned char *j = c;
        do {
            memcpy(j, j - sz, sz);
            j -= sz;
        } while (j > base && cmp(j - sz, tmp) > 0);
        memcpy(j, tmp, sz);
    }
}
static int pdq_partial_isort(unsigned char *base, size_type64 n, size_type64 sz,
                             int (*cmp)(const void *, const void *), unsigned char *tmp) {
    if (n < 2) return 1;
    size_type64 cnt = 0;
    for (size_type64 i = 1; i < n; ++i) {
        unsigned char *c = PDQ_ELEM(base, i);
        if (cmp(c - sz, c) <= 0) continue;
        memcpy(tmp, c, sz);
        unsigned char *j = c;
        do {
            memcpy(j, j - sz, sz);
            j -= sz;
            if (++cnt > PDQ_PARTIAL_LIMIT) return 0;
        } while (j > base && cmp(j - sz, tmp) > 0);
        memcpy(j, tmp, sz);
    }
    return 1;
}
static inline int pdq_s2(unsigned char *base, size_type64 a, size_type64 b,
                         size_type64 sz, int (*cmp)(const void *, const void *)) {
    if (cmp(PDQ_ELEM(base, b), PDQ_ELEM(base, a)) < 0) {
        pdq__swap(PDQ_ELEM(base, a), PDQ_ELEM(base, b), sz);
        return 1;
    }
    return 0;
}
static inline int pdq_s3(unsigned char *base, size_type64 a, size_type64 b, size_type64 c,
                         size_type64 sz, int (*cmp)(const void *, const void *)) {
    int s = pdq_s2(base, a, b, sz, cmp);
    s += pdq_s2(base, b, c, sz, cmp);
    s += pdq_s2(base, a, b, sz, cmp);
    return s;
}
static int pdq_pick_pivot(unsigned char *base, size_type64 n, size_type64 sz,
                          int (*cmp)(const void *, const void *)) {
    size_type64 mid = n >> 1;
    int sw = 0;
    if (n >= PDQ_NINTHER_THRESH) {
        size_type64 s = n >> 3;
        sw += pdq_s3(base, 0, s, s * 2, sz, cmp);
        sw += pdq_s3(base, mid - s, mid, mid + s, sz, cmp);
        sw += pdq_s3(base, n - 1 - s * 2, n - 1 - s, n - 1, sz, cmp);
        sw += pdq_s3(base, s, mid, n - 1 - s, sz, cmp);
    } else {
        sw += pdq_s3(base, 0, mid, n - 1, sz, cmp);
    }
    pdq__swap(base, PDQ_ELEM(base, mid), sz);
    return sw;
}
static void pdq_sift(unsigned char *base, size_type64 root, size_type64 n,
                     size_type64 sz, int (*cmp)(const void *, const void *)) {
    for (;;) {
        size_type64 c = root * 2 + 1;
        if (c >= n) break;
        size_type64 mx = root;
        if (cmp(PDQ_ELEM(base, mx), PDQ_ELEM(base, c)) < 0) mx = c;
        if (c + 1 < n && cmp(PDQ_ELEM(base, mx), PDQ_ELEM(base, c + 1)) < 0)
            mx = c + 1;
        if (mx == root) break;
        pdq__swap(PDQ_ELEM(base, root), PDQ_ELEM(base, mx), sz);
        root = mx;
    }
}
static void pdq_heap(unsigned char *base, size_type64 n, size_type64 sz, int (*cmp)(const void *, const void *)) {
    if (n < 2) return;
    for (size_type64 i = n / 2; i-- > 0;) pdq_sift(base, i, n, sz, cmp);
    for (size_type64 e = n; e-- > 1;) {
        pdq__swap(base, PDQ_ELEM(base, e), sz);
        pdq_sift(base, 0, e, sz, cmp);
    }
}
static inline uint64_t pdq_rng(uint64_t *s) {
    uint64_t x = *s;
    x ^= x << 13;
    x ^= x >> 7;
    x ^= x << 17;
    return (*s = x);
}
static void pdq_break(unsigned char *base, size_type64 n, size_type64 sz, uint64_t *rs) {
    if (n < 8) return;
    size_type64 h = n >> 1, q = n >> 2;
    pdq__swap(PDQ_ELEM(base, q), PDQ_ELEM(base, q + pdq_rng(rs) % (h?h:1)), sz);
    pdq__swap(PDQ_ELEM(base, h), PDQ_ELEM(base, q + pdq_rng(rs) % (h?h:1)), sz);
    pdq__swap(PDQ_ELEM(base, q + h), PDQ_ELEM(base, q + pdq_rng(rs) % (h?h:1)), sz);
}
static inline size_type64 pdq_part_r(unsigned char *base, size_type64 n, size_type64 sz,
                                int (*cmp)(const void *, const void *), unsigned char *piv,
                                int *ap) {
    unsigned char *lo = base + sz;
    unsigned char *hi = base + (n - 1) * sz;
    while (lo <= hi && cmp(lo, piv) < 0) lo += sz;
    while (lo <= hi && cmp(hi, piv) >= 0) hi -= sz;
    int was_partitioned = (lo > hi);
    while (lo < hi) {
        pdq__swap(lo, hi, sz);
        lo += sz;
        hi -= sz;
        while (cmp(lo, piv) < 0) lo += sz;
        while (cmp(hi, piv) >= 0) hi -= sz;
    }
    unsigned char *pp = lo - sz;
    if (pp > base)
        memcpy(base, pp, sz);
    memcpy(pp, piv, sz);
    *ap = was_partitioned;
    return (size_type64) (pp - base) / sz;
}
static inline size_type64 pdq_part_l(unsigned char *base, size_type64 n, size_type64 sz,
                                int (*cmp)(const void *, const void *), unsigned char *piv) {
    memcpy(piv, base, sz);
    unsigned char *lo = base + sz;
    unsigned char *hi = base + (n - 1) * sz;
    while (lo <= hi && cmp(piv, hi) < 0) hi -= sz;
    while (lo <= hi && cmp(lo, piv) <= 0) lo += sz;
    while (lo < hi) {
        pdq__swap(lo, hi, sz);
        lo += sz;
        hi -= sz;
        while (cmp(lo, piv) <= 0) lo += sz;
        while (cmp(piv, hi) < 0) hi -= sz;
    }
    if (hi > base)
        memcpy(base, hi, sz);
    memcpy(hi, piv, sz);
    return (size_type64) (hi - base) / sz;
}
static void pdqsort(void *base, size_type64 number, size_type64 width, CSTL_COMPARE cmp) {
    if (!base || !cmp || width == 0 || number < 2) return;
    const size_type64 sz = width;
    unsigned char *arr = (unsigned char *) base;
    unsigned char sbuf[512];
    unsigned char *scratch;
    size_type64 need = sz * 2;
    scratch = (need <= sizeof(sbuf)) ? sbuf : (unsigned char *) malloc(need);
    if (!scratch) return;
    unsigned char *tmp = scratch;
    unsigned char *piv = scratch + sz;
    uint64_t rs = (uint64_t) number ^ 0x517cc1b727220a95ULL;
    struct pdq_frame {
        unsigned char *base;
        size_type64 n;
        size_type64 bad;
        int left;
    };
    struct pdq_frame stk[PDQ_MAX_STACK];
    int sp = 0;
    stk[sp].base = arr;
    stk[sp].n = number;
    stk[sp].bad = pdq_log2(number) * 2 + 1;
    stk[sp].left = 1;
    ++sp;
    while (sp > 0) {
        --sp;
        unsigned char *base = stk[sp].base;
        size_type64 n = stk[sp].n;
        size_type64 bad = stk[sp].bad;
        int leftmost = stk[sp].left;
    again:
        if (n <= PDQ_ISORT_THRESH) {
            if (leftmost)
                pdq_isort(base, n, sz, cmp, tmp);
            else
                pdq_isort_unguard(base, n, sz, cmp, tmp);
            continue;
        }
        if (bad == 0) {
            pdq_heap(base, n, sz, cmp);
            continue;
        }
        if (!leftmost && cmp(base - sz, base) >= 0) {
            size_type64 pp = pdq_part_l(base, n, sz, cmp, piv);
            base += (pp + 1) * sz;
            n -= pp + 1;
            goto again;
        }
        pdq_pick_pivot(base, n, sz, cmp);
        memcpy(piv, base, sz);
        int ap = 0;
        size_type64 pp = pdq_part_r(base, n, sz, cmp, piv, &ap);
        size_type64 lsz = pp;
        size_type64 rsz = n - pp - 1;
        int unbal = (lsz < n / 8 || rsz < n / 8);
        if (unbal) {
            bad--;
            if (lsz >= PDQ_ISORT_THRESH) pdq_break(base, lsz, sz, &rs);
            if (rsz >= PDQ_ISORT_THRESH) pdq_break(base + (pp + 1) * sz, rsz, sz, &rs);
        } else if (ap) {
            int lok = pdq_partial_isort(base, lsz, sz, cmp, tmp);
            int rok = pdq_partial_isort(base + (pp + 1) * sz, rsz, sz, cmp, tmp);
            if (lok && rok) continue;
        }
        unsigned char *rbase = base + (pp + 1) * sz;
        if (lsz < rsz) {
            if (rsz > 1 && sp < PDQ_MAX_STACK) {
                stk[sp].base = rbase;
                stk[sp].n = rsz;
                stk[sp].bad = bad;
                stk[sp].left = 0;
                ++sp;
            }
            n = lsz;
        } else {
            if (lsz > 1 && sp < PDQ_MAX_STACK) {
                stk[sp].base = base;
                stk[sp].n = lsz;
                stk[sp].bad = bad;
                stk[sp].left = leftmost;
                ++sp;
            }
            base = rbase;
            n = rsz;
            leftmost = 0;
        }
        goto again;
    }
    if (scratch != sbuf)
        free(scratch);
}
#undef PDQ_ELEM
#undef PDQ_ISORT_THRESH
#undef PDQ_NINTHER_THRESH
#undef PDQ_PARTIAL_LIMIT
#undef PDQ_MAX_STACK
#endif
#if !defined(_OPENCSTL_PMSORT_H)
#define _OPENCSTL_PMSORT_H
#ifndef OPENCSTL_PTHREAD_H
#define OPENCSTL_PTHREAD_H
#ifdef __cplusplus
extern "C" {
#endif
#if defined(OCSTL_OS_WINDOWS)
#include<windows.h>
#include<errno.h>
#include<assert.h>
typedef struct pthread_tag {
    HANDLE handle;
} pthread_t;
typedef struct pthread_mutex_tag {
    HANDLE handle;
} pthread_mutex_t;
typedef struct pthread_attr_tag {
    int attr;
} pthread_attr_t;
typedef struct pthread_mutexattr_tag {
    int attr;
} pthread_mutexattr_t;
typedef DWORD pthread_key_t;
typedef struct _pthread_cleanup_stack {
#define _PTHREAD_CLEANUP_STACK_MAX 128
    HANDLE thread;
    void (*routine[_PTHREAD_CLEANUP_STACK_MAX])(void *);
    void *arg[_PTHREAD_CLEANUP_STACK_MAX];
    size_type64 index;
    struct _pthread_cleanup_stack *next;
} _pthread_cleanup_stack;
SELECT_ANY _pthread_cleanup_stack *_pthread_cleanup_stack_head = NULL;
SELECT_ANY HANDLE _pthread_cleanup_mutex = NULL;
static int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg) {
    DWORD dwThreadId = 1;
    HANDLE handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) start_routine, arg, 0, &dwThreadId);
    thread->handle = (HANDLE) handle;
    return thread->handle == (HANDLE) NULL;
}
static void pthread_exit(void *value_ptr) {
    if (!_pthread_cleanup_mutex)
        if (!_pthread_cleanup_mutex)
            _pthread_cleanup_mutex = CreateMutexA(NULL, FALSE, NULL);
    WaitForSingleObject(_pthread_cleanup_mutex, INFINITE);
    HANDLE thread = GetCurrentThread();
    _pthread_cleanup_stack **head = &_pthread_cleanup_stack_head;
    _pthread_cleanup_stack *rts = NULL;
    while (*head) {
        _pthread_cleanup_stack *tmp = *head;
        int b = (*head)->thread == thread;
        if (b) *head = (*head)->next;
        if (*head)head = &(*head)->next;
        if (b)rts = tmp;
    }
    if (rts) {
        while (rts->index--) {
            rts->routine[rts->index](rts->arg[rts->index]);
        }
        free(rts);
    }
    TerminateThread(GetCurrentThread(), *(int *) value_ptr);
    ReleaseMutex(_pthread_cleanup_mutex);
}
static int pthread_join(pthread_t thread, void **value_ptr) {
    DWORD r = WaitForSingleObject(thread.handle, INFINITE);
    CloseHandle(thread.handle);
    return r == WAIT_OBJECT_0 ? 0 : EINVAL;
}
static pthread_t pthread_self(void) {
    pthread_t pt;
    pt.handle = GetCurrentThread();
    return pt;
}
static int pthread_detach(pthread_t thread) {
    return CloseHandle(thread.handle);
}
static int pthread_cancel(pthread_t thread) {
    TerminateThread(thread.handle, 1);
    return 0;
}
static void pthread_cleanup_push(void (*routine)(void *), void *arg) {
    if (!_pthread_cleanup_mutex)
        if (!_pthread_cleanup_mutex)
            _pthread_cleanup_mutex = CreateMutexA(NULL, FALSE, NULL);
    WaitForSingleObject(_pthread_cleanup_mutex, INFINITE);
    HANDLE thread = GetCurrentThread();
    _pthread_cleanup_stack **head = &_pthread_cleanup_stack_head;
    while (*head) {
        if ((*head)->thread == thread) break;
        head = &(*head)->next;
    }
    if (!*head) {
        *head = (_pthread_cleanup_stack *) malloc(sizeof(_pthread_cleanup_stack));
        (*head)->index = 0;
        (*head)->next = NULL;
        (*head)->thread = thread;
    }
    (*head)->routine[(*head)->index] = routine;
    (*head)->arg[(*head)->index] = arg;
    (*head)->index++;
    assert((*head)->index <= _PTHREAD_CLEANUP_STACK_MAX);
    ReleaseMutex(_pthread_cleanup_mutex);
}
static void pthread_cleanup_pop(int execute) {
    if (!_pthread_cleanup_mutex)
        if (!_pthread_cleanup_mutex)
            _pthread_cleanup_mutex = CreateMutexA(NULL, FALSE, NULL);
    WaitForSingleObject(_pthread_cleanup_mutex, INFINITE);
    HANDLE thread = GetCurrentThread();
    _pthread_cleanup_stack **head = &_pthread_cleanup_stack_head;
    while (*head) {
        _pthread_cleanup_stack *tmp = *head;
        if ((*head)->thread == thread) {
            --(*head)->index;
            if ((*head)->index == 0) {
                *head = (*head)->next;
                while (execute && tmp->index--) {
                    tmp->routine[tmp->index](tmp->arg[tmp->index]);
                }
                free(tmp);
            }
            break;
        } else {
            head = &(*head)->next;
        }
    }
    ReleaseMutex(_pthread_cleanup_mutex);
}
static int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) {
    return 0;
}
static int pthread_mutexattr_init(pthread_mutexattr_t *attr) {
    return 0;
}
static int pthread_mutex_destroy(pthread_mutex_t *mutex) {
    return !CloseHandle(mutex->handle);
}
static int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) {
    HANDLE handle = CreateMutexA(NULL, FALSE, NULL);
    if (handle != NULL) {
        mutex->handle = handle;
        return 0;
    } else {
        return 1;
    }
}
static int pthread_mutex_lock(pthread_mutex_t *mutex) {
    return (WaitForSingleObject(mutex->handle, INFINITE) == WAIT_OBJECT_0) ? 0 : EINVAL;
}
static int pthread_mutex_trylock(pthread_mutex_t *mutex) {
    DWORD retvalue = WaitForSingleObject(mutex->handle, 0);
    switch (WaitForSingleObject(mutex->handle, 0)) {
        case WAIT_OBJECT_0: return 0;
        case WAIT_TIMEOUT: return EBUSY;
        default: return EINVAL;
    }
}
static int pthread_mutex_unlock(pthread_mutex_t *mutex) {
    return !ReleaseMutex(mutex->handle);
}
static int pthread_key_create(pthread_key_t *key, void (*destr_function)(void *)) {
    DWORD dkey = TlsAlloc();
    if (dkey != 0xFFFFFFFF) {
        *key = dkey;
        return 0;
    } else {
        return EAGAIN;
    }
}
static int pthread_key_delete(pthread_key_t key) {
    return TlsFree(key) ? 0 : EINVAL;
}
static int pthread_setspecific(pthread_key_t key, const void *pointer) {
    return TlsSetValue(key, (LPVOID) pointer) ? 0 : EINVAL;
}
static void *pthread_getspecific(pthread_key_t key) {
    return TlsGetValue(key);
}
#else
#include <pthread.h>
#endif
#ifdef __cplusplus
}
#endif
#endif
#include <stdlib.h>
#include <string.h>
#ifndef PS_MAX_DEPTH
#define PS_MAX_DEPTH 4
#endif
#ifndef PS_SEQ_CUTOFF
#define PS_SEQ_CUTOFF 4096
#endif
struct ps_args {
    char *base;
    char *buf;
    size_type64 n;
    size_type64 sz;
    CSTL_COMPARE cmp;
    int depth;
};
static void ps_merge(char *base, char *buf, size_type64 n1, size_type64 n2,
                     size_type64 sz, CSTL_COMPARE cmp) {
    char *l = base;
    char *r = base + n1 * sz;
    char *l_end = r;
    char *r_end = r + n2 * sz;
    char *d = buf;
    while (l < l_end && r < r_end) {
        if (cmp(r, l) < 0) {
            memcpy(d, r, sz);
            r += sz;
        } else {
            memcpy(d, l, sz);
            l += sz;
        }
        d += sz;
    }
    if (l < l_end)
        memcpy(d, l, (size_type64) (l_end - l));
    if (r < r_end)
        memcpy(d, r, (size_type64) (r_end - r));
    memcpy(base, buf, (n1 + n2) * sz);
}
static void *ps_run(void *p) {
    struct ps_args *a = (struct ps_args *) p;
    if (a->n < 2) return NULL;
    if (a->n <= PS_SEQ_CUTOFF || a->depth >= PS_MAX_DEPTH) {
        qsort(a->base, a->n, a->sz, a->cmp);
        return NULL;
    }
    size_type64 mid = a->n / 2;
    struct ps_args left = {
        a->base, a->buf, mid, a->sz, a->cmp, a->depth + 1
    };
    struct ps_args right = {
        a->base + mid * a->sz, a->buf + mid * a->sz,
        a->n - mid, a->sz, a->cmp, a->depth + 1
    };
    pthread_t tid;
    int spawned = (pthread_create(&tid, NULL, ps_run, &left) == 0);
    if (!spawned) ps_run(&left);
    ps_run(&right);
    if (spawned) pthread_join(tid, NULL);
    ps_merge(a->base, a->buf, mid, a->n - mid, a->sz, a->cmp);
    return NULL;
}
static void pmsort(void *base, const size_type64 number, const size_type64 width, CSTL_COMPARE cmp) {
    if (number < 2) return;
    if (number <= PS_SEQ_CUTOFF) {
        msort(base, number, width, cmp);
        return;
    }
    char *buf = (char *) malloc(number * width);
    if (!buf) {
        msort(base, number, width, cmp);
        return;
    }
    struct ps_args root = {
        (char *) base, buf, number, width, cmp, 0
    };
    ps_run(&root);
    free(buf);
}
#undef PS_MAX_DEPTH
#undef PS_SEQ_CUTOFF
#endif
#ifndef OPENCSTL_BESTSORT_H
#define OPENCSTL_BESTSORT_H
#if defined(OCSTL_OS_MACOS) && defined(OCSTL_CC_CLANG)
#define cstl_best_stable_sort msort
#define cstl_unstable_sort pdqsort
#elif defined(OCSTL_OS_MACOS) && defined(OCSTL_CC_GCC)
#define cstl_best_stable_sort tsort
#define cstl_unstable_sort pdqsort
#elif defined(OCSTL_OS_MACOS) && defined(OCSTL_CC_TCC)
#define cstl_best_stable_sort tsort
#define cstl_unstable_sort qsort
#elif defined(OCSTL_OS_LINUX) && defined(OCSTL_CC_CLANG)
#define cstl_best_stable_sort msort
#define cstl_unstable_sort pdqsort
#elif defined(OCSTL_OS_LINUX) && defined(OCSTL_CC_GCC)
#define cstl_best_stable_sort tsort
#define cstl_unstable_sort pdqsort
#elif defined(OCSTL_OS_LINUX) && defined(OCSTL_CC_TCC)
#define cstl_best_stable_sort tsort
#define cstl_unstable_sort qsort
#elif defined(OCSTL_OS_WINDOWS) && defined(OCSTL_CC_CLANG)
#define cstl_best_stable_sort tsort
#define cstl_unstable_sort pdqsort
#elif defined(OCSTL_OS_WINDOWS) && defined(OCSTL_CC_GCC)
#define cstl_best_stable_sort tsort
#define cstl_unstable_sort pdqsort
#elif defined(OCSTL_OS_WINDOWS) && defined(OCSTL_CC_TCC)
#define cstl_best_stable_sort tsort
#define cstl_unstable_sort pdqsort
#elif defined(OCSTL_OS_WINDOWS) && defined(OCSTL_CC_MSVC)
#define cstl_best_stable_sort tsort
#define cstl_unstable_sort pdqsort
#elif defined(OCSTL_CC_NVCC)
#define cstl_best_stable_sort tsort
#define cstl_unstable_sort pdqsort
#endif
#endif
#ifndef OPENCSTL_RSORT_H
#define OPENCSTL_RSORT_H
#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>
#include <limits.h>
static void rsort32(int32_t *__base, size_type64 n) {
    if (__base == NULL || n <= 1) {
        return;
    }
    int32_t *tmp = (int32_t *) malloc(n * sizeof(int32_t));
    if (tmp == NULL) {
        return;
    }
    {
        size_type64 count[256];
        size_type64 pass, i;
        uint32_t sign_mask = (uint32_t) 1u << (sizeof(int32_t) * CHAR_BIT - 1);
        for (pass = 0; pass < sizeof(int32_t); ++pass) {
            size_type64 shift = pass * 8;
            for (i = 0; i < 256; ++i) {
                count[i] = 0;
            }
            for (i = 0; i < n; ++i) {
                uint32_t key = ((uint32_t) __base[i]) ^ sign_mask;
                uint32_t digit = (key >> shift) & 0xFFu;
                count[digit]++;
            }
            for (i = 1; i < 256; ++i) {
                count[i] += count[i - 1];
            }
            for (i = n; i > 0; --i) {
                uint32_t key = ((uint32_t) __base[i - 1]) ^ sign_mask;
                uint32_t digit = (key >> shift) & 0xFFu;
                tmp[--count[digit]] = __base[i - 1];
            }
            for (i = 0; i < n; ++i) {
                __base[i] = tmp[i];
            }
        }
    }
    free(tmp);
}
static void rsort64(int64_t *__base, size_type64 n) {
    if (__base == NULL || n <= 1) {
        return;
    }
    int64_t *tmp = (int64_t *) malloc(n * sizeof(int64_t));
    if (tmp == NULL) {
        return;
    }
    {
        size_type64 count[256];
        size_type64 pass, i;
        uint64_t sign_mask = (uint64_t) 1ULL << (sizeof(int64_t) * CHAR_BIT - 1);
        for (pass = 0; pass < sizeof(int64_t); ++pass) {
            size_type64 shift = pass * 8;
            for (i = 0; i < 256; ++i) {
                count[i] = 0;
            }
            for (i = 0; i < n; ++i) {
                uint64_t key = ((uint64_t) __base[i]) ^ sign_mask;
                uint32_t digit = (uint32_t) ((key >> shift) & 0xFFULL);
                count[digit]++;
            }
            for (i = 1; i < 256; ++i) {
                count[i] += count[i - 1];
            }
            for (i = n; i > 0; --i) {
                uint64_t key = ((uint64_t) __base[i - 1]) ^ sign_mask;
                uint32_t digit = (uint32_t) ((key >> shift) & 0xFFULL);
                tmp[--count[digit]] = __base[i - 1];
            }
            for (i = 0; i < n; ++i) {
                __base[i] = tmp[i];
            }
        }
    }
    free(tmp);
}
#define RSORT_STATIC_TYPECHECK(base) \
    ((void)sizeof(char[(sizeof(*(base)) == 4 || sizeof(*(base)) == 8) ? 1 : -1]))
#define rsort(base, n)                                                     \
    do {                                                                   \
        RSORT_STATIC_TYPECHECK(base);                                      \
        if (sizeof(*(base)) == sizeof(int32_t)) {                          \
            rsort32((int32_t *)(base), (n));                               \
        } else {                                                           \
            rsort64((int64_t *)(base), (n));                               \
        }                                                                  \
    } while (0)
#endif
#define _CSTL_SORT_EXPAND(x) x
#define _cstl_sort_func(...) _CSTL_SORT_EXPAND(_CSTL_SORT_DISPATCH(__VA_ARGS__, NULL, NULL))
#define _CSTL_SORT_DISPATCH(CONTAINER, FUNC, ...) _cstl_sort(CONTAINER, (void*)(FUNC))
OPENCSTL_FUNC void _cstl_sort(void *container, void *_cmp) {
    ptrdiff_t distance = 0;
    size_type64 container_type = __opencstl_container_type((void **) &container, &distance);
    if (container_type == 0) return;
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            size_type64 type_size = (size_type64) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            size_type64 length = (size_type64) OPENCSTL_NIDX(&container, -1);
            CSTL_COMPARE cmp = (CSTL_COMPARE) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                fault("Compare function is NULL");
            }
            cstl_unstable_sort(container, length, type_size, cmp);
        }
        break;
        case OPENCSTL_LIST: {
            size_type64 type_size = (size_type64) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            CSTL_COMPARE cmp = (CSTL_COMPARE) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                fault("Compare function is NULL");
            }
            __cstl_list_qsort(&container, cmp);
        }
        break;
        case OPENCSTL_DEQUE: {
            size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (NIDX_TSIZE) * (ptrdiff_t) sizeof(size_type64) + distance);
            size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
            char *type_name = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
            CSTL_COMPARE cmp = (CSTL_COMPARE) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                fault("Compare function is NULL");
            }
            cstl_unstable_sort(container, length, type_size, cmp);
        }
        break;
        default: {
            fault("Invalid Operation");
        }
        break;
    }
}
#define _CSTL_STABLE_SORT_EXPAND(x) x
#define _cstl_stable_sort_func(...) _CSTL_STABLE_SORT_EXPAND(_CSTL_STABLE_SORT_DISPATCH(__VA_ARGS__, NULL, NULL))
#define _CSTL_STABLE_SORT_DISPATCH(CONTAINER, FUNC, ...) _cstl_stable_sort(CONTAINER, (void*)(FUNC))
OPENCSTL_FUNC void _cstl_stable_sort(void *container, void *_cmp) {
    ptrdiff_t distance = 0;
    size_type64 container_type = __opencstl_container_type((void **) &container, &distance);
    if (container_type == 0) return;
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            size_type64 type_size = (size_type64) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            size_type64 length = (size_type64) OPENCSTL_NIDX(&container, -1);
            CSTL_COMPARE cmp = (CSTL_COMPARE) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                fault("Compare function is NULL");
            }
            cstl_best_stable_sort(container, length, type_size, cmp);
        }
        break;
        case OPENCSTL_LIST: {
            size_type64 type_size = (size_type64) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            CSTL_COMPARE cmp = (CSTL_COMPARE) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                fault("Compare function is NULL");
            }
            __cstl_list_msort(&container, cmp);
        }
        break;
        case OPENCSTL_DEQUE: {
            size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (NIDX_TSIZE) * (ptrdiff_t) sizeof(size_type64) + distance);
            size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
            char *type_name = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
            CSTL_COMPARE cmp = (CSTL_COMPARE) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                fault("Compare function is NULL");
            }
            cstl_best_stable_sort(container, length, type_size, cmp);
        }
        break;
        default: {
            fault("Invalid Operation");
        }
        break;
    }
}
#if defined(USE_CSTL_FUNC)
#if defined(__cplusplus)
#define csort _cstl_sort_func
#define cstable_sort _cstl_stable_sort_func
#else
#define sort _cstl_sort_func
#define stable_sort _cstl_stable_sort_func
#endif
#endif
#if defined(_WIN32) || defined(_WIN64)
#define cstl_sort(container,...)	_cstl_sort(&(container),ARGN(__VA_ARGS__),__VA_ARGS__)
#define cstl_stable_sort_def(container,...)	_cstl_stable_sort(&(container),ARGN(__VA_ARGS__),__VA_ARGS__)
#elif defined(__linux__) || defined(__APPLE__)
#define cstl_sort(C,...) _linux_cstl_sort(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,ARGN(__VA_ARGS__),__VA_ARGS__)
#define _linux_cstl_sort(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_sort ## _ ## N
#define _cstl_sort_0(C,argc)    {_CSTL_TYPEOF(&C) __0=&C;_cstl_sort( __0,argc);}
#define _cstl_sort_1(C,argc,_1)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_sort( __0,argc,&__1);}
#define _cstl_sort_2(C,argc,_1,_2)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_sort( __0,argc,&__1,&__2);}
#define _cstl_sort_3(C,argc,_1,_2,_3)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_sort( __0,argc,&__1,&__2,&__3);}
#define _cstl_sort_4(C,argc,_1,_2,_3,_4)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_sort( __0,argc,&__1,&__2,&__3,&__4);}
#define _cstl_sort_5(C,argc,_1,_2,_3,_4,_5)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_sort( __0,argc,&__1,&__2,&__3,&__4,&__5);}
#define _cstl_sort_6(C,argc,_1,_2,_3,_4,_5,_6)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6);}
#define _cstl_sort_7(C,argc,_1,_2,_3,_4,_5,_6,_7)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}
#define _cstl_sort_8(C,argc,_1,_2,_3,_4,_5,_6,_7,_8)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}
#define _cstl_sort_9(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}
#define _cstl_sort_10(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}
#define cstl_stable_sort(C,...) _linux_cstl_stable_sort(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,ARGN(__VA_ARGS__),__VA_ARGS__)
#define _linux_cstl_stable_sort(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_stable_sort ## _ ## N
#define _cstl_stable_sort_0(C,argc)    {_CSTL_TYPEOF(&C) __0=&C;_cstl_stable_sort( __0,argc);}
#define _cstl_stable_sort_1(C,argc,_1)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_cstl_stable_sort( __0,argc,&__1);}
#define _cstl_stable_sort_2(C,argc,_1,_2)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_cstl_stable_sort( __0,argc,&__1,&__2);}
#define _cstl_stable_sort_3(C,argc,_1,_2,_3)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_cstl_stable_sort( __0,argc,&__1,&__2,&__3);}
#define _cstl_stable_sort_4(C,argc,_1,_2,_3,_4)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_cstl_stable_sort( __0,argc,&__1,&__2,&__3,&__4);}
#define _cstl_stable_sort_5(C,argc,_1,_2,_3,_4,_5)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_cstl_stable_sort( __0,argc,&__1,&__2,&__3,&__4,&__5);}
#define _cstl_stable_sort_6(C,argc,_1,_2,_3,_4,_5,_6)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_cstl_stable_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6);}
#define _cstl_stable_sort_7(C,argc,_1,_2,_3,_4,_5,_6,_7)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_cstl_stable_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7);}
#define _cstl_stable_sort_8(C,argc,_1,_2,_3,_4,_5,_6,_7,_8)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_cstl_stable_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8);}
#define _cstl_stable_sort_9(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_cstl_stable_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9);}
#define _cstl_stable_sort_10(C,argc,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10)    {_CSTL_TYPEOF(&C) __0=&C;_CSTL_TYPEOF(_1) __1=_1;_CSTL_TYPEOF(_2) __2=_2;_CSTL_TYPEOF(_3) __3=_3;_CSTL_TYPEOF(_4) __4=_4;_CSTL_TYPEOF(_5) __5=_5;_CSTL_TYPEOF(_6) __6=_6;_CSTL_TYPEOF(_7) __7=_7;_CSTL_TYPEOF(_8) __8=_8;_CSTL_TYPEOF(_9) __9=_9;_CSTL_TYPEOF(_10) __10=_10;_cstl_stable_sort( __0,argc,&__1,&__2,&__3,&__4,&__5,&__6,&__7,&__8,&__9,&__10);}
#endif
#define _CSTL_IS_SORTED_EXPAND(x) x
#define _cstl_is_sorted_func(...) _CSTL_IS_SORTED_EXPAND(_CSTL_IS_SORTED_DISPATCH(__VA_ARGS__, NULL, NULL))
#define _CSTL_IS_SORTED_DISPATCH(CONTAINER, FUNC, ...) _cstl_is_sorted(CONTAINER, (void*)(FUNC))
OPENCSTL_FUNC int _cstl_is_sorted(void *container, void *_cmp) {
    ptrdiff_t distance = 0;
    size_type64 container_type = __opencstl_container_type((void **) &container, &distance);
    if (container_type == 0) return 0;
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            size_type64 type_size = (size_type64) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            size_type64 length = (size_type64) OPENCSTL_NIDX(&container, -1);
            CSTL_COMPARE cmp = (CSTL_COMPARE) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                fault("Compare function is NULL");
                return 0;
            }
            for (size_type64 i = 1; i < length; i++) {
                if (cmp((char *) container + (i - 1) * type_size,
                        (char *) container + i * type_size) > 0) {
                    return 0;
                }
            }
            return 1;
        }
        break;
        case OPENCSTL_LIST: {
            size_type64 type_size = (size_type64) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            CSTL_COMPARE cmp = (CSTL_COMPARE) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                fault("Compare function is NULL");
                return 0;
            }
            void *it = cstl_begin(container);
            void *end = cstl_end(container);
            if (it == end) {
                return 1;
            }
            void *prev = it;
            it = cstl_next(it);
            while (it != end) {
                if (cmp(prev, it) > 0) {
                    return 0;
                }
                prev = it;
                it = cstl_next(it);
            }
            return 1;
        }
        break;
        case OPENCSTL_DEQUE: {
            size_type64 type_size = *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (NIDX_TSIZE) * (ptrdiff_t) sizeof(size_type64) + distance);
            size_type64 length = *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (-2) * (ptrdiff_t) sizeof(size_type64) + distance);
            char *type_name = (char *) *(_opencstl_ll_ua *) ((char *) *(void **) &container + (ptrdiff_t) (-4) * (ptrdiff_t) sizeof(size_type64) + distance);
            CSTL_COMPARE cmp = (CSTL_COMPARE) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                fault("Compare function is NULL");
                return 0;
                return 0;
                return 0;
            }
            for (size_type64 i = 1; i < length; i++) {
                if (cmp((char *) container + (i - 1) * type_size,
                        (char *) container + i * type_size) > 0) {
                    return 0;
                }
            }
            return 1;
        }
        break;
        default: {
            fault("Invalid Operation");
            return 0;
        }
        break;
    }
}
#if defined(USE_CSTL_FUNC)
#define is_sorted _cstl_is_sorted_func
#endif
#endif
#if !defined(_OPENCSTL_VERSION_H)
#define _OPENCSTL_VERSION_H
static char *OPENCSTL_VERSION = "v1.3.2";
static char *opencstl_version(void) {
    return OPENCSTL_VERSION;
}
static char *opencstl_env(void) {
    static char __opencstl_env_str[512] = {0};
#if defined(OCSTL_CC_MSVC)
    sprintf_s(__opencstl_env_str, sizeof(__opencstl_env_str),
              "%s, %s, %s", OCSTL_OS_STR, OCSTL_CC_STR, OCSTL_C_VERSION_STR);
#else
    sprintf(__opencstl_env_str, "%s, %s, %s", OCSTL_OS_STR, OCSTL_CC_STR, OCSTL_C_VERSION_STR);
#endif
    return __opencstl_env_str;
}
#endif
#if !defined(OPENCSTL_BITSET_H)
#define OPENCSTL_BITSET_H
static inline int __popcnt_sw(int v) {
    v = (v & 0x55555555) + ((v >> 1) & 0x55555555);
    v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
    v = (v & 0x0f0f0f0f) + ((v >> 4) & 0x0f0f0f0f);
    v = (v & 0x00ff00ff) + ((v >> 8) & 0x00ff00ff);
    v = (v & 0x0000ffff) + ((v >> 16) & 0x0000ffff);
    return v;
}
static inline int __popcnt64_sw(long long v) {
    v = (v & 0x5555555555555555LL) + ((v >> 1) & 0x5555555555555555LL);
    v = (v & 0x3333333333333333LL) + ((v >> 2) & 0x3333333333333333LL);
    v = (v & 0x0f0f0f0f0f0f0f0fLL) + ((v >> 4) & 0x0f0f0f0f0f0f0f0fLL);
    v = (v & 0x00ff00ff00ff00ffLL) + ((v >> 8) & 0x00ff00ff00ff00ffLL);
    v = (v & 0x0000ffff0000ffffLL) + ((v >> 16) & 0x0000ffff0000ffffLL);
    v = (v & 0x00000000ffffffffLL) + ((v >> 32) & 0x00000000ffffffffLL);
    return (int) v;
}
#if defined(OCSTL_OS_LINUX)
#if defined (OCSTL_CC_TCC)
#define __popcnt __popcnt_sw
#define __popcnt64 __popcnt64_sw
#else
#define __popcnt(v)   __builtin_popcount((unsigned int)(v))
#define __popcnt64(v) __builtin_popcountll((unsigned long long)(v))
#endif
#elif defined(OCSTL_OS_WINDOWS)
#if !defined(OCSTL_CC_TCC)
#include<intrin.h>
#else
#define __popcnt __popcnt_sw
#define __popcnt64 __popcnt64_sw
#endif
#elif defined(OCSTL_OS_MACOS)
#if !defined(OCSTL_CC_TCC)
#define __popcnt(v)   __builtin_popcount((unsigned int)(v))
#define __popcnt64(v) __builtin_popcountll((unsigned long long)(v))
#else
#define __popcnt __popcnt_sw
#define __popcnt64 __popcnt64_sw
#endif
#endif
#define __BASE_SIZE 8
static inline size_type __cstl_bitset_capacity(size_type size) {
    size_type cap = (size + 7) / 8;
    return cap < __BASE_SIZE ? __BASE_SIZE : cap;
}
typedef struct {
    size_type nbits;
    ubyte_x *bits;
    char *str;
} BITSET;
#define new_bitset(N) __cstl_bitset(N)
static BITSET __cstl_bitset(size_type n) {
    size_type cap = __cstl_bitset_capacity(n);
    BITSET b;
    b.nbits = n;
    b.bits = (ubyte_x *) calloc(cap, 1);
    b.str = (char *) calloc(b.nbits + 1, 1);
    bool iveb_init = false;
    if (iveb == NULL) {
        iveb = iveb_new();
        iveb_init = true;
    }
    iveb_insert(iveb, b.bits, b.bits + cap, CT_BITSET, 0, "bitset");
    if (iveb_init) {
        atexit(__opencstl_iveb_destroy);
    }
    return b;
}
typedef void (*bitset_fn1)(BITSET b);
typedef void (*bitset_fn2)(BITSET b, size_type idx, bool val);
typedef size_type (*bitset_fn3)(BITSET b);
typedef bool (*bitset_fn4)(BITSET b);
typedef void (*bitset_fn5)(BITSET b, size_type idx);
typedef bool (*bitset_fn6)(BITSET b, size_type idx);
typedef char * (*bitset_fn7)(BITSET b);
static void __cstl_bitset_set(BITSET b) {
    size_type cap = __cstl_bitset_capacity(b.nbits);
    memset(b.bits, 0xFF, cap);
    size_type rem = b.nbits % 8;
    if (rem != 0) {
        b.bits[b.nbits / 8] &= (ubyte_x) ((1 << rem) - 1);
    }
}
static void __cstl_bitset_reset(BITSET b) {
    size_type cap = __cstl_bitset_capacity(b.nbits);
    memset(b.bits, 0, cap);
}
static void __cstl_bitset_set_at(BITSET b, size_type idx, bool val) {
    size_type byte_idx = idx / 8;
    size_type bit_idx = idx % 8;
    if (val) {
        b.bits[byte_idx] |= (ubyte_x) (1 << bit_idx);
    } else {
        b.bits[byte_idx] &= (ubyte_x) ~(1 << bit_idx);
    }
}
static size_type __cstl_bitset_count(BITSET b) {
    size_type cap = __cstl_bitset_capacity(b.nbits);
    size_type64 count = 0;
    size_type i = 0;
    for (; i + 8 <= cap; i += 8) {
        long long chunk;
        memcpy(&chunk, b.bits + i, 8);
        count += __popcnt64(chunk);
    }
    for (; i + 4 <= cap; i += 4) {
        int chunk;
        memcpy(&chunk, b.bits + i, 4);
        count += __popcnt(chunk);
    }
    for (; i < cap; i++) {
        count += __popcnt((int) b.bits[i]);
    }
    return (size_type) count;
}
static bool __cstl_bitset_all(BITSET b) {
    if (b.nbits == 0) return true;
    size_type full_bytes = b.nbits / 8;
    size_type rem = b.nbits % 8;
    for (size_type i = 0; i < full_bytes; i++) {
        if (b.bits[i] != 0xFF) return false;
    }
    if (rem != 0) {
        ubyte_x mask = (ubyte_x) ((1 << rem) - 1);
        if ((b.bits[full_bytes] & mask) != mask) return false;
    }
    return true;
}
static bool __cstl_bitset_any(BITSET b) {
    if (b.nbits == 0) return false;
    size_type full_bytes = b.nbits / 8;
    size_type rem = b.nbits % 8;
    for (size_type i = 0; i < full_bytes; i++) {
        if (b.bits[i] != 0) return true;
    }
    if (rem != 0) {
        ubyte_x mask = (ubyte_x) ((1 << rem) - 1);
        if ((b.bits[full_bytes] & mask) != 0) return true;
    }
    return false;
}
static bool __cstl_bitset_none(BITSET b) {
    return !__cstl_bitset_any(b);
}
static void __cstl_bitset_flip(BITSET b) {
    size_type full_bytes = b.nbits / 8;
    size_type rem = b.nbits % 8;
    for (size_type i = 0; i < full_bytes; i++) {
        b.bits[i] = ~b.bits[i];
    }
    if (rem != 0) {
        ubyte_x mask = (ubyte_x) ((1 << rem) - 1);
        b.bits[full_bytes] ^= mask;
    }
}
static void __cstl_bitset_flip_at(BITSET b, size_type idx) {
    size_type byte_idx = idx / 8;
    size_type bit_idx = idx % 8;
    b.bits[byte_idx] ^= (ubyte_x) (1 << bit_idx);
}
static size_type __cstl_bitset_nbits(BITSET b) {
    return b.nbits;
}
static bool __cstl_bitset_test(BITSET b, size_type idx) {
    size_type byte_idx = idx / 8;
    size_type bit_idx = idx % 8;
    return (b.bits[byte_idx] >> bit_idx) & 1;
}
static char *__cstl_bitset_to_string(BITSET b) {
    for (size_type i = 0; i < b.nbits; i++) {
        size_type bit_pos = b.nbits - 1 - i;
        b.str[i] = __cstl_bitset_test(b, bit_pos) ? '1' : '0';
    }
    b.str[b.nbits] = '\0';
    return b.str;
}
static void __cstl_bitset_free(BITSET b) {
    iveb_erase(iveb, b.bits);
    free(b.bits);
    free(b.str);
}
typedef struct {
    bitset_fn1 set;
    bitset_fn1 reset;
    bitset_fn2 set_at;
    bitset_fn3 count;
    bitset_fn4 all;
    bitset_fn4 any;
    bitset_fn4 none;
    bitset_fn1 flip;
    bitset_fn5 flip_at;
    bitset_fn3 nbits;
    bitset_fn6 test;
    bitset_fn7 to_string;
} __BITSET;
static __BITSET bitset = {
    __cstl_bitset_set,
    __cstl_bitset_reset,
    __cstl_bitset_set_at,
    __cstl_bitset_count,
    __cstl_bitset_all,
    __cstl_bitset_any,
    __cstl_bitset_none,
    __cstl_bitset_flip,
    __cstl_bitset_flip_at,
    __cstl_bitset_nbits,
    __cstl_bitset_test,
    __cstl_bitset_to_string,
};
#endif
#ifndef OPENCSTL_GLOB_H
#define OPENCSTL_GLOB_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
#if defined(OCSTL_OS_WINDOWS)
#include <windows.h>
#else
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#endif
static bool __cstl_glob_is_sep(char c) {
#if defined(OCSTL_OS_WINDOWS)
    return c == '/' || c == '\\';
#else
    return c == '/';
#endif
}
static bool __cstl_glob_exists_(const char *path) {
#if defined(OCSTL_OS_WINDOWS)
    return GetFileAttributesA(path) != INVALID_FILE_ATTRIBUTES;
#else
    struct stat st;
    return stat(path, &st) == 0;
#endif
}
static bool __cstl_glob_isdir_(const char *path) {
#if defined(OCSTL_OS_WINDOWS)
    DWORD a = GetFileAttributesA(path);
    return a != INVALID_FILE_ATTRIBUTES && (a & FILE_ATTRIBUTE_DIRECTORY);
#else
    struct stat st;
    if (stat(path, &st) != 0) return false;
    return S_ISDIR(st.st_mode);
#endif
}
static char *__cstl_glob_join_(const char *a, const char *b) {
    size_type64 la = strlen(a), lb = strlen(b);
    bool need_sep = la > 0 && !__cstl_glob_is_sep(a[la - 1]);
    char *r = (char *) malloc(la + (need_sep ? 1 : 0) + lb + 1);
    memcpy(r, a, la);
    size_type64 pos = la;
    if (need_sep) {
        r[pos++] = '/';
    }
    memcpy(r + pos, b, lb);
    r[pos + lb] = '\0';
    return r;
}
static char **__cstl_glob_listdir_(const char *path, int *n_out) {
    int cap = 16, cnt = 0;
    char **names = (char **) malloc(cap * sizeof(char *));
    *n_out = 0;
#if defined(OCSTL_OS_WINDOWS)
    size_type64 plen = strlen(path);
    char *pat = (char *) malloc(plen + 3);
    memcpy(pat, path, plen);
    size_type64 pos = plen;
    if (plen > 0 && !__cstl_glob_is_sep(path[plen - 1])) pat[pos++] = '\\';
    pat[pos++] = '*';
    pat[pos] = '\0';
    WIN32_FIND_DATAA data;
    HANDLE h = FindFirstFileA(pat, &data);
    free(pat);
    if (h == INVALID_HANDLE_VALUE) return names;
    do {
        if (strcmp(data.cFileName, ".") == 0 || strcmp(data.cFileName, "..") == 0) continue;
        if (cnt >= cap) {
            cap *= 2;
            names = (char **) realloc(names, cap * sizeof(char *));
        }
        size_type64 nl = strlen(data.cFileName);
        names[cnt] = (char *) malloc(nl + 1);
        memcpy(names[cnt], data.cFileName, nl + 1);
        cnt++;
    } while (FindNextFileA(h, &data));
    FindClose(h);
#else
    DIR *d = opendir(path);
    if (!d) return names;
    struct dirent *e;
    while ((e = readdir(d))) {
        if (strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0) continue;
        if (cnt >= cap) {
            cap *= 2;
            names = (char **) realloc(names, cap * sizeof(char *));
        }
        size_type64 nl = strlen(e->d_name);
        names[cnt] = (char *) malloc(nl + 1);
        memcpy(names[cnt], e->d_name, nl + 1);
        cnt++;
    }
    closedir(d);
#endif
    *n_out = cnt;
    return names;
}
static bool __cstl_glob_fnmatch_(const char *pat, const char *name) {
    while (*pat) {
        if (*pat == '*') {
            while (*pat == '*') pat++;
            if (!*pat) return true;
            while (*name) {
                if (__cstl_glob_fnmatch_(pat, name)) return true;
                name++;
            }
            return false;
        }
        if (!*name) return false;
        if (*pat == '?') {
            pat++;
            name++;
        } else if (*pat == '[') {
            const char *p = pat + 1;
            bool negate = false;
            if (*p == '!' || *p == '^') {
                negate = true;
                p++;
            }
            bool matched = false;
            if (*p == ']') {
                if (*name == ']') matched = true;
                p++;
            }
            while (*p && *p != ']') {
                if (p[1] == '-' && p[2] && p[2] != ']') {
                    unsigned char lo = (unsigned char) p[0], hi = (unsigned char) p[2];
                    unsigned char c = (unsigned char) *name;
                    if (c >= lo && c <= hi) matched = true;
                    p += 3;
                } else {
                    if (*name == *p) matched = true;
                    p++;
                }
            }
            if (*p != ']') return false;
            pat = p + 1;
            if (matched == negate) return false;
            name++;
        } else {
            if (*pat != *name) return false;
            pat++;
            name++;
        }
    }
    return !*name;
}
static bool __cstl_glob_has_magic_(const char *s) {
    for (; *s; s++) {
        if (*s == '*' || *s == '?' || *s == '[') return true;
    }
    return false;
}
static void __cstl_glob_parse_(const char *pat,
                               char **base_out, char ***segs_out, int *n_out) {
    size_type64 plen = strlen(pat);
    const char *rest = pat;
    char *base;
#if defined(OCSTL_OS_WINDOWS)
    if (plen >= 2 && isalpha((unsigned char) pat[0]) && pat[1] == ':') {
        if (plen >= 3 && __cstl_glob_is_sep(pat[2])) {
            base = (char *) malloc(4);
            base[0] = pat[0];
            base[1] = ':';
            base[2] = '/';
            base[3] = '\0';
            rest = pat + 3;
        } else {
            base = (char *) malloc(3);
            base[0] = pat[0];
            base[1] = ':';
            base[2] = '\0';
            rest = pat + 2;
        }
    } else if (plen >= 1 && __cstl_glob_is_sep(pat[0])) {
        base = (char *) malloc(2);
        base[0] = '/';
        base[1] = '\0';
        rest = pat + 1;
    } else {
        base = (char *) malloc(2);
        base[0] = '.';
        base[1] = '\0';
    }
#else
    if (plen >= 1 && pat[0] == '/') {
        base = (char *) malloc(2);
        base[0] = '/';
        base[1] = '\0';
        rest = pat + 1;
    } else {
        base = (char *) malloc(2);
        base[0] = '.';
        base[1] = '\0';
    }
#endif
    int cap = 8, n = 0;
    char **segs = (char **) malloc(cap * sizeof(char *));
    const char *start = rest;
    for (const char *p = rest; ; p++) {
        if (__cstl_glob_is_sep(*p) || *p == '\0') {
            size_type64 sl = (size_type64) (p - start);
            if (sl > 0) {
                if (n >= cap) {
                    cap *= 2;
                    segs = (char **) realloc(segs, cap * sizeof(char *));
                }
                segs[n] = (char *) malloc(sl + 1);
                memcpy(segs[n], start, sl);
                segs[n][sl] = '\0';
                n++;
            }
            if (*p == '\0') break;
            start = p + 1;
        }
    }
    *base_out = base;
    *segs_out = segs;
    *n_out = n;
}
typedef struct {
    char **items;
    int cnt;
    int cap;
} __cstl_glob_result_;
static void __cstl_glob_push_(__cstl_glob_result_ *r, const char *s) {
    if (r->cnt + 1 >= r->cap) {
        r->cap = r->cap ? r->cap * 2 : 16;
        r->items = (char **) realloc(r->items, r->cap * sizeof(char *));
    }
    size_type64 l = strlen(s);
    r->items[r->cnt] = (char *) malloc(l + 1);
    memcpy(r->items[r->cnt], s, l + 1);
    r->cnt++;
}
static void __cstl_glob_walk_(const char *base,
                              char **segs, int i, int n,
                              bool recursive,
                              __cstl_glob_result_ *out) {
    if (i >= n) {
        if (__cstl_glob_exists_(base)) __cstl_glob_push_(out, base);
        return;
    }
    const char *seg = segs[i];
    if (recursive && strcmp(seg, "**") == 0) {
        __cstl_glob_walk_(base, segs, i + 1, n, recursive, out);
        int dn;
        char **dnames = __cstl_glob_listdir_(base, &dn);
        for (int k = 0; k < dn; k++) {
            if (dnames[k][0] != '.') {
                char *sub = __cstl_glob_join_(base, dnames[k]);
                if (__cstl_glob_isdir_(sub)) {
                    __cstl_glob_walk_(sub, segs, i, n, recursive, out);
                }
                free(sub);
            }
            free(dnames[k]);
        }
        free(dnames);
        return;
    }
    bool is_last = (i == n - 1);
    if (!__cstl_glob_has_magic_(seg)) {
        char *full = __cstl_glob_join_(base, seg);
        if (is_last) {
            if (__cstl_glob_exists_(full)) __cstl_glob_push_(out, full);
        } else if (__cstl_glob_isdir_(full)) {
            __cstl_glob_walk_(full, segs, i + 1, n, recursive, out);
        }
        free(full);
        return;
    }
    int dn;
    char **dnames = __cstl_glob_listdir_(base, &dn);
    bool pat_starts_dot = (seg[0] == '.');
    for (int k = 0; k < dn; k++) {
        if (dnames[k][0] == '.' && !pat_starts_dot) {
            free(dnames[k]);
            continue;
        }
        if (__cstl_glob_fnmatch_(seg, dnames[k])) {
            char *full = __cstl_glob_join_(base, dnames[k]);
            if (is_last) {
                __cstl_glob_push_(out, full);
            } else if (__cstl_glob_isdir_(full)) {
                __cstl_glob_walk_(full, segs, i + 1, n, recursive, out);
            }
            free(full);
        }
        free(dnames[k]);
    }
    free(dnames);
}
static char **__cstl_glob_impl_(const char *pattern, bool recursive) {
    char *base;
    char **segs;
    int n_segs;
    __cstl_glob_parse_(pattern, &base, &segs, &n_segs);
    __cstl_glob_result_ r = {0};
    __cstl_glob_walk_(base, segs, 0, n_segs, recursive, &r);
    for (int i = 0; i < n_segs; i++) free(segs[i]);
    free(segs);
    free(base);
    if (!r.items) {
        r.items = (char **) malloc(sizeof(char *));
    } else if (r.cnt + 1 > r.cap) {
        r.items = (char **) realloc(r.items, (r.cnt + 1) * sizeof(char *));
    }
    r.items[r.cnt] = NULL;
    for (int i = 0; i < r.cnt; i++) {
        char *s = r.items[i];
        for (char *p = s; *p; p++) {
            if (*p == '\\') *p = '/';
        }
        if (s[0] == '.' && s[1] == '/') {
            size_type64 l = strlen(s);
            memmove(s, s + 2, l - 1);
        }
    }
    bool iveb_init = false;
    if (iveb == NULL) {
        iveb = iveb_new();
        iveb_init = true;
    }
    iveb_insert(iveb, r.items, r.items, CT_GLOB, 0, "glob");
    if (iveb_init) {
        atexit(__opencstl_iveb_destroy);
    }
    return r.items;
}
static void __glob_free(char **results) {
    if (!results) return;
    for (char **p = results; *p; p++) free(*p);
    iveb_erase(iveb,results);
    free(results);
}
#define __CSTL_GLOB_PICK(_1, _2, NAME, ...) NAME
#define __CSTL_GLOB_1(p)    __cstl_glob_impl_((p), false)
#define __CSTL_GLOB_2(p, r) __cstl_glob_impl_((p), (r))
#define glob(...) __CSTL_GLOB_PICK(__VA_ARGS__, __CSTL_GLOB_2, __CSTL_GLOB_1)(__VA_ARGS__)
#endif
#if !defined(OPENCSTL_MSG_H)
#define OPENCSTL_MSG_H
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>
#include <stdarg.h>
#if defined(OCSTL_OS_WINDOWS)
#include <windows.h>
#endif
static void MsgBoxCLI(const char *format, ...) {
#if defined(OCSTL_CC_MSVC)
    SetConsoleOutputCP(CP_UTF8);
#elif defined(OCSTL_CC_TCC)
#ifdef OCSTL_OS_WINDOWS
    SetConsoleOutputCP(65001);
#endif
    setvbuf(stdout, NULL, _IONBF, 0);
#endif
    int width = 80;
    setlocale(LC_ALL, ".UTF-8");
    va_list args;
    va_start(args, format);
    char buf[1024];
    vsnprintf(buf, sizeof(buf), format, args);
    va_end(args);
    const char *tl = "\xE2\x94\x8F";
    const char *tr = "\xE2\x94\x93";
    const char *bl = "\xE2\x94\x97";
    const char *br = "\xE2\x94\x9B";
    const char *vline = "\xE2\x94\x81";
    const char *hline = "\xE2\x94\x83";
    int inner = width - 2;
    fputs(tl, stdout);
    for (int i = 0; i < inner; i++) fputs(vline, stdout);
    fputs(tr, stdout);
    putchar('\n');
    const char *line_start = buf;
    const char *p = buf;
    while (1) {
        if (*p == '\n' || *p == '\0') {
            int len = (int) (p - line_start);
            int lpadding = (inner - len) / 2;
            int rpadding = inner - len - lpadding;
            if (lpadding < 0) lpadding = 0;
            if (rpadding < 0) rpadding = 0;
            fputs(hline, stdout);
            for (int i = 0; i < lpadding; i++) putchar(' ');
            fwrite(line_start, 1, (size_type64) len, stdout);
            for (int i = 0; i < rpadding; i++) putchar(' ');
            fputs(hline, stdout);
            putchar('\n');
            if (*p == '\0') break;
            line_start = p + 1;
        }
        p++;
    }
    fputs(bl, stdout);
    for (int i = 0; i < inner; i++) fputs(vline, stdout);
    fputs(br, stdout);
    putchar('\n');
}
#if defined(OCSTL_OS_WINDOWS)
#if defined(OCSTL_CC_GCC_)
#pragma comment(lib, "user32.lib")
#endif
static char *_MsgTitle(void) {
    static char buf[1024] = {0};
#if defined(OCSTL_CC_GCC)
    sprintf(buf, "%s", "GNU gcc Runtime Library");
#elif defined(OCSTL_CC_MSVC)
    sprintf_s(buf, sizeof(buf), "%s", "Microsoft Visual C Runtime Library");
#elif defined(OCSTL_CC_CLANG)
    sprintf(buf, "%s", "LLVM clang Runtime Library");
#elif defined(OCSTL_CC_TCC)
    sprintf(buf, "%s", "TCC Runtime Library");
#endif
    return buf;
}
typedef int (WINAPI *PFN_MessageBoxExA)(HWND, LPCSTR, LPCSTR, UINT, WORD);
static void MsgBoxGUI(const char *format, ...) {
    setlocale(LC_ALL, ".UTF-8");
    char userMsg[1024];
    va_list args;
    va_start(args, format);
    vsnprintf(userMsg, sizeof(userMsg), format, args);
    va_end(args);;
#ifdef OCSTL_OS_WINDOWS
    int r = 0;
#ifdef OCSTL_CC_TCC
    HMODULE h = LoadLibraryA("user32.dll");
    PFN_MessageBoxExA pMessageBoxExA = h
                                           ? (PFN_MessageBoxExA) GetProcAddress(h, "MessageBoxExA")
                                           : NULL;
#else
    HMODULE h = NULL;
    PFN_MessageBoxExA pMessageBoxExA = MessageBoxExA;
#endif
    char path[MAX_PATH];
    GetModuleFileNameA(NULL, path, sizeof(path));
    char buf[2048];
    snprintf(buf, sizeof(buf),
             "Runtime Error!\n\n"
             "Program: %s\n\n"
             "MsgBoxGUI() has been called\n\n"
             "%s\n\n"
             "(Press Retry to debug the application)",
             path, userMsg);
    if (pMessageBoxExA) {
        r = pMessageBoxExA(
            NULL,
            buf,
            _MsgTitle(),
            MB_ABORTRETRYIGNORE | MB_ICONERROR | MB_DEFBUTTON3 | MB_TASKMODAL,
            0
        );
    }
    if (h) FreeLibrary(h);
    switch (r) {
        case IDABORT: ExitProcess(3);
            break;
        case IDRETRY: DebugBreak();
            break;
        case IDIGNORE: break;
    }
#endif
}
#elif defined(OCSTL_OS_LINUX)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <sys/wait.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
#include <signal.h>
struct lang_labels {
    const char *prefix;
    const char *abort_s;
    const char *retry_s;
    const char *ignore_s;
    const char *title_s;
};
static const struct lang_labels kLangs[] = {
    {"ko", "중단", "다시 시도", "무시", "런타임 라이브러리"},
    {"ja", "中止", "再試行", "無視", "ランタイム ライブラリ"},
    {"zh", "中止", "重试", "忽略", "运行时库"},
    {"de", "Abbrechen", "Wiederholen", "Ignorieren", "Laufzeitbibliothek"},
    {"fr", "Abandonner", "Réessayer", "Ignorer", "Bibliothèque d'exécution"},
    {"es", "Anular", "Reintentar", "Omitir", "Biblioteca de ejecución"},
    {"ru", "Прервать", "Повторить", "Пропустить", "Библиотека времени выполнения"},
    {"it", "Interrompi", "Riprova", "Ignora", "Libreria runtime"},
    {"pt", "Anular", "Repetir", "Ignorar", "Biblioteca de runtime"},
    {"en", "Abort", "Retry", "Ignore", "Runtime Library"},
    {NULL, NULL, NULL, NULL, NULL}
};
static const struct lang_labels *detect_lang(void) {
    const char *lang = getenv("LC_ALL");
    if (!lang || !*lang) lang = getenv("LC_MESSAGES");
    if (!lang || !*lang) lang = getenv("LANG");
    if (!lang || !*lang) lang = "en";
    for (int i = 0; kLangs[i].prefix; i++) {
        size_type64 n = strlen(kLangs[i].prefix);
        if (strncmp(lang, kLangs[i].prefix, n) == 0 &&
            (lang[n] == '\0' || lang[n] == '_' || lang[n] == '.')) {
            return &kLangs[i];
        }
    }
    int last = 0;
    while (kLangs[last + 1].prefix) last++;
    return &kLangs[last];
}
#define IDABORT   3
#define IDRETRY   4
#define IDIGNORE  5
static void get_exe_path(char *out, size_type64 n) {
    ssize_t r = readlink("/proc/self/exe", out, n - 1);
    if (r < 0) r = 0;
    out[r] = '\0';
}
static int zenity_abort_retry_ignore(const char *title, const char *body) {
    int pipefd[2];
    if (pipe(pipefd) < 0) return IDABORT;
    pid_t pid = fork();
    if (pid < 0) {
        close(pipefd[0]);
        close(pipefd[1]);
        return IDABORT;
    }
    const struct lang_labels *L = detect_lang();
    if (pid == 0) {
        close(pipefd[0]);
        dup2(pipefd[1], STDOUT_FILENO);
        close(pipefd[1]);
        char ok_opt[128], cancel_opt[128], extra_opt[128];
        snprintf(ok_opt, sizeof(ok_opt), "--ok-label=%s", L->ignore_s);
        snprintf(cancel_opt, sizeof(cancel_opt), "--cancel-label=%s", L->abort_s);
        snprintf(extra_opt, sizeof(extra_opt), "--extra-button=%s", L->retry_s);
        int devnull = open("/dev/null", O_WRONLY);
        if (devnull >= 0) {
            dup2(devnull, STDERR_FILENO);
            close(devnull);
        }
        execlp("zenity", "zenity",
               "--question",
               "--title", L->title_s,
               "--text", body,
               "--icon=dialog-error",
               ok_opt,
               cancel_opt,
               extra_opt,
               "--default-cancel",
               "--width=420",
               (char *) NULL);
        _exit(127);
    }
    close(pipefd[1]);
    char out[256] = {0};
    ssize_t n = read(pipefd[0], out, sizeof(out) - 1);
    close(pipefd[0]);
    if (n > 0) out[n] = '\0';
    int status = 0;
    waitpid(pid, &status, 0);
    int code = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
    if (code == 0) {
        return IDIGNORE;
    }
    size_type64 Llen = strlen(out);
    while (Llen > 0 && (out[Llen - 1] == '\n' || out[Llen - 1] == '\r')) out[--Llen] = '\0';
    if (strcmp(out, L->retry_s) == 0) return IDRETRY;
    return IDABORT;
}
static void MsgBoxGUI(const char *format, ...) {
    char userMsg[1024];
    va_list args;
    va_start(args, format);
    vsnprintf(userMsg, sizeof(userMsg), format, args);
    va_end(args);
    char path[PATH_MAX];
    get_exe_path(path, sizeof(path));
    char buf[8192] = {0};
    snprintf(buf, sizeof(buf),
             "<b>Runtime Error!</b>\n\n"
             "Program: %s\n\n"
             "MsgBoxGUI() has been called\n\n"
             "%s\n\n"
             "(Press Retry to debug the application)",
             path, userMsg);
    int r = zenity_abort_retry_ignore("Runtime Library", buf);
    switch (r) {
        case IDABORT: fprintf(stderr, "abort\n");
            _exit(3);
        case IDRETRY: fprintf(stderr, "retry\n");
#if defined(OCSTL_CC_TCC)
raise(SIGTRAP);
#else
__builtin_trap();
#endif
break;
        case IDIGNORE: fprintf(stderr, "ignore\n");
            break;
    }
}
#elif defined(OASTL_OS_MACOD)
#endif
#endif
#ifndef OPENCSTL_JSON_H
#define OPENCSTL_JSON_H
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#include<stdbool.h>
#if defined(OCSTL_CC_TCC) || defined(OCSTL_OS_LINUX)
char *strtok_s(char *str, char *delimiters, char **last) {
    if (!delimiters || !last) return NULL;
    char *s = str ? str : *last;
    if (!s) return NULL;
    while (*s && strchr(delimiters, *s)) s++;
    if (!*s) {
        *last = NULL;
        return NULL;
    }
    char *token = s;
    while (*s && !strchr(delimiters, *s)) s++;
    if (*s) {
        *s = '\0';
        *last = s + 1;
    } else {
        *last = NULL;
    }
    return token;
}
#elif defined(OCSTL_OS_MACOS) || defined(OCSTL_CC_GCC)
#define strtok_s strtok_r
#elif !defined(OCSTL_CC_MSVC)
#endif
typedef struct JSON_TOKEN JSON_TOKEN;
JSON_TOKEN *__g_last_token = NULL;
int as_int();
char *as_string();
bool as_bool();
double as_double();
bool is_null();
struct JSON_TOKEN {
    char *p;
    char *q;
    char key[512];
    char *str_buf;
    struct JSON_TOKEN *children;
    struct JSON_TOKEN *next;
    int (*as_int)();
    bool (*as_bool)();
    char * (*as_string)();
    double (*as_double)();
    bool (*is_null)();
};
typedef struct JSON_TOKEN JSON;
int __as_int() {
    JSON_TOKEN *p = __g_last_token;
    if (!p || !p->p) return 0;
    return (int) strtol(p->p, NULL, 10);
}
char *__as_string() {
    JSON_TOKEN *p = __g_last_token;
    if (!p || !p->p || !p->q) return NULL;
    if (p->str_buf) return p->str_buf;
    char *start;
    char *end;
    if (*(p->p) == '"') {
        start = p->p + 1;
        end = p->q;
    } else {
        start = p->p;
        end = p->q + 1;
    }
    size_type64 cap = (size_type64) (end - start) + 1;
    char *out = (char *) malloc(cap);
    if (!out) return NULL;
    char *dst = out;
    for (char *s = start; s < end; s++) {
        if (*s != '\\' || s + 1 >= end) {
            *dst++ = *s;
            continue;
        }
        s++;
        switch (*s) {
            case 'n': *dst++ = '\n';
                break;
            case 't': *dst++ = '\t';
                break;
            case 'r': *dst++ = '\r';
                break;
            case 'b': *dst++ = '\b';
                break;
            case 'f': *dst++ = '\f';
                break;
            case '"': *dst++ = '"';
                break;
            case '\\': *dst++ = '\\';
                break;
            case '/': *dst++ = '/';
                break;
            default: *dst++ = '\\';
                *dst++ = *s;
                break;
        }
    }
    *dst = '\0';
    p->str_buf = out;
    return out;
}
bool __as_bool() {
    JSON_TOKEN *p = __g_last_token;
    if (!p || !p->p) return false;
    return *(p->p) == 't';
}
double __as_double() {
    JSON_TOKEN *p = __g_last_token;
    if (!p || !p->p) return 0.0;
    return strtod(p->p, NULL);
}
bool __is_null() {
    JSON_TOKEN *p = __g_last_token;
    return p && p->p && *(p->p) == 'n';
}
static char *__parse_value(char *s, JSON_TOKEN *node);
static char *__skip_ws(char *s) {
    while (*s && isspace((unsigned char) *s)) s++;
    return s;
}
static char *__parse_string(char *s, JSON_TOKEN *node) {
    node->p = s;
    s++;
    while (*s && *s != '"') {
        if (*s == '\\' && *(s + 1)) s++;
        s++;
    }
    node->q = s;
    return (*s == '"') ? s + 1 : s;
}
static char *__parse_number(char *s, JSON_TOKEN *node) {
    node->p = s;
    if (*s == '-' || *s == '+') s++;
    while (*s && (isdigit((unsigned char) *s) || *s == '.' ||
                  *s == 'e' || *s == 'E' || *s == '+' || *s == '-')) {
        s++;
    }
    node->q = s - 1;
    return s;
}
static char *__parse_literal(char *s, JSON_TOKEN *node) {
    node->p = s;
    while (*s && isalpha((unsigned char) *s)) s++;
    node->q = s - 1;
    return s;
}
static char *parse_array(char *s, JSON_TOKEN *node) {
    node->p = s;
    s++;
    s = __skip_ws(s);
    JSON_TOKEN **tail = &node->children;
    if (*s == ']') {
        node->q = s;
        return s + 1;
    }
    while (*s) {
        JSON_TOKEN *child = (JSON_TOKEN *) calloc(1, sizeof(JSON_TOKEN));
        s = __parse_value(s, child);
        *tail = child;
        tail = &child->next;
        s = __skip_ws(s);
        if (*s == ',') {
            s++;
            s = __skip_ws(s);
        } else if (*s == ']') {
            node->q = s;
            return s + 1;
        } else break;
    }
    node->q = s;
    return s;
}
static char *__parse_object(char *s, JSON_TOKEN *node) {
    node->p = s;
    s++;
    s = __skip_ws(s);
    JSON_TOKEN **tail = &node->children;
    if (*s == '}') {
        node->q = s;
        return s + 1;
    }
    while (*s) {
        s = __skip_ws(s);
        if (*s != '"') break;
        s++;
        char *key_start = s;
        while (*s && *s != '"') {
            if (*s == '\\' && *(s + 1)) s++;
            s++;
        }
        char *key_end = s;
        if (*s == '"') s++;
        s = __skip_ws(s);
        if (*s != ':') break;
        s++;
        s = __skip_ws(s);
        JSON_TOKEN *child = (JSON_TOKEN *) calloc(1, sizeof(JSON_TOKEN));
        size_type64 klen = (size_type64) (key_end - key_start);
        if (klen > sizeof(child->key) - 1) klen = sizeof(child->key) - 1;
        memcpy(child->key, key_start, klen);
        child->key[klen] = '\0';
        s = __parse_value(s, child);
        *tail = child;
        tail = &child->next;
        s = __skip_ws(s);
        if (*s == ',') s++;
        else if (*s == '}') {
            node->q = s;
            return s + 1;
        } else break;
    }
    node->q = s;
    return s;
}
static char *__parse_value(char *s, JSON_TOKEN *node) {
    s = __skip_ws(s);
    if (*s == '{') return __parse_object(s, node);
    if (*s == '[') return parse_array(s, node);
    if (*s == '"') return __parse_string(s, node);
    if (*s == '-' || *s == '+' || isdigit((unsigned char) *s)) return __parse_number(s, node);
    if (isalpha((unsigned char) *s)) return __parse_literal(s, node);
    return s;
}
JSON_TOKEN *__parse(char *json_str) {
    JSON_TOKEN *root = (JSON_TOKEN *) calloc(1, sizeof(JSON_TOKEN));
    memset(root, 0, sizeof(JSON_TOKEN));
    __parse_value(json_str, root);
    bool iveb_init = false;
    if (iveb == NULL) {
        iveb = iveb_new();
        iveb_init = true;
    }
    iveb_insert(iveb, root, root, CT_JSON, 0, "json");
    if (iveb_init) {
        atexit(__opencstl_iveb_destroy);
    }
    return root;
}
JSON_TOKEN *__get(JSON_TOKEN *root, char *keys) {
    if (!root || !keys) return NULL;
    char buf[1024];
#ifdef _MSC_VER
    strncpy_s(buf, sizeof(buf), keys, _TRUNCATE);
#else
    strncpy(buf, keys, sizeof(buf) - 1);
    buf[sizeof(buf) - 1] = '\0';
#endif
    JSON_TOKEN *cur = root;
    char *ctx = NULL;
    char *tok = strtok_s(buf, ".", &ctx);
    while (tok && cur) {
        JSON_TOKEN *found = NULL;
        if (cur->p && *(cur->p) == '[') {
            int idx = atoi(tok);
            JSON_TOKEN *c = cur->children;
            for (int i = 0; c && i < idx; i++) c = c->next;
            found = c;
        } else {
            for (JSON_TOKEN *c = cur->children; c; c = c->next) {
                if (strcmp(c->key, tok) == 0) {
                    found = c;
                    break;
                }
            }
        }
        if (!found) return NULL;
        cur = found;
        tok = strtok_s(NULL, ".", &ctx);
    }
    __g_last_token = cur;
    cur->as_int = __as_int;
    cur->as_bool = __as_bool;
    cur->as_string = __as_string;
    cur->as_double = __as_double;
    cur->is_null = __is_null;
    return cur;
}
static void __free_subtree(JSON_TOKEN *node) {
    if (!node) return;
    JSON_TOKEN *c = node->children;
    while (c) {
        JSON_TOKEN *nx = c->next;
        __free_subtree(c);
        c = nx;
    }
    free(node->str_buf);
    free(node);
}
void __free_json(JSON *root) {
    if (!root) return;
    iveb_erase(iveb, root);
    JSON_TOKEN *c = root->children;
    while (c) {
        JSON_TOKEN *nx = c->next;
        __free_subtree(c);
        c = nx;
    }
    free(root->str_buf);
    root->str_buf = NULL;
    root->children = NULL;
    root->p = root->q = NULL;
    free(root);
}
static void __dumps(JSON_TOKEN *node, int depth) {
    if (!node || !node->p || !node->q) return;
    for (int i = 0; i < depth; i++) printf("  ");
    int len = (int) (node->q - node->p + 1);
    if (node->key[0]) printf("\"%s\": [%.*s]\n", node->key, len, node->p);
    else printf("[%.*s]\n", len, node->p);
    for (JSON_TOKEN *c = node->children; c; c = c->next) __dumps(c, depth + 1);
}
static void _dumps(JSON *root) {
    __dumps(root, 0);
}
typedef struct JSON_CLASS {
    JSON_TOKEN * (*parse)(char *json_str);
    JSON_TOKEN * (*get)(JSON_TOKEN *root, char *keys);
    void (*dumps)(JSON *root);
} JSON_CLASS;
JSON_CLASS json = {__parse, __get, _dumps};
#endif
#ifndef OPENCSTL_CSV_H
#define OPENCSTL_CSV_H
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct {
    char ***table;
    char **header;
    int rows;
    int cols;
} CSV;
static const char *csv__next_field(const char *p, const char *end,
                                   char *dst, size_t *out_len, int *eol) {
    size_t len = 0;
    *eol = 0;
    if (p >= end) {
        *out_len = 0;
        *eol = 1;
        return p;
    }
    if (*p == '"') {
        p++;
        while (p < end) {
            if (*p == '"') {
                if (p + 1 < end && *(p + 1) == '"') {
                    if (dst) dst[len] = '"';
                    len++;
                    p += 2;
                } else {
                    p++;
                    break;
                }
            } else {
                if (dst) dst[len] = *p;
                len++;
                p++;
            }
        }
    } else {
        while (p < end && *p != ',' && *p != '\r' && *p != '\n') {
            if (dst) dst[len] = *p;
            len++;
            p++;
        }
    }
    if (dst) dst[len] = '\0';
    *out_len = len;
    if (p >= end) { *eol = 1; } else if (*p == '\r') {
        p++;
        if (p < end && *p == '\n') p++;
        *eol = 1;
    } else if (*p == '\n') {
        p++;
        *eol = 1;
    } else if (*p == ',') { p++; }
    return p;
}
static CSV __parse_csv(char *csv_path, bool is_header) {
    CSV ret;
    ret.table = NULL;
    ret.header = NULL;
    ret.rows = 0;
    ret.cols = 0;
    FILE *f = file.open(csv_path, "rb");
    if (!f) return ret;
    fseek(f, 0, SEEK_END);
    long fsz = ftell(f);
    rewind(f);
    verify(fsz > 0);
    char *buf = (char *) malloc((size_t) fsz);
    verify(buf!=NULL);
    fread(buf, 1, (size_t) fsz, f);
    file.close(f);
    const char *end = buf + fsz;
    int total_rows = 0;
    int max_cols = 0;
    size_t str_bytes = 0;
    int row_cap = 64;
    int *row_cols = (int *) malloc(row_cap * sizeof(int));
    verify(row_cols!=NULL);
    const char *p = buf;
    while (p < end) {
        if (total_rows == row_cap) {
            row_cap *= 2;
            int *tmp = (int *) realloc(row_cols, row_cap * sizeof(int));
            verify(tmp!=NULL);
            row_cols = tmp;
        }
        int ncols = 0;
        int eol = 0;
        while (!eol) {
            size_t flen;
            const char *next = csv__next_field(p, end, NULL, &flen, &eol);
            if (next == p) goto done_pass1;
            str_bytes += flen + 1;
            ncols++;
            p = next;
        }
        if (ncols == 0) break;
        row_cols[total_rows++] = ncols;
        if (ncols > max_cols) max_cols = ncols;
    }
done_pass1:;
    for (int i = 0; i < total_rows; i++)
        if (row_cols[i] < max_cols)
            str_bytes += (size_t) (max_cols - row_cols[i]);
    int data_rows = is_header
                        ? (total_rows > 0 ? total_rows - 1 : 0)
                        : total_rows;
    size_t off1 = (size_t) data_rows * sizeof(char **);
    size_t off2 = (size_t) data_rows * (size_t) max_cols * sizeof(char *);
    size_t off3 = is_header ? (size_t) max_cols * sizeof(char *) : 0;
    char *mem = (char *) malloc(off1 + off2 + off3 + str_bytes);
    verify(mem!=NULL);
    char ***table = (char ***) mem;
    char **cells = (char **) (mem + off1);
    char **hdr = is_header ? (char **) (mem + off1 + off2) : NULL;
    char *sdata = mem + off1 + off2 + off3;
    for (int i = 0; i < data_rows; i++)
        table[i] = cells + i * max_cols;
    p = buf;
    char *sp = sdata;
    if (is_header && total_rows > 0) {
        int j = 0, eol = 0;
        while (!eol && j < row_cols[0]) {
            size_t flen;
            hdr[j] = sp;
            p = csv__next_field(p, end, sp, &flen, &eol);
            sp += flen + 1;
            j++;
        }
        for (; j < max_cols; j++) {
            hdr[j] = sp;
            *sp++ = '\0';
        }
    }
    int start = is_header ? 1 : 0;
    for (int i = start; i < total_rows; i++) {
        int di = i - start, j = 0, eol = 0;
        while (!eol && j < row_cols[i]) {
            size_t flen;
            table[di][j] = sp;
            p = csv__next_field(p, end, sp, &flen, &eol);
            sp += flen + 1;
            j++;
        }
        for (; j < max_cols; j++) {
            table[di][j] = sp;
            *sp++ = '\0';
        }
    }
    free(row_cols);
    free(buf);
    ret.table = table;
    ret.header = hdr;
    ret.rows = data_rows;
    ret.cols = max_cols;
    bool iveb_init = false;
    if (iveb == NULL) {
        iveb = iveb_new();
        iveb_init = true;
    }
    iveb_insert(iveb, table, table, CT_CSV, 0, "csv");
    if (iveb_init) {
        atexit(__opencstl_iveb_destroy);
    }
    return ret;
}
void __free_csv(CSV *csv) {
    iveb_erase(iveb, csv->table);
    free(csv->table);
    csv->table = NULL;
    csv->header = NULL;
    csv->rows = 0;
    csv->cols = 0;
}
typedef struct CSV_CLASS {
    CSV (*parse)(char *csv_path,bool is_header);
} CSV_CLASS;
CSV_CLASS csv = {
    __parse_csv
};
#endif
#if defined(OCSTL_C_VERSION_11) || defined(OCSTL_C_VERSION_17) || defined(OCSTL_C_VERSION_23)
#  define OCSTL_CSTLIO_DISPATCH_GENERIC 1
#elif defined(OCSTL_C_VERSION_99) && (defined(__GNUC__) || defined(__clang__))
#  define OCSTL_CSTLIO_DISPATCH_BUILTIN 1
#endif
#if defined(OCSTL_CSTLIO_DISPATCH_GENERIC) || defined(OCSTL_CSTLIO_DISPATCH_BUILTIN)
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>
#ifdef OCSTL_OS_WINDOWS
#if defined(OCSTL_CC_MSVC) || defined(OCSTL_CC_GCC)
#include <codecapi.h>
#include <processenv.h>
#else
#include <WinBase.h>
#endif
#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
#endif
#ifndef CP_UTF8
#define CP_UTF8 65001
#endif
static int s_cio_unicode_init = -1;
static void ocstl_ensure_unicode(void) {
    HANDLE h;
    DWORD mode = 0;
    if (s_cio_unicode_init != -1) return;
    SetConsoleOutputCP(CP_UTF8);
    h = GetStdHandle(STD_OUTPUT_HANDLE);
    if (GetConsoleMode(h, &mode))
        SetConsoleMode(h, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
    s_cio_unicode_init = 1;
}
#else
#define ocstl_ensure_unicode() ((void)0)
#endif
typedef enum {
    OCSTL_COUT_BOOL,
    OCSTL_COUT_SCHAR,
    OCSTL_COUT_UCHAR,
    OCSTL_COUT_SHORT,
    OCSTL_COUT_USHORT,
    OCSTL_COUT_INT,
    OCSTL_COUT_UINT,
    OCSTL_COUT_LONG,
    OCSTL_COUT_ULONG,
    OCSTL_COUT_LLONG,
    OCSTL_COUT_ULLONG,
    OCSTL_COUT_FLOAT,
    OCSTL_COUT_DOUBLE,
    OCSTL_COUT_CHAR,
    OCSTL_COUT_STR,
} ocstl_cout_type_t;
typedef struct {
    ocstl_cout_type_t type;
    union {
        _Bool b;
        signed char sc;
        unsigned char uc;
        short h;
        unsigned short uh;
        int i;
        unsigned int u;
        long l;
        unsigned long ul;
        long long ll;
        unsigned long long ull;
        float f;
        double d;
        char c;
        const char *s;
    };
} ocstl_val_t;
static ocstl_val_t ocstl_mk_bool(_Bool x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_BOOL;
    v.b = x;
    return v;
}
static ocstl_val_t ocstl_mk_schar(signed char x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_SCHAR;
    v.sc = x;
    return v;
}
static ocstl_val_t ocstl_mk_uchar(unsigned char x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_UCHAR;
    v.uc = x;
    return v;
}
static ocstl_val_t ocstl_mk_short(short x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_SHORT;
    v.h = x;
    return v;
}
static ocstl_val_t ocstl_mk_ushort(unsigned short x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_USHORT;
    v.uh = x;
    return v;
}
static ocstl_val_t ocstl_mk_int(int x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_INT;
    v.i = x;
    return v;
}
static ocstl_val_t ocstl_mk_uint(unsigned int x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_UINT;
    v.u = x;
    return v;
}
static ocstl_val_t ocstl_mk_long(long x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_LONG;
    v.l = x;
    return v;
}
static ocstl_val_t ocstl_mk_ulong(unsigned long x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_ULONG;
    v.ul = x;
    return v;
}
static ocstl_val_t ocstl_mk_llong(long long x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_LLONG;
    v.ll = x;
    return v;
}
static ocstl_val_t ocstl_mk_ullong(unsigned long long x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_ULLONG;
    v.ull = x;
    return v;
}
static ocstl_val_t ocstl_mk_float(float x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_FLOAT;
    v.f = x;
    return v;
}
static ocstl_val_t ocstl_mk_double(double x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_DOUBLE;
    v.d = x;
    return v;
}
static ocstl_val_t ocstl_mk_char(char x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_CHAR;
    v.c = x;
    return v;
}
static ocstl_val_t ocstl_mk_str(const char *x) {
    ocstl_val_t v;
    v.type = OCSTL_COUT_STR;
    v.s = x;
    return v;
}
#if defined(OCSTL_CSTLIO_DISPATCH_GENERIC)
#define OCSTL_VAL(x) _Generic((x),                  \
    _Bool:              ocstl_mk_bool,              \
    signed char:        ocstl_mk_schar,             \
    unsigned char:      ocstl_mk_uchar,             \
    short:              ocstl_mk_short,             \
    unsigned short:     ocstl_mk_ushort,            \
    int:                ocstl_mk_int,               \
    unsigned int:       ocstl_mk_uint,              \
    long:               ocstl_mk_long,              \
    unsigned long:      ocstl_mk_ulong,             \
    long long:          ocstl_mk_llong,             \
    unsigned long long: ocstl_mk_ullong,            \
    float:              ocstl_mk_float,             \
    double:             ocstl_mk_double,            \
    char:               ocstl_mk_char,              \
    char *:             ocstl_mk_str,               \
    const char *:       ocstl_mk_str                \
)(x)
#elif defined(OCSTL_CSTLIO_DISPATCH_BUILTIN)
#define OCSTL_TYPEEQ(x, T) __builtin_types_compatible_p(__typeof__(x), T)
#define OCSTL_AS(x, T)                                          \
    (*(T*)__builtin_choose_expr(OCSTL_TYPEEQ(x, T),             \
        (void*)&(__typeof__(x)){(x)},                           \
        (void*)0))
#define OCSTL_VAL(x)                                                                                                \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, _Bool),              ocstl_mk_bool  (OCSTL_AS(x, _Bool)),                 \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, signed char),        ocstl_mk_schar (OCSTL_AS(x, signed char)),           \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, unsigned char),      ocstl_mk_uchar (OCSTL_AS(x, unsigned char)),         \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, short),              ocstl_mk_short (OCSTL_AS(x, short)),                 \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, unsigned short),     ocstl_mk_ushort(OCSTL_AS(x, unsigned short)),        \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, int),                ocstl_mk_int   (OCSTL_AS(x, int)),                   \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, unsigned int),       ocstl_mk_uint  (OCSTL_AS(x, unsigned int)),          \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, long),               ocstl_mk_long  (OCSTL_AS(x, long)),                  \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, unsigned long),      ocstl_mk_ulong (OCSTL_AS(x, unsigned long)),         \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, long long),          ocstl_mk_llong (OCSTL_AS(x, long long)),             \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, unsigned long long), ocstl_mk_ullong(OCSTL_AS(x, unsigned long long)),    \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, float),              ocstl_mk_float (OCSTL_AS(x, float)),                 \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, double),             ocstl_mk_double(OCSTL_AS(x, double)),                \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, char),               ocstl_mk_char  (OCSTL_AS(x, char)),                  \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, char *),             ocstl_mk_str   (OCSTL_AS(x, char *)),                \
    __builtin_choose_expr(OCSTL_TYPEEQ(x, const char *),       ocstl_mk_str   (OCSTL_AS(x, const char *)),          \
        ocstl_mk_int(0)))))))))))))))))
#endif
#define OCSTL_MAP1(f,a)      f(a)
#define OCSTL_MAP2(f,a,...)  f(a), OCSTL_MAP1(f, __VA_ARGS__)
#define OCSTL_MAP3(f,a,...)  f(a), OCSTL_MAP2(f, __VA_ARGS__)
#define OCSTL_MAP4(f,a,...)  f(a), OCSTL_MAP3(f, __VA_ARGS__)
#define OCSTL_MAP5(f,a,...)  f(a), OCSTL_MAP4(f, __VA_ARGS__)
#define OCSTL_MAP6(f,a,...)  f(a), OCSTL_MAP5(f, __VA_ARGS__)
#define OCSTL_MAP7(f,a,...)  f(a), OCSTL_MAP6(f, __VA_ARGS__)
#define OCSTL_MAP8(f,a,...)  f(a), OCSTL_MAP7(f, __VA_ARGS__)
#define OCSTL_MAP9(f,a,...)  f(a), OCSTL_MAP8(f, __VA_ARGS__)
#define OCSTL_MAP10(f,a,...) f(a), OCSTL_MAP9(f, __VA_ARGS__)
#define OCSTL_MAP11(f,a,...) f(a), OCSTL_MAP10(f, __VA_ARGS__)
#define OCSTL_MAP12(f,a,...) f(a), OCSTL_MAP11(f, __VA_ARGS__)
#define OCSTL_MAP13(f,a,...) f(a), OCSTL_MAP12(f, __VA_ARGS__)
#define OCSTL_MAP14(f,a,...) f(a), OCSTL_MAP13(f, __VA_ARGS__)
#define OCSTL_MAP15(f,a,...) f(a), OCSTL_MAP14(f, __VA_ARGS__)
#define OCSTL_MAP16(f,a,...) f(a), OCSTL_MAP15(f, __VA_ARGS__)
#define OCSTL_MAP17(f,a,...) f(a), OCSTL_MAP16(f, __VA_ARGS__)
#define OCSTL_MAP18(f,a,...) f(a), OCSTL_MAP17(f, __VA_ARGS__)
#define OCSTL_MAP19(f,a,...) f(a), OCSTL_MAP18(f, __VA_ARGS__)
#define OCSTL_MAP20(f,a,...) f(a), OCSTL_MAP19(f, __VA_ARGS__)
#define OCSTL_MAP21(f,a,...) f(a), OCSTL_MAP20(f, __VA_ARGS__)
#define OCSTL_MAP22(f,a,...) f(a), OCSTL_MAP21(f, __VA_ARGS__)
#define OCSTL_MAP23(f,a,...) f(a), OCSTL_MAP22(f, __VA_ARGS__)
#define OCSTL_MAP24(f,a,...) f(a), OCSTL_MAP23(f, __VA_ARGS__)
#define OCSTL_MAP25(f,a,...) f(a), OCSTL_MAP24(f, __VA_ARGS__)
#define OCSTL_MAP26(f,a,...) f(a), OCSTL_MAP25(f, __VA_ARGS__)
#define OCSTL_MAP27(f,a,...) f(a), OCSTL_MAP26(f, __VA_ARGS__)
#define OCSTL_MAP28(f,a,...) f(a), OCSTL_MAP27(f, __VA_ARGS__)
#define OCSTL_MAP29(f,a,...) f(a), OCSTL_MAP28(f, __VA_ARGS__)
#define OCSTL_MAP30(f,a,...) f(a), OCSTL_MAP29(f, __VA_ARGS__)
#define OCSTL_MAP31(f,a,...) f(a), OCSTL_MAP30(f, __VA_ARGS__)
#define OCSTL_MAP32(f,a,...) f(a), OCSTL_MAP31(f, __VA_ARGS__)
#define OCSTL_MAP_SEL( \
    _1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16, \
    _17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32, N,...) \
    OCSTL_MAP##N
#define OCSTL_MAP(f,...) \
    OCSTL_MAP_SEL(__VA_ARGS__, \
        32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17, \
        16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1)(f, __VA_ARGS__)
typedef struct {
    char fill;
    char align;
    char sign;
    bool alt;
    bool zero_pad;
    int width;
    int precision;
    char type;
} ocstl_fmt_spec_t;
static void ocstl_spec_init(ocstl_fmt_spec_t *s) {
    s->fill = ' ';
    s->align = 0;
    s->sign = 0;
    s->alt = false;
    s->zero_pad = false;
    s->width = -1;
    s->precision = -1;
    s->type = 0;
}
static bool ocstl_is_align(char c) { return c == '<' || c == '>' || c == '^'; }
static const char *ocstl_parse_spec(const char *p, ocstl_fmt_spec_t *spec) {
    if (p[0] && p[1] && ocstl_is_align(p[1])) {
        spec->fill = p[0];
        spec->align = p[1];
        p += 2;
    } else if (ocstl_is_align(p[0])) {
        spec->align = p[0];
        p += 1;
    }
    if (*p == '+') {
        spec->sign = '+';
        p++;
    }
    if (*p == '#') {
        spec->alt = true;
        p++;
    }
    if (*p == '0') {
        spec->zero_pad = true;
        p++;
    }
    if (*p >= '0' && *p <= '9') {
        int w = 0;
        while (*p >= '0' && *p <= '9') {
            w = w * 10 + (*p - '0');
            p++;
        }
        spec->width = w;
    }
    if (*p == '.') {
        p++;
        int pr = 0;
        while (*p >= '0' && *p <= '9') {
            pr = pr * 10 + (*p - '0');
            p++;
        }
        spec->precision = pr;
    }
    if (*p && *p != '}') {
        spec->type = *p;
        p++;
    }
    return p;
}
static void ocstl_emit_pad(char ch, int n) {
    for (int i = 0; i < n; i++) putchar(ch);
}
static void ocstl_emit_padded(const char *core, int core_len,
                              const ocstl_fmt_spec_t *spec,
                              int sign_prefix_len) {
    int width = spec->width;
    if (width < 0 || width <= core_len) {
        fwrite(core, 1, core_len, stdout);
        return;
    }
    int pad = width - core_len;
    char align = spec->align;
    char fill = spec->fill;
    if (align == 0 && spec->zero_pad && sign_prefix_len >= 0) {
        fwrite(core, 1, sign_prefix_len, stdout);
        ocstl_emit_pad('0', pad);
        fwrite(core + sign_prefix_len, 1, core_len - sign_prefix_len, stdout);
        return;
    }
    if (align == 0) align = (sign_prefix_len >= 0) ? '>' : '<';
    if (align == '<') {
        fwrite(core, 1, core_len, stdout);
        ocstl_emit_pad(fill, pad);
    } else if (align == '>') {
        ocstl_emit_pad(fill, pad);
        fwrite(core, 1, core_len, stdout);
    } else {
        int left = pad / 2;
        int right = pad - left;
        ocstl_emit_pad(fill, left);
        fwrite(core, 1, core_len, stdout);
        ocstl_emit_pad(fill, right);
    }
}
static int ocstl_format_int(char *buf, int bufsz,
                            unsigned long long uval, bool negative,
                            const ocstl_fmt_spec_t *spec,
                            int *sign_prefix_len) {
    int base = 10;
    bool upper = false;
    const char *prefix = "";
    switch (spec->type) {
        case 'x': base = 16;
            break;
        case 'X': base = 16;
            upper = true;
            break;
        case 'o': base = 8;
            break;
        case 'b': base = 2;
            break;
        default: break;
    }
    if (spec->alt) {
        if (spec->type == 'x') prefix = "0x";
        else if (spec->type == 'X') prefix = "0X";
        else if (spec->type == 'b') prefix = "0b";
        else if (spec->type == 'o') prefix = "0o";
    }
    char tmp[80];
    int tlen = 0;
    if (uval == 0) tmp[tlen++] = '0';
    while (uval > 0) {
        unsigned digit = (unsigned) (uval % (unsigned long long) base);
        char c = (digit < 10)
                     ? (char) ('0' + digit)
                     : (char) ((upper ? 'A' : 'a') + (digit - 10));
        tmp[tlen++] = c;
        uval /= base;
    }
    int pos = 0;
    if (negative) buf[pos++] = '-';
    else if (spec->sign == '+' && base == 10) buf[pos++] = '+';
    int plen = (int) strlen(prefix);
    for (int i = 0; i < plen; i++) buf[pos++] = prefix[i];
    *sign_prefix_len = pos;
    for (int i = tlen - 1; i >= 0 && pos < bufsz - 1; i--) buf[pos++] = tmp[i];
    buf[pos] = '\0';
    return pos;
}
static int ocstl_format_float(char *buf, int bufsz, double dval,
                              const ocstl_fmt_spec_t *spec,
                              int *sign_prefix_len) {
    bool negative = dval < 0.0;
    if (negative) dval = -dval;
    int prec = spec->precision >= 0 ? spec->precision : 6;
    char fmt[16];
    char type = spec->type ? spec->type : 'f';
    if (type != 'f' && type != 'e' && type != 'E' && type != 'g' && type != 'G') type = 'f';
    snprintf(fmt, sizeof fmt, "%%.%d%c", prec, type);
    int pos = 0;
    if (negative) buf[pos++] = '-';
    else if (spec->sign == '+') buf[pos++] = '+';
    *sign_prefix_len = pos;
    int n = snprintf(buf + pos, bufsz - pos, fmt, dval);
    if (n < 0) n = 0;
    return pos + n;
}
static void ocstl_print_val(const ocstl_val_t *v, const ocstl_fmt_spec_t *spec) {
    char buf[128];
    int len = 0;
    int sign_prefix_len = -1;
    switch (v->type) {
        case OCSTL_COUT_BOOL:
            len = ocstl_format_int(buf, sizeof buf,
                                   (unsigned long long) v->b, false,
                                   spec, &sign_prefix_len);
            break;
        case OCSTL_COUT_SCHAR: {
            long long sv = v->sc;
            len = ocstl_format_int(buf, sizeof buf,
                                   (unsigned long long) (sv < 0 ? -sv : sv),
                                   sv < 0, spec, &sign_prefix_len);
            break;
        }
        case OCSTL_COUT_UCHAR:
            len = ocstl_format_int(buf, sizeof buf,
                                   (unsigned long long) v->uc, false,
                                   spec, &sign_prefix_len);
            break;
        case OCSTL_COUT_SHORT: {
            long long sv = v->h;
            len = ocstl_format_int(buf, sizeof buf,
                                   (unsigned long long) (sv < 0 ? -sv : sv),
                                   sv < 0, spec, &sign_prefix_len);
            break;
        }
        case OCSTL_COUT_USHORT:
            len = ocstl_format_int(buf, sizeof buf,
                                   (unsigned long long) v->uh, false,
                                   spec, &sign_prefix_len);
            break;
        case OCSTL_COUT_INT: {
            long long sv = v->i;
            len = ocstl_format_int(buf, sizeof buf,
                                   (unsigned long long) (sv < 0 ? -sv : sv),
                                   sv < 0, spec, &sign_prefix_len);
            break;
        }
        case OCSTL_COUT_LONG: {
            long long sv = v->l;
            len = ocstl_format_int(buf, sizeof buf,
                                   (unsigned long long) (sv < 0 ? -sv : sv),
                                   sv < 0, spec, &sign_prefix_len);
            break;
        }
        case OCSTL_COUT_LLONG: {
            long long sv = v->ll;
            len = ocstl_format_int(buf, sizeof buf,
                                   (unsigned long long) (sv < 0 ? -sv : sv),
                                   sv < 0, spec, &sign_prefix_len);
            break;
        }
        case OCSTL_COUT_UINT:
            len = ocstl_format_int(buf, sizeof buf, (unsigned long long) v->u, false, spec, &sign_prefix_len);
            break;
        case OCSTL_COUT_ULONG:
            len = ocstl_format_int(buf, sizeof buf, (unsigned long long) v->ul, false, spec, &sign_prefix_len);
            break;
        case OCSTL_COUT_ULLONG:
            len = ocstl_format_int(buf, sizeof buf, v->ull, false, spec, &sign_prefix_len);
            break;
        case OCSTL_COUT_FLOAT:
            len = ocstl_format_float(buf, sizeof buf, (double) v->f, spec, &sign_prefix_len);
            break;
        case OCSTL_COUT_DOUBLE:
            len = ocstl_format_float(buf, sizeof buf, v->d, spec, &sign_prefix_len);
            break;
        case OCSTL_COUT_CHAR: {
            buf[0] = v->c;
            buf[1] = '\0';
            len = 1;
            break;
        }
        case OCSTL_COUT_STR: {
            const char *s = v->s ? v->s : "(null)";
            ocstl_emit_padded(s, (int) strlen(s), spec, -1);
            return;
        }
    }
    ocstl_emit_padded(buf, len, spec, sign_prefix_len);
}
static void ocstl_print_impl(const char *fmt, const ocstl_val_t *args, int n) {
    int idx = 0;
    const char *p = fmt;
    ocstl_ensure_unicode();
    while (*p) {
        if (p[0] == '{' && p[1] == '{') {
            putchar('{');
            p += 2;
        } else if (p[0] == '}' && p[1] == '}') {
            putchar('}');
            p += 2;
        } else if (p[0] == '{') {
            const char *q = p + 1;
            ocstl_fmt_spec_t spec;
            ocstl_spec_init(&spec);
            if (*q == ':') {
                q = ocstl_parse_spec(q + 1, &spec);
            }
            if (*q == '}') {
                if (idx < n) ocstl_print_val(&args[idx++], &spec);
                p = q + 1;
            } else {
                putchar((unsigned char) *p++);
            }
        } else {
            putchar((unsigned char) *p++);
        }
    }
}
#define OCSTL_PRINT_N1(fmt) \
    do { ocstl_ensure_unicode(); ocstl_print_impl((fmt), NULL, 0); } while (0)
#define OCSTL_PRINT_1(fmt) OCSTL_PRINT_N1(fmt)
#define OCSTL_PRINT_2(fmt, _a) do {                                                       \
    ocstl_val_t _args[1];                                                                  \
    _args[0] = OCSTL_VAL(_a);                                                              \
    ocstl_print_impl((fmt), _args, 1);                                                     \
} while (0)
#define OCSTL_PRINT_3(fmt, _a, _b) do {                                                   \
    ocstl_val_t _args[2];                                                                  \
    _args[0] = OCSTL_VAL(_a); _args[1] = OCSTL_VAL(_b);                                    \
    ocstl_print_impl((fmt), _args, 2);                                                     \
} while (0)
#define OCSTL_PRINT_4(fmt, _a, _b, _c) do {                                               \
    ocstl_val_t _args[3];                                                                  \
    _args[0] = OCSTL_VAL(_a); _args[1] = OCSTL_VAL(_b); _args[2] = OCSTL_VAL(_c);          \
    ocstl_print_impl((fmt), _args, 3);                                                     \
} while (0)
#define OCSTL_PRINT_5(fmt, _a, _b, _c, _d) do {                                           \
    ocstl_val_t _args[4];                                                                  \
    _args[0] = OCSTL_VAL(_a); _args[1] = OCSTL_VAL(_b);                                    \
    _args[2] = OCSTL_VAL(_c); _args[3] = OCSTL_VAL(_d);                                    \
    ocstl_print_impl((fmt), _args, 4);                                                     \
} while (0)
#define OCSTL_PRINT_6(fmt, _a, _b, _c, _d, _e) do {                                       \
    ocstl_val_t _args[5];                                                                  \
    _args[0] = OCSTL_VAL(_a); _args[1] = OCSTL_VAL(_b);                                    \
    _args[2] = OCSTL_VAL(_c); _args[3] = OCSTL_VAL(_d); _args[4] = OCSTL_VAL(_e);          \
    ocstl_print_impl((fmt), _args, 5);                                                     \
} while (0)
#define OCSTL_PRINT_7(fmt, _a, _b, _c, _d, _e, _f) do {                                   \
    ocstl_val_t _args[6];                                                                  \
    _args[0] = OCSTL_VAL(_a); _args[1] = OCSTL_VAL(_b); _args[2] = OCSTL_VAL(_c);          \
    _args[3] = OCSTL_VAL(_d); _args[4] = OCSTL_VAL(_e); _args[5] = OCSTL_VAL(_f);          \
    ocstl_print_impl((fmt), _args, 6);                                                     \
} while (0)
#define OCSTL_PRINT_8(fmt, _a, _b, _c, _d, _e, _f, _g) do {                               \
    ocstl_val_t _args[7];                                                                  \
    _args[0] = OCSTL_VAL(_a); _args[1] = OCSTL_VAL(_b); _args[2] = OCSTL_VAL(_c);          \
    _args[3] = OCSTL_VAL(_d); _args[4] = OCSTL_VAL(_e); _args[5] = OCSTL_VAL(_f);          \
    _args[6] = OCSTL_VAL(_g);                                                              \
    ocstl_print_impl((fmt), _args, 7);                                                     \
} while (0)
#define OCSTL_PRINT_9(fmt, _a, _b, _c, _d, _e, _f, _g, _h) do {                           \
    ocstl_val_t _args[8];                                                                  \
    _args[0] = OCSTL_VAL(_a); _args[1] = OCSTL_VAL(_b); _args[2] = OCSTL_VAL(_c);          \
    _args[3] = OCSTL_VAL(_d); _args[4] = OCSTL_VAL(_e); _args[5] = OCSTL_VAL(_f);          \
    _args[6] = OCSTL_VAL(_g); _args[7] = OCSTL_VAL(_h);                                    \
    ocstl_print_impl((fmt), _args, 8);                                                     \
} while (0)
#define OCSTL_PRINT_10(fmt, _a, _b, _c, _d, _e, _f, _g, _h, _i) do {                      \
    ocstl_val_t _args[9];                                                                  \
    _args[0] = OCSTL_VAL(_a); _args[1] = OCSTL_VAL(_b); _args[2] = OCSTL_VAL(_c);          \
    _args[3] = OCSTL_VAL(_d); _args[4] = OCSTL_VAL(_e); _args[5] = OCSTL_VAL(_f);          \
    _args[6] = OCSTL_VAL(_g); _args[7] = OCSTL_VAL(_h); _args[8] = OCSTL_VAL(_i);          \
    ocstl_print_impl((fmt), _args, 9);                                                     \
} while (0)
#define OCSTL_PRINT_11(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_12(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_13(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_14(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_15(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_16(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_17(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_18(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_19(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_20(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_21(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_22(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_23(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_24(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_25(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_26(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_27(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_28(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_29(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_30(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_31(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PRINT_32(...) OCSTL_PRINT_NX(__VA_ARGS__)
#define OCSTL_PASTE2(a, b) a##b
#define OCSTL_PASTE(a, b)  OCSTL_PASTE2(a, b)
#define print(...)   OCSTL_PASTE(OCSTL_PRINT_, ARGN(__VA_ARGS__))(__VA_ARGS__)
#define println(...) do { print(__VA_ARGS__); putchar('\n'); } while (0)
#endif
#ifndef print
#define print(...)   __noop
#pragma message("warning: print/println is not defined in MSVC C99; use /std:c11 or newer")
#endif
#ifndef println
#define println(...) __noop
#endif
#define ARRAY(TYPE)             TYPE*
#define VECTOR(TYPE)            TYPE*
#define LIST(TYPE)              TYPE**
#define SET(TYPE)               TYPE**
#define MAP(TYPE)               TYPE**
#define DEQUE(TYPE)             TYPE*
#define STACK(TYPE)             TYPE*
#define QUEUE(TYPE)             TYPE*
#define UNORDERED_SET(TYPE)     TYPE*
#define UNORDERED_MAP(TYPE)     TYPE*
#if defined(USE_CSTL_FUNC)
#define push_back       cstl_push_back
#define pop_back        cstl_pop_back
#define push_front      cstl_push_front
#define pop_front       cstl_pop_front
#define push            cstl_push
#define pop             cstl_pop
#define insert          cstl_insert
#define erase           cstl_erase
#define resize          cstl_resize
#define assign          cstl_assign
#define find            cstl_find
#if defined(OPENCSTL_USE_LENGTH)
#define length          cstl_size
#else
#define size            cstl_size
#define empty           cstl_empty
#define clear           cstl_clear
#define destroy         cstl_free
#define top             cstl_top
#define front           cstl_front
#define back            cstl_back
#define reserve         cstl_reserve
#define max_size        cstl_max_size
#define shrink_to_fit   cstl_shrink_to_fit
#define capacity        cstl_capacity
#endif
#define next            cstl_next
#define prev            cstl_prev
#define begin           cstl_begin
#define end             cstl_end
#define rbegin          cstl_rbegin
#define rend            cstl_rend
#define count_if        cstl_count_if
#define lower_bound     cstl_lower_bound
#define upper_bound     cstl_upper_bound
#define new_deque           cstl_deque
#define new_list            cstl_list
#define new_stack           cstl_stack
#define new_queue           cstl_queue
#define new_unordered_set   cstl_unordered_set
#define new_unordered_map   cstl_unordered_map
#define new_deque           cstl_deque
#define new_vector          cstl_vector
#define new_set             cstl_set
#define new_map             cstl_map
#define new_priority_queue  cstl_priority_queue
#endif
OPENCSTL_FUNC void _cstl_assign(void *container, int argc, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, argc, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
    void *param2 = __cstl_va_arg_next(vl);
    void *param3 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
    void *param2 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 1);
    void *param3 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 2);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            if (argc >= 3) {
                fault("Not implemented");
            } else {
                if (argc == 1) {
                    param2 = NULL;
                }
                __cstl_vector_assign((void **) container, *(int *) param1, param2);
            }
        }
        break;
        case OPENCSTL_LIST: {
        }
        break;
        case OPENCSTL_DEQUE: {
            if (argc == 1)param2 = NULL;
            __cstl_deque_assign((void **) container, *(int *) param1, param2);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    __cstl_va_end(vl);
}
OPENCSTL_FUNC void _cstl_push(void *container, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, container, va_ptr);
#if CSTL_USE_VAARG
    void *value = __cstl_va_arg_next(vl);
#else
    void *value = __cstl_va_arg(va_ptr);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_STACK:
        case OPENCSTL_QUEUE: {
            __cstl_deque_push_back((void **) container, value);
        }
        break;
        case OPENCSTL_PRIORITY_QUEUE: {
            __cstl_priority_queue_push((void **) container, value);
        }
        break;
        default: fault("Invalid operator");
            break;
    }
    __cstl_va_end(vl);
}
OPENCSTL_FUNC void _cstl_push_back(void *container, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, container, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            __cstl_vector_push_back((void **) container, param1);
        }
        break;
        case OPENCSTL_LIST: {
            __cstl_list_push_back_front((void **) container, param1, -1, 0);
        }
        break;
        case OPENCSTL_DEQUE: {
            __cstl_deque_push_back((void **) container, param1);
        }
        break;
        default: fault("Invalid operator");
            break;
    }
    __cstl_va_end(vl);
}
OPENCSTL_FUNC void _cstl_push_front(void *container, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, container, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_LIST: {
            __cstl_list_push_back_front((void **) container, param1, 0, -1);
        }
        break;
        case OPENCSTL_DEQUE: {
            __cstl_deque_push_front((void **) container, param1);
        }
        break;
        default: fault("Invalid operator");
            break;
    }
    __cstl_va_end(vl);
}
OPENCSTL_FUNC void _cstl_pop(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_STACK: {
            __cstl_deque_pop_back((void **) container);
        }
        break;
        case OPENCSTL_QUEUE: {
            __cstl_deque_pop_front((void **) container);
        }
        break;
        case OPENCSTL_PRIORITY_QUEUE: {
            __cstl_priority_queue_pop((void **) container);
        }
        break;
        default: fault("Invalid operator");
            break;
    }
}
OPENCSTL_FUNC void _cstl_pop_back(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            __cstl_vector_pop_back((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            __cstl_list_pop_back_front((void **) container, -1, 0);
        }
        break;
        case OPENCSTL_DEQUE: {
            __cstl_deque_pop_back((void **) container);
        }
        break;
    }
}
OPENCSTL_FUNC size_type _cstl_max_size(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_type sz = 0;
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            sz = __cstl_array_max_size((void **) container);
        }
        break;
        case OPENCSTL_VECTOR: {
            sz = __cstl_vector_max_size((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            sz = __cstl_list_max_size((void **) container);
        }
        break;
        case OPENCSTL_DEQUE: {
            sz = __cstl_deque_max_size((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            sz = __cstl_hashtable_capacity((void **) container);
        }
        break;
        default: {
            fault("Invalid operator");
        }
    }
    return sz;
}
OPENCSTL_FUNC void _cstl_pop_front(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_LIST: {
            __cstl_list_pop_back_front((void **) container, 0, -1);
        }
        break;
        case OPENCSTL_DEQUE: {
            __cstl_deque_pop_front((void **) container);
        }
        break;
    }
}
OPENCSTL_FUNC size_type _cstl_size(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_type sz = 0;
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            sz = __cstl_array_size((void **) container);
        }
        break;
        case OPENCSTL_PRIORITY_QUEUE:
        case OPENCSTL_VECTOR: {
            sz = __cstl_vector_size((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            sz = __cstl_list_size((void **) container);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            sz = __cstl_tree_size((void **) container);
        }
        break;
        case OPENCSTL_DEQUE: {
            sz = __cstl_deque_size((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            sz = __cstl_hashtable_size((void **) container);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    return sz;
}
OPENCSTL_FUNC size_type _cstl_capacity(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_type sz = 0;
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            sz = __cstl_array_capacity((void **) container);
        }
        break;
        case OPENCSTL_STACK:
        case OPENCSTL_QUEUE:
        case OPENCSTL_PRIORITY_QUEUE:
        case OPENCSTL_VECTOR: {
            sz = __cstl_vector_capacity((void **) container);
        }
        break;
        case OPENCSTL_DEQUE: {
            sz = __cstl_deque_capacity((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            sz = __cstl_hashtable_capacity((void **) container);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    return sz;
}
OPENCSTL_FUNC void _cstl_insert(void *container, int argc, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, argc, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
    void *param2 = __cstl_va_arg_next(vl);
    void *param3 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
    void *param2 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 1);
    void *param3 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 2);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            if (argc == 2)__cstl_vector_insert((void **) container, param1, 1, param2);
            else __cstl_vector_insert((void **) container, param1, *(int *) param2, param3);
        }
        break;
        case OPENCSTL_LIST: {
            if (argc == 2)__cstl_list_insert((void **) container, (void **) param1, 1, param2);
            else __cstl_list_insert((void **) container, (void **) param1, *(int *) param2, param3);
        }
        break;
        case OPENCSTL_DEQUE: {
            if (argc == 2)__cstl_deque_insert((void **) container, param1, 1, param2);
            else __cstl_deque_insert((void **) container, param1, *(int *) param2, param3);
        }
        break;
        case OPENCSTL_MAP: {
            if (argc == 2) __cstl_tree_insert((void **) container, param1, param2);
            else
                fault("Invalid operation");
        }
        break;
        case OPENCSTL_SET: {
            if (argc == 1) __cstl_tree_insert((void **) container, param1,NULL);
            else
                fault("Invalid operation");
        }
        break;
        case OPENCSTL_UNORDERED_MAP: {
            if (argc == 2)__cstl_hashtable_insert((void **) container, param1, param2);
            else
                fault("Invalid operation");
        }
        break;
        case OPENCSTL_UNORDERED_SET: {
            if (argc == 1) {
                __cstl_hashtable_insert((void **) container, param1,NULL);
            } else
                fault("Invalid operation");
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    __cstl_va_end(vl);
}
OPENCSTL_FUNC void _cstl_erase(void *container, int argc, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, argc, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
    void *param2 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
    void *param2 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 1);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            if (argc == 1) {
                param2 = (*(char **) param1) + OPENCSTL_NIDX((void**)container, NIDX_TSIZE);
                __cstl_vector_erase((void **) container, param1, &param2);
            } else __cstl_vector_erase((void **) container, param1, param2);
        }
        break;
        case OPENCSTL_LIST: {
            if (argc == 1) {
                param2 = cstl_next(*(void**)param1);
                __cstl_list_erase((void **) container, (void **) param1, (void **) &param2);
            } else __cstl_list_erase((void **) container, (void **) param1, (void **) param2);
        }
        break;
        case OPENCSTL_DEQUE: {
            if (argc == 1) {
                param2 = (*(char **) param1) + OPENCSTL_NIDX((void**)container,
                                                             NIDX_TSIZE + (ptrdiff_t)OPENCSTL_NIDX(((void**)container),
                                                                 -1) + 1);
                __cstl_deque_erase((void **) container, param1, &param2);
            } else __cstl_deque_erase((void **) container, param1, param2);
        }
        break;
        case OPENCSTL_MAP:
        case OPENCSTL_SET: {
            __cstl_tree_erase((void **) container, (void **) *(void **) param1);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            __cstl_hashtable_erase((void **) container, *(void **) param1);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    __cstl_va_end(vl);
}
OPENCSTL_FUNC void _cstl_resize(void *container, int argc, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, argc, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
    void *param2 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
    void *param2 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 1);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            if (argc == 1)param2 = NULL;
            __cstl_vector_resize((void **) container, *(int *) param1, param2);
        }
        break;
        case OPENCSTL_LIST: {
            if (argc == 1)param2 = NULL;
            __cstl_list_resize((void **) container, *(int *) param1, param2);
        }
        break;
        case OPENCSTL_DEQUE: {
            if (argc == 1)param2 = NULL;
            __cstl_deque_resize((void **) container, *(int *) param1, &param2);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
    __cstl_va_end(vl);
}
OPENCSTL_FUNC void _cstl_clear(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            __cstl_vector_clear((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            __cstl_list_clear((void **) container);
        }
        break;
        case OPENCSTL_STACK:
        case OPENCSTL_QUEUE:
        case OPENCSTL_DEQUE: {
            __cstl_deque_clear((void **) container);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            __cstl_tree_clear((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            __cstl_hashtable_clear((void **) container);
        }
        break;
        default: {
            fault("Invalid operation");
        }
        break;
    }
}
OPENCSTL_FUNC bool _cstl_empty(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_type64 sz = 0;
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            sz = __cstl_array_size((void **) container);
        }
        break;
        case OPENCSTL_PRIORITY_QUEUE:
        case OPENCSTL_VECTOR: {
            sz = __cstl_vector_size((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            sz = __cstl_list_size((void **) container);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            sz = __cstl_tree_size((void **) container);
        }
        break;
        case OPENCSTL_STACK:
        case OPENCSTL_QUEUE:
        case OPENCSTL_DEQUE: {
            sz = __cstl_deque_size((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            sz = __cstl_hashtable_size((void **) container);
        }
        break;
        default: {
            fault("Invalid operation");
        };
    }
    return sz ? false : true;
}
OPENCSTL_FUNC void _cstl_free(void *container) {
    void **tmp = (void **) container;
    if (iveb != NULL) {
        BITSET *bs = (BITSET *) container;
        Interval *iv_bs = iveb_find(iveb, bs->bits);
        if (iv_bs != NULL && iv_bs->ctype == CT_BITSET) {
            __cstl_bitset_free(*bs);
            goto _BYE_;
        }
        Interval *iv = iveb_find(iveb, *tmp);
        if (iv != NULL) {
            if (iv->ctype == CT_JSON) {
                __free_json((JSON *) *tmp);
                goto _BYE_;
            } else if (iv->ctype == CT_GLOB) {
                __glob_free(*tmp);
                goto _BYE_;
            } else if (iv->ctype == CT_CSV) {
                __free_csv((CSV *) tmp);
                goto _BYE_;
            }
        }
    }
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            __cstl_array_free((void **) container);
        }
        break;
        case OPENCSTL_VECTOR: {
            __cstl_vector_free((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            __cstl_list_free((void **) container);
        }
        break;
        case OPENCSTL_STACK:
        case OPENCSTL_QUEUE:
        case OPENCSTL_DEQUE: {
            __cstl_deque_free((void **) container);
        }
        break;
        case OPENCSTL_SET:
        case OPENCSTL_MAP: {
            __cstl_tree_free((void **) container);
        }
        break;
        case OPENCSTL_PRIORITY_QUEUE: {
            __cstl_vector_free((void **) container);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            __cstl_hashtable_free((void **) container);
        }
        break;
        default: fault("Invalid operation");
            break;
    }
_BYE_:
    return;
}
OPENCSTL_FUNC void *_cstl_find(void *container, int argc, ...) {
    va_list vl;
    void *va_ptr = NULL;
    __cstl_va_start(vl, argc, va_ptr);
#if CSTL_USE_VAARG
    void *param1 = __cstl_va_arg_next(vl);
    void *param2 = __cstl_va_arg_next(vl);
#else
    void *param1 = __cstl_va_arg(va_ptr);
    void *param2 = __cstl_va_arg((char *) va_ptr + sizeof(void *) * 1);
#endif
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            if (argc == 1) return __cstl_array_find((void **) container, (void **) container, param2);
            else return __cstl_array_find((void **) container, param1, param2);
        }
        break;
        case OPENCSTL_VECTOR: {
            if (argc == 1) return __cstl_vector_find((void **) container, container, param1);
            else return __cstl_vector_find((void **) container, param1, param2);
        }
        break;
        case OPENCSTL_LIST: {
            if (argc == 1)
                return __cstl_list_find((void **) container, (void **) &OPENCSTL_NIDX((void**)container, 0),
                                        param1);
            else return __cstl_list_find((void **) container, (void **) param1, param2);
        }
        break;
        case OPENCSTL_DEQUE: {
            if (argc == 1) return __cstl_deque_find((void **) container, container, param1);
            else return __cstl_deque_find((void **) container, param1, param2);
        }
        break;
        case OPENCSTL_MAP:
        case OPENCSTL_SET: {
            return __cstl_tree_find((void **) container, param1);
        }
        break;
        case OPENCSTL_UNORDERED_SET:
        case OPENCSTL_UNORDERED_MAP: {
            return __cstl_hashtable_find((void **) container, param1);
        }
        break;
        default: fault("Invalid operator");
            break;
    }
    __cstl_va_end(vl);
    return NULL;
}
OPENCSTL_FUNC void _cstl_shrink_to_fit(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            __cstl_vector_shrink_to_fit((void **) container);
        }
        break;
        case OPENCSTL_DEQUE: {
            __cstl_deque_shrink_to_fit((void **) container);
        }
        break;
        default: {
            fault("Invalid operation");
        }
        break;
    }
}
OPENCSTL_FUNC void _cstl_reverse(void *container) {
    size_type64 container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(_opencstl_ll_ua *) ((char *) *(void **) container + (ptrdiff_t) NIDX_CTYPE * (ptrdiff_t) sizeof(size_type64) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_ARRAY: {
            __cstl_array_reverse((void **) container);
        }
        break;
        case OPENCSTL_VECTOR: {
            __cstl_vector_reverse((void **) container);
        }
        break;
        case OPENCSTL_DEQUE: {
            __cstl_deque_reverse((void **) container);
        }
        break;
        case OPENCSTL_LIST: {
            __cstl_list_reverse((void **) container);
        }
        break;
        default: {
            fault("Invalid operation");
        }
        break;
    }
}
static void reverse(void *container) {
    _cstl_reverse((void **) &container);
}
#if defined(__linux__) || defined(__APPLE__)
#if defined(OCSTL_CC_CLANG)
#pragma clang diagnostic pop
#if !defined(OCSTL_CC_CLANG)
#pragma clang diagnostic ignored "-Wgnu-auto-type"
#pragma clang diagnostic ignored "-Wgnu-statement-expression-from-macro-expansion"
#pragma clang diagnostic ignored "-Wvariadic-macro-arguments-omitted"
#endif
#endif
#if defined(OCSTL_CC_GCC)
#pragma GCC diagnostic pop
#pragma GCC diagnostic ignored "-Wpedantic"
#endif
#endif
#if defined(__cplusplus)
}
#endif
#endif // _OPENCSTL_AMALGAMATED_H