opencstl.h

//
// ============================================================================
//  OpenCSTL — Single-Header Amalgamation
//  Auto-generated by amalgamate.py  (do NOT edit manually)
//
//  Copyright (C) 2018-2026, Kim Bomm, all rights reserved.
//  Licensed under the OpenCSTL License Agreement.
// ============================================================================
//

#pragma once
#ifndef _OPENCSTL_AMALGAMATED_H
#define _OPENCSTL_AMALGAMATED_H

// ── System includes — unconditional, deduplicated ─────────────────────
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>


// ==============================================================================
// BEGIN  opencstl.h                     (depth 0)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2018-2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if defined(__cplusplus)
extern "C" {



#endif

// ==============================================================================
// BEGIN  zalloc.h                       (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or
#if !defined(_OPENCSTL_ZALLOC_H)
#define _OPENCSTL_ZALLOC_H
#include <stdlib.h>

// ==============================================================================
// BEGIN  tracer.h                       (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//

#ifndef OPENCSTL_TRACER_H
#define OPENCSTL_TRACER_H
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// ==============================================================================
// BEGIN  logging.h                      (depth 3)
// ==============================================================================




// ==============================================================================
// BEGIN  crossplatform.h                (depth 4)
// ==============================================================================

//
// Created by spring on 2026. 4. 11..
//
#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 //_OPENCSTL_CROSSPLATFORM_H

// ==============================================================================
// END    crossplatform.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 *__white = "\033[37m";
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;
    //if (color == __white) return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
    return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
}

#endif // OCSTL_OS_WINDOWS

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

static char *__vcsprintf(const char *format, ...) {
    static char buf[1024] = {0};
    va_list args;
    va_start(args, format);
    vsprintf(buf, format, args);
    va_end(args);
    return buf;
}

#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];
    // zenity ?놁쑝硫?kdialog, ?????놁쑝硫?stderr
    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);
    // __fatal_message_box(ret);
    // exit(EXIT_FAILURE);
    return ret;
}

// static int _logging_message(const char *format, ...) {
//     va_list args;
//     int ret;
//     va_start(args, format);
//     ret = __vcprintln(__white, 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_fn message;
} LOGGING;

static const LOGGING logging = {
    _logging_debug,
    _logging_info,
    _logging_warning,
    _logging_error,
    _logging_critical,
    _logging_fatal,
    //_logging_message
};


// ==============================================================================
// END    logging.h
// ==============================================================================
//#include "van_emde_boas_tree.h"
#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};
//void *zalloc_vector[_512KB] = {0};
size_t zalloc_size = 0;
size_t zalloc_count = 0;

static void zinsert(void *ptr, char *file, char *func, int line) {
    zmem[zalloc_size].ptr = ptr;
    zmem[zalloc_size].file = file;
    zmem[zalloc_size].func = func;
    zmem[zalloc_size].line = line;
    zalloc_size++;
    zalloc_count++;
}

static void zremove(void *ptr) {
    for (size_t i = 0; i < zalloc_size; i++) {
        if (zmem[i].ptr == ptr) {
            memcpy(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;
        }
    }
}

// static void zappend(void *ptr) {
//     zalloc_vector[zalloc_size++] = ptr;
//     zalloc_count++;
// }
//
// static void zerase(void *ptr) {
//     for (size_t i = 0; i < zalloc_size; i++) {
//         if (zalloc_vector[i] == ptr) {
//             memcpy(zalloc_vector + i, zalloc_vector + i + 1, (zalloc_size - i - 1) * sizeof(void *));
//             zalloc_size--;
//             zalloc_vector[zalloc_size] = NULL;
//             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_t 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) {
    //size_t SZ = _512KB;
    //zalloc_vector = salloc(SZ);
    //memset(zalloc_vector, 0, SZ);

    logging.debug("OpenCSTL tracer start");

    //htm = htm_new();

    //mt19937.seed(time(NULL));
    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

// ==============================================================================
// END    tracer.h
// ==============================================================================


#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_t cnt, size_t sz, char *file, char *func, int line) {
    void *ptr = ocalloc(cnt, sz);
    if (ptr) {
        zinsert(ptr, file, func, line);
    }
    return ptr;
}


static void *_zmalloc(size_t sz, char *file, char *func, int line) {
    void *ptr = omalloc(sz);
    if (ptr) {
        zinsert(ptr, file, func, line);
    }
    return ptr;
}


static void *_zrealloc(void *ptr, size_t new_size, char *file, 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 //_OPENCSTL_ZALLOC_H

// ==============================================================================
// END    zalloc.h
// ==============================================================================

// [already included: tracer.h]
// [already included: zalloc.h]
// [already included: crossplatform.h]

#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 "-Wuse-after-free"

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


#define USE_CSTL_FUNC

// #if defined(__linux__) || defined(__APPLE__)
// #if !defined(__8cc__ )
// #pragma GCC push_options
// #pragma GCC optimize("O0")
// #endif
// #endif
// [already included: zalloc.h]

// ==============================================================================
// BEGIN  string.h                       (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//

#ifndef OPENCSTL_STRING_H
#define OPENCSTL_STRING_H

// [already included: zalloc.h]

// ==============================================================================
// BEGIN  verify.h                       (depth 2)
// ==============================================================================

//
// Created by spring on 4/15/2026.
//

#ifndef OPENCSTL_VERIFY_H
#define OPENCSTL_VERIFY_H
#include <assert.h>
// [already included: logging.h]

#define verify(EXPR) do { if(!(EXPR)) __verify(#EXPR,__FILE__,__LINE__); } while(0)

int __verify(char *expression, char *file, int line) {
    logging.error("Verification failed: %s, file %s, line %d",
                  expression, file, line);
    abort();
}

#define yikes(STR) _yikes(STR,__FILE__,__LINE__)

void _yikes(char *str, char *file, int line) {
    logging.error("Mistake failed: %s, file %s, line %d");
}
#endif //OPENCSTL_VERIFY_H

// ==============================================================================
// END    verify.h
// ==============================================================================
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdbool.h>
// ============================================================
// string function implementations
// ============================================================

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

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

    // separator 개수 세기
    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;
}


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

char *__cstl_string_ltrim(const char *src) {
    const char *p = src;
    while (*p && isspace((unsigned char) *p)) p++;
    size_t len = strlen(p);
    char *ret = (char *) malloc(len + 1);
    memcpy(ret, p, len + 1);
    return ret;
}

char *__cstl_string_rtrim(const char *src) {
    size_t 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;
}

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_t len = end - begin;
    char *ret = (char *) malloc(len + 1);
    memcpy(ret, begin, len);
    ret[len] = '\0';
    return ret;
}

char *__cstl_string_to_upper(const char *src) {
    size_t len = strlen(src);
    char *ret = (char *) malloc(len + 1);
    for (size_t i = 0; i < len; i++) ret[i] = (char) toupper((unsigned char) src[i]);
    ret[len] = '\0';
    return ret;
}

char *__cstl_string_to_lower(const char *src) {
    size_t len = strlen(src);
    char *ret = (char *) malloc(len + 1);
    for (size_t i = 0; i < len; i++) ret[i] = (char) tolower((unsigned char) src[i]);
    ret[len] = '\0';
    return ret;
}

bool __cstl_string_starts_with(const char *src, const char *prefix) {
    size_t plen = strlen(prefix);
    return strncmp(src, prefix, plen) == 0;
}

bool __cstl_string_ends_with(const char *src, const char *suffix) {
    size_t slen = strlen(src);
    size_t flen = strlen(suffix);
    if (flen > slen) return false;
    return memcmp(src + slen - flen, suffix, flen) == 0;
}

int __cstl_string_count(const char *src, const char *sub) {
    int count = 0;
    size_t 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;
}

char *__cstl_string_join(char **parts, int n, const char *delim) {
    if (n <= 0) {
        char *empty = (char *) malloc(1);
        *empty = '\0';
        return empty;
    }
    size_t dlen = strlen(delim);
    size_t 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_t len = strlen(parts[i]);
        memcpy(dst, parts[i], len);
        dst += len;
    }
    *dst = '\0';
    return ret;
}

char *__cstl_string_concat(const char *a, const char *b) {
    size_t alen = strlen(a);
    size_t blen = strlen(b);
    char *ret = (char *) malloc(alen + blen + 1);
    memcpy(ret, a, alen);
    memcpy(ret + alen, b, blen + 1);
    return ret;
}

char *__cstl_string_reverse(const char *src) {
    size_t len = strlen(src);
    char *ret = (char *) malloc(len + 1);
    for (size_t i = 0; i < len; i++) ret[i] = src[len - 1 - i];
    ret[len] = '\0';
    return ret;
}

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

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

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

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

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_t n = strlen(src);
    size_t m = strlen(pattern);

    // 빈 패턴 또는 패턴이 원본보다 긴 경우
    if (m == 0 || n < m) {
        return NULL;
    }

    // LPS 테이블 생성
    int *lps = (int *) malloc(sizeof(int) * m);
    if (lps == NULL) return NULL;

    lps[0] = 0;
    size_t len = 0;
    size_t 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++;
            }
        }
    }

    // 매칭 위치 버퍼 (인덱스 0부터 저장)
    size_t capacity = 16;
    int *matches = (int *) malloc(sizeof(int) * capacity);
    if (matches == NULL) {
        free(lps);
        return NULL;
    }

    size_t match_count = 0;
    size_t 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;

    // 매칭 0개면 NULL 반환 (caller가 free 안 하도록)
    if (match_count == 0) {
        free(matches);
        return NULL;
    }

    // 실제 크기로 축소 (실패해도 matches는 유효)
    int *result = (int *) realloc(matches, sizeof(int) * match_count);
    return (result != NULL) ? result : matches;
}

// ============================================================
// function pointer types
// ============================================================
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);

// ============================================================
// string namespace struct
// ============================================================
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;
    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 //OPENCSTL_STRING_H

// ==============================================================================
// END    string.h
// ==============================================================================

// Contaner

// ==============================================================================
// BEGIN  deque.h                        (depth 1)
// ==============================================================================

//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2018-2026, Kim Bomm, Woo Cheol, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_DEQUE_H)
#define _OPENCSTL_DEQUE_H

// [already included: zalloc.h]

// ==============================================================================
// BEGIN  van_emde_boas_tree.h           (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//

#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_t 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_t oc = h->cap;
    HMEntry *oe = h->e;
    h->cap = oc * 2;
    h->e = (HMEntry *) calloc(h->cap, sizeof(HMEntry));
    h->size = 0;
    for (size_t 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_t i = (size_t) (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_t i = (size_t) (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_t i = (size_t) (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_t 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_t 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;
    }

    // x가 현재 min보다 작으면 교환해 min 갱신
    // (min은 클러스터에 저장하지 않으므로 재귀 불필요)
    if (x < v->min) {
        u64 t = v->min;
        v->min = x;
        x = t;
    }

    // bits==1: universe {0,1}, 클러스터 없이 min/max로 처리
    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);
    // 클러스터가 비어있었으면 summary에 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) {
    // 원소가 1개뿐이면 바로 비움
    if (v->min == v->max) {
        v->min = v->max = VEB_EMPTY;
        return;
    }

    // bits==1: {0,1} 중 하나 제거
    if (v->bits == 1) {
        v->min = v->max = (x == 0) ? 1 : 0;
        return;
    }

    if (x == v->min) {
        // min 제거: 다음 최솟값을 클러스터에서 꺼내 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)) {
        // 클러스터가 비면 해제하고 summary에서도 제거
        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;
    // bits==1: x==1, v->min==0 임이 보장됨
    if (v->bits == 1) return 0;

    u64 h = vhi(x, v->bits), l = vlo(x, v->bits);
    VEB *c = cls_get(v, h);

    // 같은 클러스터 내에 l보다 작은 원소가 있으면 그것을 반환
    if (c && !veb_empty(c) && l > c->min)
        return vidx(h, veb_pred(c, l), v->bits);

    // 이전 클러스터(summary 기준으로 h 미만)의 최댓값을 반환
    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;
    // pred(x+1) = x 이하의 최댓값
    // x < max 이므로 x+1 이 VEB_EMPTY 로 오버플로되지 않음
    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,
} CONTAINER_TYPE;

typedef struct {
    void *a; // 구간 시작 (inclusive)
    void *b; // 구간 끝   (inclusive)
    CONTAINER_TYPE ctype;
    size_t 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;

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_t 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_t 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_t 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) {
    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;
}

static IntervalVEB *iveb = NULL;
static HTMVEB *htm = NULL;

void __opencstl_iveb_destroy(void) {
    iveb_free(iveb);
}
#endif //_OPENCSTL_VAN_EMDE_BOAS_TREE_H

// ==============================================================================
// END    van_emde_boas_tree.h
// ==============================================================================
#ifdef _MSC_VER
#pragma warning(disable:4146)
#pragma warning(disable:4308)
#pragma warning(disable:4307)
#endif

// ==============================================================================
// BEGIN  defines.h                      (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2018-2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#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_ARRAYBASE	0x80	//b10000000
//#define OPENCSTL_NODEBASE	0x40	//b01000000

#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


#if defined(OPENCSTL_OS_WINDOWS)
#include<Windows.h>
#endif

//For access header element
//OPENCSTL_AccessContainerAsIndex
#define OPENCSTL_NIDX(container,nidx) (((size_t*)*container)[(nidx)])

#define OPENCSTL_HEADER	(12)
#define NIDX_CTYPE	    (-12)	// container type
#define NIDX_HSIZE	    (-11)	// header size
#define NIDX_TSIZE	    (-10)	// type size

#define NIDX_LIST_NODE_SIZE	(3)
#define NIDX_TREE_NODE_SIZE	(5)
//OPENCSTL_HEAP_MACROS
#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 // Non-Microsoft compilers
#   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


#define cstl_value(iter,TYPE)	(*(TYPE*)(iter+1))

// CSTL_USE_VAARG=0: Windows only (values passed directly on stack)
// CSTL_USE_VAARG=1: Linux/macOS (macros pass pointers via &__1; standard va_arg is correct)
#if defined(_WIN32) || defined(_WIN64)
#  define CSTL_USE_VAARG 0
#else
#  define CSTL_USE_VAARG 1
#endif

#if defined(_WIN32) || defined(_WIN64)
// On Windows the dispatch macros pass values directly (not pointer-to-value).
// va_arg(vl,void*) would read the value itself, so use PTR arithmetic instead.
#define __cstl_va_start(V,C,beg)	va_start(V,C);beg=(void*)V;
#define __cstl_va_arg(PTR)	(PTR)
// Windows: __cstl_va_arg_next is unused (Windows uses PTR-based path),
// but define it to avoid compile errors if referenced.
#define __cstl_va_arg_next(V)	(NULL)
#define __cstl_va_end(V)	va_end(V)
#else

// On Linux/macOS (GCC, Clang, TCC) the dispatch macros pass &__N (address of a local copy)
// for each arg. So va_arg(vl, void*) returns void** -- we must dereference to get the actual value.
#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

//Unary Functions
#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_max_capacity(container) _cstl_max_size(&(container))
//Macro only functions

#define _cstl_deque_type(container) (*(size_t*)((char*)*(void**)container + NIDX_CTYPE * sizeof(size_t) + (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__)
// #pragma GCC diagnostic push
// #pragma GCC diagnostic ignored "-Wincompatible-pointer-types"
// #pragma GCC diagnostic ignored "-Wint-conversion"
#if !defined(__clang__)
//#pragma GCC diagnostic ignored "-Wno-lto-type-mismatch"
#endif
#endif

#define _cstl_deref(P) (*(P))
#define _cstl_err_ptr (void*)(size_t)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__)
// #pragma GCC diagnostic pop
#endif

#define OPENCSTL_DEQUE_NIDX(container, nidx) (*(size_t*)((char*)*(void**)container + nidx * sizeof(size_t) + (OPENCSTL_NIDX(((void**)container), -1) + 1)))
#define _cstl_stack_top(container)   *container[OPENCSTL_DEQUE_NIDX(container, -2) -1]
// cstl_top: (void**)&container explicit cast for strict compilers (MinGW64, Windows Clang).
#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]))   //priority queue


#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))
#elif defined(__linux__) || defined(__APPLE__)

// TCC supports typeof but not __auto_type; GCC/Clang support both.
#if defined(__TINYC__)
#define _CSTL_TYPEOF(x) typeof(x)
#else
#define _CSTL_TYPEOF(x) __auto_type
#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(C,...) ({void* _() {_linux_cstl_max_size(C,__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)(C,__VA_ARGS__)}_;});
// #define _linux_cstl_max_size(C,_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) _cstl_max_size ## _ ## N
// #define _cstl_max_size_0(C) _cstl_max_size(&C)
// #define _cstl_max_size_1(C,...) _cstl_max_size(&C)
// #define _cstl_max_size_2(C,...) _cstl_max_size(&C)
// #define _cstl_max_size_3(C,...) _cstl_max_size(&C)
// #define _cstl_max_size_4(C,...) _cstl_max_size(&C)
// #define _cstl_max_size_5(C,...) _cstl_max_size(&C)
// #define _cstl_max_size_6(C,...) _cstl_max_size(&C)
// #define _cstl_max_size_7(C,...) _cstl_max_size(&C)
// #define _cstl_max_size_8(C,...) _cstl_max_size(&C)
// #define _cstl_max_size_9(C,...) _cstl_max_size(&C)
// #define _cstl_max_size_10(C,...) _cstl_max_size(&C)
#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))
#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

// ==============================================================================
// END    defines.h
// ==============================================================================

// ==============================================================================
// BEGIN  types.h                        (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2018-2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#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 size_t cstl_ptr;

typedef size_t (*cstl_hash)(void *key, size_t capacity, size_t key_size);


typedef int size_type;


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

// ==============================================================================
// END    types.h
// ==============================================================================
OPENCSTL_FUNC ptrdiff_t __is_deque(void **container) {
    if (OPENCSTL_NIDX(container, -1) > (size_t) INT_MAX)
        return 1;
    return 0;
}

// Safe container type detection for sort dispatch functions.
// Returns 0 if ptr is not an OpenCSTL container. Sets *distance for deque.
OPENCSTL_FUNC size_t __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; // Not an OpenCSTL container
    if (it->ctype == CT_DEQUE) {
        *distance = OPENCSTL_NIDX(container, -1) + 1;
    }
    return *(size_t *) ((char *) *container + NIDX_CTYPE * sizeof(size_t) + *distance);
}

#define cstl_deque(TYPE) __cstl_deque(sizeof(TYPE),#TYPE)
OPENCSTL_FUNC void *__cstl_deque(size_t type_size, char *type) {
    size_t header_sz = sizeof(size_t) * OPENCSTL_HEADER;
    void *block = calloc(header_sz + type_size * 2, 1);
    verify(block != NULL);
    void *ptr = (char *) block + header_sz; // 2 = capacity
    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_t) type;
    OPENCSTL_NIDX(container, -3) = 2; // capacity
    OPENCSTL_NIDX(container, -2) = 0; // length
    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_t n, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_t header_sz = *(size_t *) ((char *) *(void **) container + NIDX_HSIZE * sizeof(size_t) + distance);
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    //size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);
    size_t capacity = *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + distance);
    char *type = (char *) *(size_t *) ((char *) *(void **) container + -4 * sizeof(size_t) + distance);
#if !defined(__linux__)
    float valuef = 0.0F;
    if (strcmp(type, "float") == 0) {
        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;
    *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + distance) = n;
    *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + 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_t 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_t header_sz = *(size_t *) ((char *) *(void **) container + NIDX_HSIZE * sizeof(size_t) + distance);
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);
    size_t capacity = *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + distance);
    char *type = (char *) *(size_t *) ((char *) *(void **) container + -4 * sizeof(size_t) + distance);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float = *(size_t *) ((char *) *(void **) container + -8 * sizeof(size_t) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif

    if (length == capacity + distance / (ptrdiff_t) type_size) {
        size_t distance_sz = -distance;
        size_t 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;
        *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + 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);

    (*(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance))++;
}

OPENCSTL_FUNC void __cstl_deque_push_front(void **container, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_t header_sz = *(size_t *) ((char *) *(void **) container + NIDX_HSIZE * sizeof(size_t) + distance);
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);
    size_t capacity = *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + distance);
    char *type = (char *) *(size_t *) ((char *) *(void **) container + -4 * sizeof(size_t) + distance);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float = *(size_t *) ((char *) *(void **) container + -8 * sizeof(size_t) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    if (distance == 0) {
        size_t 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;
        *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + 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;
    *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance + type_size) += 1;
}

OPENCSTL_FUNC void __cstl_deque_pop_back(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);

    verify(length > 0);
    *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance) -= 1;
}

OPENCSTL_FUNC void __cstl_deque_pop_front(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);

    verify(*(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + 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;
    *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance - type_size) -= 1;
}

OPENCSTL_FUNC void __cstl_deque_insert(void **container, void *it, size_t n, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_t header_sz = *(size_t *) ((char *) *(void **) container + NIDX_HSIZE * sizeof(size_t) + distance);
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);
    size_t capacity = *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + distance);
    char *type = (char *) *(size_t *) ((char *) *(void **) container + -4 * sizeof(size_t) + distance);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float = *(size_t *) ((char *) *(void **) container + -8 * sizeof(size_t) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    size_t 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_t alloc_sz = header_sz + capacity * type_size - distance;
        void *b = realloc((char *) *container - header_sz + distance, alloc_sz);
        *container = (char *) b + header_sz - distance;
        *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + 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_t i = 0; i < n; i++) {
        memcpy((char *) *container + (pos + i) * type_size, value, type_size);
    }
    *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance) += n;
}

OPENCSTL_FUNC void __cstl_deque_erase(void **container, void *begin, void *end) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);
    size_t pos = (*(char **) end - *(char **) begin) / type_size;

    memmove(*(char **) begin, *(char **) end, (char *) *container + (length + 1) * type_size - *(char **) end);
    *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance) -= pos;
}

OPENCSTL_FUNC size_type __cstl_deque_size(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;

    return (size_type) (*(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance));
}

OPENCSTL_FUNC size_type __cstl_deque_capacity(void **container) {
    size_t capacity = OPENCSTL_NIDX(container, -3);

    return (size_type) capacity;
}

OPENCSTL_FUNC void __cstl_deque_resize(void **container, size_t n, void *value) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_t header_sz = *(size_t *) ((char *) *(void **) container + NIDX_HSIZE * sizeof(size_t) + distance);
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);
    size_t capacity = *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + distance);
    char *type = (char *) *(size_t *) ((char *) *(void **) container + -4 * sizeof(size_t) + distance);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float = *(size_t *) ((char *) *(void **) container + -8 * sizeof(size_t) + 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;
        *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + distance) = n;
        iveb_insert(iveb, *container, (char *) (*container) + (type_size * n), CT_DEQUE, type_size, type);
    }
    *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance) = n;
    if (length < n) {
        if (*(void **) value == NULL) {
            memset((char *) *container + length * type_size, 0, (n - length) * type_size);
        } else {
            for (size_t 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_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);

    return (char *) *container + length * type_size;
}

OPENCSTL_FUNC void *__cstl_deque_rbegin(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + 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_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);

    return (char *) *container - type_size;
}

OPENCSTL_FUNC void __cstl_deque_clear(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;

    *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance) = 0;
}

OPENCSTL_FUNC void __cstl_deque_free(void **container) {
    ptrdiff_t distance = OPENCSTL_NIDX(container, -1) + 1;
    size_t header_sz = *(size_t *) ((char *) *(void **) container + NIDX_HSIZE * sizeof(size_t) + 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_t header_sz = *(size_t *) ((char *) *(void **) container + NIDX_HSIZE * sizeof(size_t) + distance);
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);
    //size_t capacity = *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + distance);
    //char *type = (char *) *(size_t *) ((char *) *(void **) container + -4 * sizeof(size_t) + distance);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float = *(size_t *) ((char *) *(void **) container + -8 * sizeof(size_t) + distance);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    size_t pos = (*(char **) iter_begin - *(char **) container) / type_size;
    for (size_t 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_t header_sz = *(size_t *) ((char *) *(void **) container + NIDX_HSIZE * sizeof(size_t) + distance);
    size_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);
    size_t capacity = *(size_t *) ((char *) *(void **) container + -3 * sizeof(size_t) + distance);
    char *type = (char *) *(size_t *) ((char *) *(void **) container + -4 * sizeof(size_t) + distance);

    // 이미 꽉 차있고 앞쪽 여유도 없으면 아무것도 안 함
    if (length == capacity && distance == 0) {
        return;
    }

    size_t 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);
    // 원소들을 새 버퍼의 맨 앞(distance=0)으로 복사
    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_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_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);

    if (length < 2) {
        return;
    }

    // 작은 타입은 스택 버퍼, 큰 타입은 heap (list_swap_data와 동일 패턴)
    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_t 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);
    }
}
#endif // if !defined(_OPENCSTL_DEQUE_H)

// ==============================================================================
// END    deque.h
// ==============================================================================

// ==============================================================================
// BEGIN  vector.h                       (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2018-2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_VECTOR_H)
#define _OPENCSTL_VECTOR_H
// [already included: zalloc.h]
// [already included: van_emde_boas_tree.h]

// ==============================================================================
// BEGIN  swap.h                         (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//

#ifndef OPENCSTL_SWAP_H
#define OPENCSTL_SWAP_H
#include <stddef.h>
#include <string.h>

#define SWAP_STACK_BUF_SIZE 256

void swap(void *a, void *b, size_t sz) {
    unsigned char stack_buf[SWAP_STACK_BUF_SIZE];
    unsigned char *tmp;
    size_t i;

    if (a == NULL || b == NULL || a == b || sz == 0) {
        return;
    }

    /*
     * 작은 크기는 stack buffer 사용
     * 큰 크기는 byte-wise swap (malloc 없이)
     */
    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 //OPENCSTL_SWAP_H

// ==============================================================================
// END    swap.h
// ==============================================================================

// ==============================================================================
// BEGIN  utility.h                      (depth 2)
// ==============================================================================

//
// Created by spring on 4/22/2026.
//

#ifndef OPENCSTL_UTILITY_H
#define OPENCSTL_UTILITY_H
// floor(sqrt(x)) — 정수 전용, FP/division 없음
// 비트 단위로 2비트씩 처리 → 32bit 입력 기준 최대 16회 루프
static unsigned int fast_sqrt(unsigned int x) {
    unsigned int res = 0;
    unsigned int bit = 1u << 30; // 32bit 내 최대 4의 거듭제곱
    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;
}

// ratio = √2 + (√9 - √2) · K / (K + √capacity)
//   capacity →   0 : ratio → √9 = 3.0
//   capacity → ∞   : ratio → √2 ≈ 1.414
//   K = 전환 속도. K=16 이면 √capacity = K 지점(=capacity 256)이 딱 중간.
static int get_new_capacity(int _capacity) {
    if (_capacity < 2) return 2;

    enum {
        SQRT2_Q16 = 92682, // √2 · 65536
        DIFF_Q16 = 103926, // (√9 - √2) · 65536
        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;
}

// #include <math.h>
// #include <float.h>
// static int float_cmp(const void* a, const void* b) {
//     const float* pa = (const float*) a;
//     const float* pb = (const float*) b;
//     float x = *pa, y = *pb;
//     float diff = fabsf(x - y);
//     float scale = fmaxf(fabsf(x), fabsf(y));
//     if (diff <= FLT_EPSILON * fmaxf(1.0f, scale)) return 0;
//     return (x < y) ? -1 : 1;
// }
#endif //OPENCSTL_UTILITY_H

// ==============================================================================
// END    utility.h
// ==============================================================================
// ██╗░░░██╗███████╗░█████╗░████████╗░█████╗░██████╗░
// ██║░░░██║██╔════╝██╔══██╗╚══██╔══╝██╔══██╗██╔══██╗
// ╚██╗░██╔╝█████╗░░██║░░╚═╝░░░██║░░░██║░░██║██████╔╝
// ░╚████╔╝░██╔══╝░░██║░░██╗░░░██║░░░██║░░██║██╔══██╗
// ░░╚██╔╝░░███████╗╚█████╔╝░░░██║░░░╚█████╔╝██║░░██║
// ░░░╚═╝░░░╚══════╝░╚════╝░░░░╚═╝░░░░╚════╝░╚═╝░░╚═╝

#define cstl_vector(TYPE)	__cstl_vector(sizeof(TYPE),#TYPE)
OPENCSTL_FUNC void *__cstl_vector(size_t type_size, char *type) {
    size_t header_sz = sizeof(size_t) * OPENCSTL_HEADER;
    void *block = calloc(header_sz + type_size, 1);
    if (block == NULL) {
        yikes("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_t) type;

    OPENCSTL_NIDX(container, -3) = 0; //
    OPENCSTL_NIDX(container, -2) = 1; //capacity
    OPENCSTL_NIDX(container, -1) = 0; //length
    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_t n, void *value) {
    size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    //size_t length = OPENCSTL_NIDX(container, -1);
    size_t capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t 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) {
            yikes("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_t 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_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    size_t capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t 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_t new_capaciy = get_new_capacity(capacity);
        void *b = realloc((char *) *container - header_sz, header_sz + new_capaciy * type_size);
        if (b == NULL) {
            yikes("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) {
        yikes("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_t N, void *value) {
    size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    size_t capacity = OPENCSTL_NIDX(container, -2);
    size_t pos = (*(char **) iter - *(char **) container) / type_size;
    char *type = (char *) OPENCSTL_NIDX(container, -4);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t 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_t new_capaciy = get_new_capacity(capacity+N);
        void *b = realloc((char *) *container - header_sz, header_sz + new_capaciy * type_size);
        if (b == NULL) {
            yikes("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_t 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_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    //size_t capacity = OPENCSTL_NIDX(container, -2);
    size_t pos_begin = (*(char **) iter_begin - *(char **) container) / type_size;
    size_t 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_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    return (void *) ((char *) *container + (type_size * length));
}

OPENCSTL_FUNC void *__cstl_vector_rbegin(void **container) {
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    return (void *) ((char *) *container + (type_size * (length - 1)));
}

OPENCSTL_FUNC void *__cstl_vector_rend(void **container) {
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    return (void *) ((char *) *container - (type_size));
}

OPENCSTL_FUNC void __cstl_vector_resize(void **container, size_t n, void *value) {
    size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    size_t capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);
#if !defined(__linux__) && !defined(__APPLE__)
    size_t 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) {
            yikes("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_t 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_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    //size_t capacity = OPENCSTL_NIDX(container, -2);
    size_t pos = (*(char **) iter_begin - *(char **) container) / type_size;
    //char *type = (char *) OPENCSTL_NIDX(container, -4);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float = OPENCSTL_NIDX(container, -8);
    float valuef = 0.0F;
    if (is_float) {
        valuef = (float) *(double *) value;
        value = &valuef;
    }
#endif
    for (size_t 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_t 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_t n) {
    size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    //size_t length = OPENCSTL_NIDX(container, -1);
    size_t 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) {
            yikes("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_t type_size) {
    return (char *) it + type_size;
}

OPENCSTL_FUNC void *__cstl_vector_prev(void *it, size_t 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_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    size_t capacity = OPENCSTL_NIDX(container, -2);
    char *type = (char *) OPENCSTL_NIDX(container, -4);

    if (capacity == length) {
        return;
    }
    size_t 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) {
        yikes("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_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    size_t 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--;
    }
}


#endif

// ==============================================================================
// END    vector.h
// ==============================================================================

// ==============================================================================
// BEGIN  list.h                         (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2018-2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_LIST_H)
#define _OPENCSTL_LIST_H

// ==============================================================================
// BEGIN  error.h                        (depth 2)
// ==============================================================================

//
// Created by spring on 4/21/2026.
//
#ifndef OPENCSTL_ERROR_H
#define OPENCSTL_ERROR_H
// [already included: defines.h]
// [already included: types.h]
#endif //OPENCSTL_ERROR_H

// ==============================================================================
// END    error.h
// ==============================================================================
// [already included: zalloc.h]

#define cstl_list(TYPE)		__cstl_list(sizeof(TYPE),#TYPE)
#define NTAIL(N)	(N==-1?-2:N)
OPENCSTL_FUNC void *__cstl_list(size_t type_size, char *type) {
    size_t header_sz = sizeof(size_t) * OPENCSTL_HEADER;
    void *block = calloc(header_sz + sizeof(size_t), 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_t) type;
    OPENCSTL_NIDX(container, -2) = 0; //tail
    OPENCSTL_NIDX(container, -1) = 0; //length
    OPENCSTL_NIDX(container, 0) = 0; //head
    bool iveb_init = false;
    if (iveb == NULL) {
        iveb = iveb_new();
        iveb_init = true;
    }
    iveb_insert(iveb, ptr, (char *) ptr + sizeof(size_t), CT_LIST, type_size, type);
    if (iveb_init) {
        atexit(__opencstl_iveb_destroy);
    }
    return ptr;
}

OPENCSTL_FUNC void *__cstl_list_node(size_t type_size) {
    //[node type][prev][next] ↘ [data]
    size_t header_sz = sizeof(void *) * NIDX_LIST_NODE_SIZE;
    size_t 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_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    void **tail = (void **) &OPENCSTL_NIDX(container, NTAIL(ntail)); //-1 , 0
    void **head = (void **) &OPENCSTL_NIDX(container, nhead); //0  , -1
    void *n = __cstl_list_node(type_size);
    //char *type = (char *) OPENCSTL_NIDX(container, -4);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t 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_t) n;
        OPENCSTL_NIDX(&n, -(nhead + 2)) = (size_t) *tail;
        *tail = n;
    }
    OPENCSTL_NIDX(container, -1)++;
}

OPENCSTL_FUNC void __cstl_list_pop_back_front(void **container, int ntail, int nhead) {
    //size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    //size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    void **tail = (void **) &OPENCSTL_NIDX(container, NTAIL(ntail)); //-1 , 0
    void **head = (void **) &OPENCSTL_NIDX(container, nhead); //0  , -1
    verify(*head != NULL && *tail != NULL);
    if (*head == *tail) {
        free(&OPENCSTL_NIDX(tail, -3)); //fix
        *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) {
    //next(-1), prev(-2)
    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_t n, void *value) {
    size_t 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_t N, void *value) {
    //size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t 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);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t 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_t i = 1; i < N; i++) {
        void *n = __cstl_list_node(type_size);
        memcpy(n, value, type_size);
        OPENCSTL_NIDX(&n, -2) = (size_t) ntail; //n->prev=tail
        OPENCSTL_NIDX(&ntail, -1) = (size_t) n; //tail->next=n;
        ntail = n;
    }
    OPENCSTL_NIDX(&ntail, -1) = (size_t) *iter; //n->next=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_t) nhead; //iter->prev->next=n;
        }
        OPENCSTL_NIDX(&nhead, -2) = OPENCSTL_NIDX(iter, -2); //n->prev=iter->prev
        OPENCSTL_NIDX(iter, -2) = (size_t) ntail; //iter->prev=n;
        if (*iter == *head) {
            *head = nhead;
        }
    } else {
        OPENCSTL_NIDX(tail, -1) = (size_t) nhead; //tail->next=n;
        OPENCSTL_NIDX(&nhead, -2) = (size_t) *tail; //n->prev=tail;
        *tail = ntail;
    }
    OPENCSTL_NIDX(container, -1) += N;
}

OPENCSTL_FUNC void __cstl_list_erase(void **container, void **iter_begin, void **iter_end) {
    //size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    //size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    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_t) *iter_end; //begin->prev->next=end;
        if (*iter_end != NULL) {
            OPENCSTL_NIDX(iter_end, -2) = OPENCSTL_NIDX(iter_begin, -2); //end->prev=begin->prev
        }
    }
    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_t 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_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t 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);

#if !defined(__linux__) && !defined(__APPLE__)
    size_t 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_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t 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_t 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_t 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_t left_count = 0;
            size_t 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_t) pick;
                    OPENCSTL_NIDX(&pick, -2) = (size_t) 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_t 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_t 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_t 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_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t 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_t 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_t stack_cap = 64;
    __cstl_qsort_range *stack = (__cstl_qsort_range *) calloc(sizeof(__cstl_qsort_range), stack_cap);
    verify(stack != NULL);
    size_t 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_t left_cnt = 0;
        size_t 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_t length = OPENCSTL_NIDX(container, -1);

    if (*head == NULL || *tail == NULL || length < 2) {
        return;
    }

    // 각 노드의 prev/next 포인터를 스왑
    void *curr = *head;
    while (curr != NULL) {
        void *next = (void *) OPENCSTL_NIDX(&curr, -1);
        OPENCSTL_NIDX(&curr, -1) = OPENCSTL_NIDX(&curr, -2); // next ← old prev
        OPENCSTL_NIDX(&curr, -2) = (size_t) next; // prev ← old next
        curr = next;
    }

    // 컨테이너의 head ↔ tail 스왑
    void *tmp = *head;
    *head = *tail;
    *tail = tmp;
}
#endif

// ==============================================================================
// END    list.h
// ==============================================================================

// ==============================================================================
// BEGIN  rbtree.h                       (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2018-2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_TREE_H)
#define _OPENCSTL_TREE_H


// [already included: error.h]
// [already included: zalloc.h]

#define P	    (-4)
#define R       (-1)
#define L       (-2)
#define RED     ((size_t)1)
#define BLACK   ((size_t)0)
// _(N,V): raw size_t lvalue, no cast, works on all compilers including Windows Clang.
// Write sites: _(N,V) = (size_t)val
// Read sites:  (void*)_(N,V)
#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_t used;
    size_t capacity;
    size_t node_size;
};

OPENCSTL_FUNC cstl_arena_chunk *__cstl_arena_new_chunk(size_t node_size, size_t 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_t 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_t type_size, size_t node_type) {
    // [color][parent][node type][left][right] -> [data]
    size_t 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_t type_size, size_t node_type) {
    // [color][parent][node type][left][right] -> [data]
    size_t 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_t) node_type;
    COLOR(ptr) = BLACK;
    return ptr;
}

// ░██████╗███████╗████████╗
// ██╔════╝██╔════╝╚══██╔══╝
// ╚█████╗░█████╗░░░░░██║░░░
// ░╚═══██╗██╔══╝░░░░░██║░░░
// ██████╔╝███████╗░░░██║░░░
// ╚═════╝░╚══════╝░░░╚═╝░░░

#define cstl_set         _cstl_set
#define _cstl_set(KEY, ...)	    _CSTL_SET_DISPATCH(KEY, ##__VA_ARGS__, NULL)
#define _CSTL_SET_DISPATCH(KEY, COMP, ...) __cstl_set(sizeof(KEY),#KEY,(void*)(COMP))


OPENCSTL_FUNC void *__cstl_set(size_t 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_t) nil;
    }
    size_t header_sz = sizeof(size_t) * OPENCSTL_HEADER;
    void *ptr = (char *) calloc(header_sz + sizeof(size_t), 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; //value size, but set does not have value.
    OPENCSTL_NIDX(container, -3) = (size_t) type_key; //type
    OPENCSTL_NIDX(container, -2) = (size_t) compare; //compare function
    OPENCSTL_NIDX(container, -1) = 0;
    OPENCSTL_NIDX(container, 0) = (size_t) nil; //root
    return ptr;
}

// ███╗░░░███╗░█████╗░██████╗░
// ████╗░████║██╔══██╗██╔══██╗
// ██╔████╔██║███████║██████╔╝
// ██║╚██╔╝██║██╔══██║██╔═══╝░
// ██║░╚═╝░██║██║░░██║██║░░░░░
// ╚═╝░░░░░╚═╝╚═╝░░╚═╝╚═╝░░░░░
#define cstl_map         _cstl_map
#define _cstl_map(KEY, VALUE, ...)	_CSTL_MAP_DISPATCH(KEY, VALUE, ##__VA_ARGS__, NULL)
#define _CSTL_MAP_DISPATCH(KEY, VALUE, COMP, ...) __cstl_map(sizeof(KEY), sizeof(VALUE), #KEY, #VALUE, (void*)(COMP))
OPENCSTL_FUNC void *__cstl_map(size_t key_size, size_t 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_t) nil;
    }
    size_t header_sz = sizeof(size_t) * OPENCSTL_HEADER;
    void *ptr = (char *) calloc(header_sz + sizeof(size_t), 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_t) type_value; //not-reserved
    OPENCSTL_NIDX(container, -4) = value_size; //value size
    OPENCSTL_NIDX(container, -3) = (size_t) type_key; //not-reserved
    OPENCSTL_NIDX(container, -2) = (size_t) compare; //compare function
    OPENCSTL_NIDX(container, -1) = 0;
    OPENCSTL_NIDX(container, 0) = (size_t) nil; //root
    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_t) x;
    }
    _(y, P) = _(x, P);
    if ((void *) _(x, P) == nil) {
        *root = (void **) y;
    } else if (x == (void *) _(_(x,P), L)) {
        _(_(x, P), L) = (size_t) y;
    } else {
        _(_(x, P), R) = (size_t) y;
    }
    _(y, L) = (size_t) x;
    _(x, P) = (size_t) 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_t) x;
    }
    _(y, P) = _(x, P);
    if ((void *) _(x, P) == nil) {
        *root = (void **) y;
    } else if (x == (void *) _(_(x, P), R)) {
        _(_(x, P), R) = (size_t) y;
    } else {
        _(_(x, P), L) = (size_t) y;
    }
    _(y, R) = (size_t) x;
    _(x, P) = (size_t) 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_t container_type = OPENCSTL_NIDX(container, NIDX_CTYPE);
    //size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t value_size = OPENCSTL_NIDX(container, -4);
    size_t type_size = key_size + value_size;
    CSTL_COMPARE compare = (CSTL_COMPARE) OPENCSTL_NIDX(container, -2);

    // char *type_key = (char *) OPENCSTL_NIDX(container, -3);
    // char *type_value = (char *) OPENCSTL_NIDX(container, -5);


#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float_key = OPENCSTL_NIDX(container, -8);
    size_t 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(type_size, container_type);
    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) {
            //to left
            root = (void ***) &OPENCSTL_NIDX(root, L);
        } else {
            //to right
            root = (void ***) &OPENCSTL_NIDX(root, R);
        }
    }
    OPENCSTL_NIDX(&n, P) = (size_t) p;
    OPENCSTL_NIDX(&n, L) = (size_t) nil;
    OPENCSTL_NIDX(&n, R) = (size_t) 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_t) v;
    } else {
        _(_(u, P), R) = (size_t) 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;
    // size_t container_type = OPENCSTL_NIDX(container, NIDX_CTYPE);
    // size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    // size_t key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    // size_t value_size = OPENCSTL_NIDX(container, -4);
    //size_t type_size = key_size + value_size;
    //cstl_compare compare = (cstl_compare) OPENCSTL_NIDX(container, -2);
    //void ***root = (void ***) *container;
    void *z = iter;

    void *y = z;
    void *x = NULL;
    size_t y_original_color = (size_t) 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_t) COLOR(y);
        x = (void *) _(y, R);
        if ((void *) _(y, P) == z) {
            _(x, P) = (size_t) y;
        } else {
            __cstl_tree_transplant(container, y, (void *) _(y, R));
            _(y, R) = _(z, R);
            _(_(y, R), P) = (size_t) y;
        }
        __cstl_tree_transplant(container, z, y);
        _(y, L) = _(z, L);
        _(_(y, L), P) = (size_t) y;
        COLOR(y) = COLOR(z);
    }
    if (y_original_color == (size_t) BLACK) {
        __cstl_tree_erase_fixup(container, x);
    }
    //free(&OPENCSTL_NIDX(&iter, -5));
    {
        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_t container_type = OPENCSTL_NIDX(container, NIDX_CTYPE);
    // size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t value_size = OPENCSTL_NIDX(container, -4);
    size_t type_size = key_size + value_size;
    //char *type_key = (char *) OPENCSTL_NIDX(container, -3);


#if !defined(__linux__) && !defined(__APPLE__)
    size_t 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) {
            //to left
            root = (void ***) &OPENCSTL_NIDX(root, L);
        } else {
            //to right
            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) {
//     size_t container_type = OPENCSTL_NIDX(container, NIDX_CTYPE);
//     size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
//     size_t key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
//     size_t value_size = OPENCSTL_NIDX(container, -4);
//     size_t type_size = key_size + value_size;
//     cstl_compare compare = (cstl_compare) OPENCSTL_NIDX(container, -2);
//     void ***root = (void ***) *container;
//
//     void *c = *root;
//     while (c != nil) {
//         if ((void *) _(c, R) != nil) {
//             void *m = __cstl_tree_toleft(c);
//             _(m, L) = _(c, R);
//             _(_(c, R), P) = _(m, L);
//         }
//         void *t = c;
//         c = (void *) _(c, L);
//         free(&OPENCSTL_NIDX(&t, -5));
//
//     }
//     *root = 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_t 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 *)) {
    //next = r(-1) , l(-2)
    //prev = r(-2), l(-1)
    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 *n) {
//     if (n == nil)return 0;
//     return ___cstl_tree_size((void *) _(n, L)) + ___cstl_tree_size((void *) _(n, R)) + 1;
// }

OPENCSTL_FUNC size_type __cstl_tree_size(void **container) {
    //size_t container_type = OPENCSTL_NIDX(container, NIDX_CTYPE);
    //size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    //size_t key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    //size_t value_size = OPENCSTL_NIDX(container, -4);
    //size_t type_size = key_size + value_size;
    //cstl_compare compare = (cstl_compare) OPENCSTL_NIDX(container, -2);
    //void ***root = (void ***) *container;
    //void *c = *root;
    size_t length = OPENCSTL_NIDX(container, -1);
    //return ___cstl_tree_size(c);
    return (size_type) length;
}
#undef P
#undef L
#undef R
#undef _
#undef RED
#undef BLACK


#endif

// ==============================================================================
// END    rbtree.h
// ==============================================================================

// ==============================================================================
// BEGIN  stack.h                        (depth 1)
// ==============================================================================

//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2018-2026 KimBomm, Woo Cheol, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_STACK_H)
#define _OPENCSTL_STACK_H
// [already included: error.h]

#define cstl_stack(TYPE)	__cstl_stack(sizeof(TYPE),#TYPE)
OPENCSTL_FUNC void *__cstl_stack(size_t type_size, char *type) {
    size_t header_sz = sizeof(size_t) * OPENCSTL_HEADER;
    void *ptr = (char *) malloc(header_sz + type_size * 2) + header_sz; // 2 = capacity
    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_t) type;
    OPENCSTL_NIDX(container, -3) = 2; //capacity
    OPENCSTL_NIDX(container, -2) = 0; //length
    *container = (char *) ptr + type_size;
    OPENCSTL_NIDX(container, -1) = -type_size - 1; //distance  = -type_size -1 항상 음수여야 하기 때문
    return ptr;
}
#endif

// ==============================================================================
// END    stack.h
// ==============================================================================

// ==============================================================================
// BEGIN  queue.h                        (depth 1)
// ==============================================================================

//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2018-2026, Kim Bomm, Woo Cheol, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_QUEUE_H)
#define _OPENCSTL_QUEUE_H

// [already included: vector.h]
// [already included: error.h]

// ==============================================================================
// BEGIN  salloc.h                       (depth 2)
// ==============================================================================

//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, Woo Cheol, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#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 //_OPENCSTL_C_ALLOCA_H

// ==============================================================================
// END    salloc.h
// ==============================================================================


#define cstl_queue(TYPE)	__cstl_queue(sizeof(TYPE),#TYPE)
OPENCSTL_FUNC void *__cstl_queue(size_t type_size, char *type) {
    size_t header_sz = sizeof(size_t) * OPENCSTL_HEADER;
    void *ptr = (char *) malloc(header_sz + type_size * 2) + header_sz; // 2 = capacity
    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_t) type;
    OPENCSTL_NIDX(container, -3) = 2; //capacity
    OPENCSTL_NIDX(container, -2) = 0; //length
    *container = (char *) ptr + type_size;
    OPENCSTL_NIDX(container, -1) = -type_size - 1; //distance  = -type_size -1
    return ptr;
}

#define cstl_priority_queue(TYPE,...)	_CSTL_PQ_DISPATCH(TYPE, ##__VA_ARGS__, NULL)
#define _CSTL_PQ_DISPATCH(TYPE, COMP, ...) __cstl_priority_queue(sizeof(TYPE),#TYPE,(void*)(COMP))
OPENCSTL_FUNC void *__cstl_priority_queue(size_t type_size, char *type, void *compare) {
    size_t header_sz = sizeof(size_t) * 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_t) type;
    OPENCSTL_NIDX(container, -3) = (size_t) compare; //compare function
    OPENCSTL_NIDX(container, -2) = 1; //capacity
    OPENCSTL_NIDX(container, -1) = 0; //length
    return ptr;
}

OPENCSTL_FUNC void __cstl_priority_queue_push(void **container, void *value) {
    __cstl_vector_push_back(container, value);
    size_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);
    CSTL_COMPARE compare = (CSTL_COMPARE) OPENCSTL_NIDX(container, -3);

    void *tmp = salloc(type_size);
    size_t 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_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t 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_t idx = 0;
    void *tmp = salloc(type_size);
    size_t 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

// ==============================================================================
// END    queue.h
// ==============================================================================

// ==============================================================================
// BEGIN  hashtable.h                    (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//


#if !defined(_OPENCSTL_HASHTABLE_H)
#define _OPENCSTL_HASHTABLE_H
// [already included: zalloc.h]
// [already included: van_emde_boas_tree.h]
/* [already included: error.h] */

/* Linear-probing open-addressing hash table.
 * Control byte layout: 0 = empty, non-zero = occupied (7-bit hash fragment | 0x80).
 * Backward-shift deletion keeps the table tombstone-free. */
#define HT_CTRL_EMPTY 0u
#define HT_LOAD_NUM   7
#define HT_LOAD_DEN   8
#define HT_MIN_CAP    8u
/* iterator.h gates on HTM_VEBT to pick the veb-tree based htm lookup path. */
#define HTM_VEBT

/* threshold = cap * 7/8, computed via shifts (no fp) */
#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)
/* MSVC's `static inline` is advisory; __forceinline is what the hot-path
 * helpers need so hash_mixer, __ht_key_eq, __ht_mum actually get inlined and
 * the per-insert dispatch cost does not multiply across 50M calls. */
#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

/* MSVC x64 does not expose __uint128_t; use the _umul128 intrinsic instead of
 * the scalar 4-multiply fallback. This cuts the hash cost from ~15 cycles to
 * one full-width multiply. */
#if defined(_MSC_VER) && defined(_M_X64)
#include <intrin.h>
#pragma intrinsic(_umul128)
#endif

static inline size_t __ht_next_pow2(size_t n) {
    size_t 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_t 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;
    }
}

/* XX* primes retained for the byte-oriented hash() kept as public helper. */
#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_t 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_t) h;
}

OPENCSTL_FUNC size_t 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_t) x;
}

OPENCSTL_FUNC size_t hash(void *_key, size_t 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_t) h64;
}

/* Single 64x64->128 multiply + fold: one instruction on x86/x64.
 *   - GCC/Clang: __uint128_t expands to a native `mulq`.
 *   - MSVC x64: the _umul128 intrinsic (same `mulq`, no scalar fallback).
 *   - Otherwise: a 4-multiply scalar fallback. */
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_t hash_mixer(void *key, size_t 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_t) __ht_mum((uint64_t) v ^ s1, s0);
    }
    if (n == 8) {
        uint64_t v;
        memcpy(&v, key, 8);
        return (size_t) __ht_mum(v ^ s1, s0);
    }
    return (size_t) hash(key, n);
}

OPENCSTL_ALWAYS_INLINE uint8_t __ht_ctrl(size_t h) {
    /* Non-zero fragment in [1, 255] — high bit set keeps occupied ctrls well clear of empty. */
    return (uint8_t) ((h >> 56) | 0x80u);
}

#define __HASHTABLE_DEFAULT_SIZE__ HT_MIN_CAP

static uint8_t *__ht_alloc_ctrl(size_t cap) {
    /* calloc zeros the ctrl array; every slot starts as empty. */
    uint8_t *m = (uint8_t *) calloc(cap, 1);
    verify(m!=NULL);
    return m;
}

/* Reinsert a single key (and optional value) into a freshly-allocated table. */
static void __ht_reinsert(
    void *base, uint8_t *ctrl, size_t cap_mask,
    const void *key, const void *value,
    size_t key_size, size_t value_size, size_t type_size, size_t h
) {
    size_t 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_t header_sz,
    size_t key_size, size_t value_size, size_t type_size,
    size_t old_cap, uint8_t *old_ctrl
) {
    size_t 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_t new_mask = new_cap - 1;

    for (size_t 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_t 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_t) (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_t key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t value_size = OPENCSTL_NIDX(container, -4);
    size_t type_size = key_size + value_size;
    size_t cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float_key = OPENCSTL_NIDX(container, -8);
    size_t 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_t h = hash_mixer(key, key_size);
    uint8_t c = __ht_ctrl(h);
    size_t idx = h & cap_mask;
    char *base = (char *) *container;

    /* Hot loop: probe for duplicate or empty slot. Rehash threshold is only
     * consulted on the rare brand-new-slot exit below. */
    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_t length = OPENCSTL_NIDX(container, -1);
    if (OPENCSTL_UNLIKELY(length + 1 > HT_THRESHOLD(cap_mask + 1))) {
        size_t 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_t key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    size_t value_size = OPENCSTL_NIDX(container, -4);
    size_t type_size = key_size + value_size;
#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float_key = OPENCSTL_NIDX(container, -8);
    float kf = 0.f;
    if (is_float_key) {
        kf = (float) *(double *) key;
        key = &kf;
    }
#endif
    size_t h = hash_mixer(key, key_size);
    uint8_t c = __ht_ctrl(h);
    size_t 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;
    }

    /* Backward-shift deletion for plain linear probing. We scan forward until
     * the cluster's trailing empty slot, shifting any displaced entry whose
     * ideal home lies at or before the hole. Entries already at their home
     * stay put but we must keep scanning past them -- later slots may hold
     * entries from the same probe cluster whose chain would otherwise break. */
    size_t hole = idx;
    size_t j = (idx + 1) & cap_mask;
    while (ctrl[j] != HT_CTRL_EMPTY) {
        size_t nh = hash_mixer(base + j * type_size, key_size) & cap_mask;
        size_t dist_j = (j - nh) & cap_mask;
        size_t 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_t key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    size_t value_size = OPENCSTL_NIDX(container, -4);
    size_t type_size = key_size + value_size;
#if !defined(__linux__) && !defined(__APPLE__)
    size_t is_float_key = OPENCSTL_NIDX(container, -8);
    float kf = 0.f;
    if (is_float_key) {
        kf = (float) *(double *) key;
        key = &kf;
    }
#endif
    size_t h = hash_mixer(key, key_size);
    uint8_t c = __ht_ctrl(h);
    size_t 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_t 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_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE) + OPENCSTL_NIDX(container, -4);
    size_t cap_mask = OPENCSTL_NIDX(container, -7);
    uint8_t *ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);
    for (size_t 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_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE) + OPENCSTL_NIDX(container, -4);
    size_t 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_t 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_t ts = (size_t) chtm->type_size;
    size_t cap = ((char *) chtm->p2 - (char *) chtm->p1) / ts;
    uint8_t *ctrl = (uint8_t *) chtm->tombstone;

    if (n == -1) {
        size_t 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_t pos = ((char *) it - (char *) chtm->p1) / ts;
        if (pos == 0) return (char *) chtm->p1 - ts;

        for (size_t 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_t 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_t n) {
    size_t header_sz = OPENCSTL_NIDX(container, NIDX_HSIZE);
    size_t key_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t value_size = OPENCSTL_NIDX(container, -4);
    size_t type_size = key_size + value_size;
    size_t length = OPENCSTL_NIDX(container, -1);
    size_t cap_mask_old = OPENCSTL_NIDX(container, -7);
    uint8_t *old_ctrl = (uint8_t *) (uintptr_t) OPENCSTL_NIDX(container, -6);

    size_t want = length + n;
    size_t 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_t 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_t new_mask = new_cap - 1;

    for (size_t 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_t 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_t) (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);
}

void __cstl_htm_destroy(void) {
    htm_free(htm);
}

// ██╗░░░██╗███╗░░██╗░█████╗░██████╗░██████╗░███████╗██████╗░███████╗██████╗░░░░░░░░██████╗███████╗████████╗
// ██║░░░██║████╗░██║██╔══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔════╝██╔══██╗░░░░░░██╔════╝██╔════╝╚══██╔══╝
// ██║░░░██║██╔██╗██║██║░░██║██████╔╝██║░░██║█████╗░░██████╔╝█████╗░░██║░░██║░░░░░░╚█████╗░█████╗░░░░░██║░░░
// ██║░░░██║██║╚████║██║░░██║██╔══██╗██║░░██║██╔══╝░░██╔══██╗██╔══╝░░██║░░██║░░░░░░░╚═══██╗██╔══╝░░░░░██║░░░
// ╚██████╔╝██║░╚███║╚█████╔╝██║░░██║██████╔╝███████╗██║░░██║███████╗██████╔╝█████╗██████╔╝███████╗░░░██║░░░
// ░╚═════╝░╚═╝░░╚══╝░╚════╝░╚═╝░░╚═╝╚═════╝░╚══════╝╚═╝░░╚═╝╚══════╝╚═════╝░╚════╝╚═════╝░╚══════╝░░░╚═╝░░░

/* MSVC's classic preprocessor does not eat the trailing comma before an empty
 * `##__VA_ARGS__`, which would leave an empty FUNC parameter and produce a
 * bogus `(void*)()` cast. We avoid that by always padding with NULL and using
 * the EXPAND trick so MSVC correctly re-tokenises the forwarded __VA_ARGS__. */
#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_t key_size, const char *type_key, void *hash_func) {
    size_t header_sz = sizeof(size_t) * OPENCSTL_HEADER;
    size_t 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_t) (uintptr_t) ctrl;
    OPENCSTL_NIDX(c, -4) = 0;
    OPENCSTL_NIDX(c, -3) = (size_t) type_key;
    OPENCSTL_NIDX(c, -2) = (size_t) 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;
}

// ██╗░░░██╗███╗░░██╗░█████╗░██████╗░██████╗░███████╗██████╗░███████╗██████╗░░░░░░░███╗░░░███╗░█████╗░██████╗░
// ██║░░░██║████╗░██║██╔══██╗██╔══██╗██╔══██╗██╔════╝██╔══██╗██╔════╝██╔══██╗░░░░░░████╗░████║██╔══██╗██╔══██╗
// ██║░░░██║██╔██╗██║██║░░██║██████╔╝██║░░██║█████╗░░██████╔╝█████╗░░██║░░██║░░░░░░██╔████╔██║███████║██████╔╝
// ██║░░░██║██║╚████║██║░░██║██╔══██╗██║░░██║██╔══╝░░██╔══██╗██╔══╝░░██║░░██║░░░░░░██║╚██╔╝██║██╔══██║██╔═══╝░
// ╚██████╔╝██║░╚███║╚█████╔╝██║░░██║██████╔╝███████╗██║░░██║███████╗██████╔╝█████╗██║░╚═╝░██║██║░░██║██║░░░░░
// ░╚═════╝░╚═╝░░╚══╝░╚════╝░╚═╝░░╚═╝╚═════╝░╚══════╝╚═╝░░╚═╝╚══════╝╚═════╝░╚════╝╚═╝░░░░░╚═╝╚═╝░░╚═╝╚═╝░░░░░
/* Same MSVC-compatible pattern as unordered_set: always pad NULL, force a
 * re-scan via EXPAND, so the optional hash-function argument is allowed to be
 * absent on MSVC's classic preprocessor. */
#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_t key_size, size_t value_size,
                           const char *type_key, const char *type_value,
                           void *hash_func) {
    size_t header_sz = sizeof(size_t) * OPENCSTL_HEADER;
    size_t type_size = key_size + value_size;
    size_t 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_t) (uintptr_t) ctrl;
    OPENCSTL_NIDX(c, -4) = value_size;
    OPENCSTL_NIDX(c, -3) = (size_t) type_key;
    OPENCSTL_NIDX(c, -2) = (size_t) 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

// ==============================================================================
// END    hashtable.h
// ==============================================================================
/// Algorithm

// ==============================================================================
// BEGIN  algorithm.h                    (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_C_ALGORITHM_H)
#define _OPENCSTL_C_ALGORITHM_H


// [already included: defines.h]

// ==============================================================================
// BEGIN  compare.h                      (depth 2)
// ==============================================================================

 //
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//

#ifndef OPENCSTL_COMPARE_H
#define OPENCSTL_COMPARE_H
#include <string.h>
typedef const void *CVP;

typedef int (*_OpenCSTLCompareFunc)(CVP a, CVP b);

#define _SAFE_COMPARE(TYPE,X,Y)  (*(TYPE *) (X) > *(TYPE *) (Y)) - (*(TYPE *) (X) < *(TYPE *) (Y))

int less_int32(CVP a, CVP b) {
    return _SAFE_COMPARE(int, a, b);
}

int less_uint32(CVP a, CVP b) {
    return _SAFE_COMPARE(unsigned int, a, b);
}

int less_int64(CVP a, CVP b) {
    return _SAFE_COMPARE(long long, a, b);
}

int less_uint64(CVP a, CVP b) {
    return _SAFE_COMPARE(unsigned long long, a, b);
}

int less_float(CVP a, CVP b) {
    return (*(float *) a > *(float *) b) - (*(float *) a < *(float *) b);
}

int less_double(CVP a, CVP b) {
    return (*(double *) a > *(double *) b) - (*(double *) a < *(double *) b);
}

int less_string(CVP a, CVP b) {
    return strcmp(*(char **) a, *(char **) b);
}

int greater_int32(CVP a, CVP b) {
    return less_int32(b, a);
}

int greater_uint32(CVP a, CVP b) {
    return less_uint32(b, a);
}

int greater_int64(CVP a, CVP b) {
    return less_int64(b, a);
}

int greater_uint64(CVP a, CVP b) {
    return less_uint64(b, a);
}

int greater_float(CVP a, CVP b) {
    return less_float(b, a);
}

int greater_double(CVP a, CVP b) {
    return less_double(b, a);
}

int greater_string(CVP a, CVP b) {
    return less_string(b, a);
}

_OpenCSTLCompareFunc 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_t 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;
}

_OpenCSTLCompareFunc 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_t 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)


int _memcmp1(const void *a, const void *b) { return memcmp(a, b, 1); }
int _memcmp2(const void *a, const void *b) { return memcmp(a, b, 2); }
int _memcmp3(const void *a, const void *b) { return memcmp(a, b, 3); }
int _memcmp4(const void *a, const void *b) { return memcmp(a, b, 4); }
int _memcmp5(const void *a, const void *b) { return memcmp(a, b, 5); }
int _memcmp6(const void *a, const void *b) { return memcmp(a, b, 6); }
int _memcmp7(const void *a, const void *b) { return memcmp(a, b, 7); }
int _memcmp8(const void *a, const void *b) { return memcmp(a, b, 8); }
int _memcmp9(const void *a, const void *b) { return memcmp(a, b, 9); }
int _memcmp10(const void *a, const void *b) { return memcmp(a, b, 10); }
int _memcmp11(const void *a, const void *b) { return memcmp(a, b, 11); }
int _memcmp12(const void *a, const void *b) { return memcmp(a, b, 12); }
int _memcmp13(const void *a, const void *b) { return memcmp(a, b, 13); }
int _memcmp14(const void *a, const void *b) { return memcmp(a, b, 14); }
int _memcmp15(const void *a, const void *b) { return memcmp(a, b, 15); }
int _memcmp16(const void *a, const void *b) { return memcmp(a, b, 16); }
int _memcmp17(const void *a, const void *b) { return memcmp(a, b, 17); }
int _memcmp18(const void *a, const void *b) { return memcmp(a, b, 18); }
int _memcmp19(const void *a, const void *b) { return memcmp(a, b, 19); }
int _memcmp20(const void *a, const void *b) { return memcmp(a, b, 20); }
int _memcmp21(const void *a, const void *b) { return memcmp(a, b, 21); }
int _memcmp22(const void *a, const void *b) { return memcmp(a, b, 22); }
int _memcmp23(const void *a, const void *b) { return memcmp(a, b, 23); }
int _memcmp24(const void *a, const void *b) { return memcmp(a, b, 24); }
int _memcmp25(const void *a, const void *b) { return memcmp(a, b, 25); }
int _memcmp26(const void *a, const void *b) { return memcmp(a, b, 26); }
int _memcmp27(const void *a, const void *b) { return memcmp(a, b, 27); }
int _memcmp28(const void *a, const void *b) { return memcmp(a, b, 28); }
int _memcmp29(const void *a, const void *b) { return memcmp(a, b, 29); }
int _memcmp30(const void *a, const void *b) { return memcmp(a, b, 30); }
int _memcmp31(const void *a, const void *b) { return memcmp(a, b, 31); }
int _memcmp32(const void *a, const void *b) { return memcmp(a, b, 32); }
int _memcmp33(const void *a, const void *b) { return memcmp(a, b, 33); }
int _memcmp34(const void *a, const void *b) { return memcmp(a, b, 34); }
int _memcmp35(const void *a, const void *b) { return memcmp(a, b, 35); }
int _memcmp36(const void *a, const void *b) { return memcmp(a, b, 36); }
int _memcmp37(const void *a, const void *b) { return memcmp(a, b, 37); }
int _memcmp38(const void *a, const void *b) { return memcmp(a, b, 38); }
int _memcmp39(const void *a, const void *b) { return memcmp(a, b, 39); }
int _memcmp40(const void *a, const void *b) { return memcmp(a, b, 40); }
int _memcmp41(const void *a, const void *b) { return memcmp(a, b, 41); }
int _memcmp42(const void *a, const void *b) { return memcmp(a, b, 42); }
int _memcmp43(const void *a, const void *b) { return memcmp(a, b, 43); }
int _memcmp44(const void *a, const void *b) { return memcmp(a, b, 44); }
int _memcmp45(const void *a, const void *b) { return memcmp(a, b, 45); }
int _memcmp46(const void *a, const void *b) { return memcmp(a, b, 46); }
int _memcmp47(const void *a, const void *b) { return memcmp(a, b, 47); }
int _memcmp48(const void *a, const void *b) { return memcmp(a, b, 48); }
int _memcmp49(const void *a, const void *b) { return memcmp(a, b, 49); }
int _memcmp50(const void *a, const void *b) { return memcmp(a, b, 50); }
int _memcmp51(const void *a, const void *b) { return memcmp(a, b, 51); }
int _memcmp52(const void *a, const void *b) { return memcmp(a, b, 52); }
int _memcmp53(const void *a, const void *b) { return memcmp(a, b, 53); }
int _memcmp54(const void *a, const void *b) { return memcmp(a, b, 54); }
int _memcmp55(const void *a, const void *b) { return memcmp(a, b, 55); }
int _memcmp56(const void *a, const void *b) { return memcmp(a, b, 56); }
int _memcmp57(const void *a, const void *b) { return memcmp(a, b, 57); }
int _memcmp58(const void *a, const void *b) { return memcmp(a, b, 58); }
int _memcmp59(const void *a, const void *b) { return memcmp(a, b, 59); }
int _memcmp60(const void *a, const void *b) { return memcmp(a, b, 60); }
int _memcmp61(const void *a, const void *b) { return memcmp(a, b, 61); }
int _memcmp62(const void *a, const void *b) { return memcmp(a, b, 62); }
int _memcmp63(const void *a, const void *b) { return memcmp(a, b, 63); }
int _memcmp64(const void *a, const void *b) { return memcmp(a, b, 64); }
int _memcmp65(const void *a, const void *b) { return memcmp(a, b, 65); }
int _memcmp66(const void *a, const void *b) { return memcmp(a, b, 66); }
int _memcmp67(const void *a, const void *b) { return memcmp(a, b, 67); }
int _memcmp68(const void *a, const void *b) { return memcmp(a, b, 68); }
int _memcmp69(const void *a, const void *b) { return memcmp(a, b, 69); }
int _memcmp70(const void *a, const void *b) { return memcmp(a, b, 70); }
int _memcmp71(const void *a, const void *b) { return memcmp(a, b, 71); }
int _memcmp72(const void *a, const void *b) { return memcmp(a, b, 72); }
int _memcmp73(const void *a, const void *b) { return memcmp(a, b, 73); }
int _memcmp74(const void *a, const void *b) { return memcmp(a, b, 74); }
int _memcmp75(const void *a, const void *b) { return memcmp(a, b, 75); }
int _memcmp76(const void *a, const void *b) { return memcmp(a, b, 76); }
int _memcmp77(const void *a, const void *b) { return memcmp(a, b, 77); }
int _memcmp78(const void *a, const void *b) { return memcmp(a, b, 78); }
int _memcmp79(const void *a, const void *b) { return memcmp(a, b, 79); }
int _memcmp80(const void *a, const void *b) { return memcmp(a, b, 80); }
int _memcmp81(const void *a, const void *b) { return memcmp(a, b, 81); }
int _memcmp82(const void *a, const void *b) { return memcmp(a, b, 82); }
int _memcmp83(const void *a, const void *b) { return memcmp(a, b, 83); }
int _memcmp84(const void *a, const void *b) { return memcmp(a, b, 84); }
int _memcmp85(const void *a, const void *b) { return memcmp(a, b, 85); }
int _memcmp86(const void *a, const void *b) { return memcmp(a, b, 86); }
int _memcmp87(const void *a, const void *b) { return memcmp(a, b, 87); }
int _memcmp88(const void *a, const void *b) { return memcmp(a, b, 88); }
int _memcmp89(const void *a, const void *b) { return memcmp(a, b, 89); }
int _memcmp90(const void *a, const void *b) { return memcmp(a, b, 90); }
int _memcmp91(const void *a, const void *b) { return memcmp(a, b, 91); }
int _memcmp92(const void *a, const void *b) { return memcmp(a, b, 92); }
int _memcmp93(const void *a, const void *b) { return memcmp(a, b, 93); }
int _memcmp94(const void *a, const void *b) { return memcmp(a, b, 94); }
int _memcmp95(const void *a, const void *b) { return memcmp(a, b, 95); }
int _memcmp96(const void *a, const void *b) { return memcmp(a, b, 96); }
int _memcmp97(const void *a, const void *b) { return memcmp(a, b, 97); }
int _memcmp98(const void *a, const void *b) { return memcmp(a, b, 98); }
int _memcmp99(const void *a, const void *b) { return memcmp(a, b, 99); }
int _memcmp100(const void *a, const void *b) { return memcmp(a, b, 100); }
int _memcmp101(const void *a, const void *b) { return memcmp(a, b, 101); }
int _memcmp102(const void *a, const void *b) { return memcmp(a, b, 102); }
int _memcmp103(const void *a, const void *b) { return memcmp(a, b, 103); }
int _memcmp104(const void *a, const void *b) { return memcmp(a, b, 104); }
int _memcmp105(const void *a, const void *b) { return memcmp(a, b, 105); }
int _memcmp106(const void *a, const void *b) { return memcmp(a, b, 106); }
int _memcmp107(const void *a, const void *b) { return memcmp(a, b, 107); }
int _memcmp108(const void *a, const void *b) { return memcmp(a, b, 108); }
int _memcmp109(const void *a, const void *b) { return memcmp(a, b, 109); }
int _memcmp110(const void *a, const void *b) { return memcmp(a, b, 110); }
int _memcmp111(const void *a, const void *b) { return memcmp(a, b, 111); }
int _memcmp112(const void *a, const void *b) { return memcmp(a, b, 112); }
int _memcmp113(const void *a, const void *b) { return memcmp(a, b, 113); }
int _memcmp114(const void *a, const void *b) { return memcmp(a, b, 114); }
int _memcmp115(const void *a, const void *b) { return memcmp(a, b, 115); }
int _memcmp116(const void *a, const void *b) { return memcmp(a, b, 116); }
int _memcmp117(const void *a, const void *b) { return memcmp(a, b, 117); }
int _memcmp118(const void *a, const void *b) { return memcmp(a, b, 118); }
int _memcmp119(const void *a, const void *b) { return memcmp(a, b, 119); }
int _memcmp120(const void *a, const void *b) { return memcmp(a, b, 120); }
int _memcmp121(const void *a, const void *b) { return memcmp(a, b, 121); }
int _memcmp122(const void *a, const void *b) { return memcmp(a, b, 122); }
int _memcmp123(const void *a, const void *b) { return memcmp(a, b, 123); }
int _memcmp124(const void *a, const void *b) { return memcmp(a, b, 124); }
int _memcmp125(const void *a, const void *b) { return memcmp(a, b, 125); }
int _memcmp126(const void *a, const void *b) { return memcmp(a, b, 126); }
int _memcmp127(const void *a, const void *b) { return memcmp(a, b, 127); }
int _memcmp128(const void *a, const void *b) { return memcmp(a, b, 128); }
_OpenCSTLCompareFunc _memcmp_funcs[128 + 1] = {
    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,
};


#endif //OPENCSTL_COMPARE_H

// ==============================================================================
// END    compare.h
// ==============================================================================

// ==============================================================================
// BEGIN  iterator.h                     (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#ifndef OPENCSTL_ITERATOR_H
#define OPENCSTL_ITERATOR_H
// [already included: hashtable.h]
// [already included: error.h]
// [already included: vector.h]
// [already included: list.h]
// [already included: rbtree.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_t 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);
        }
    }
    size_t 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: {
            yikes("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);
        }
    }
    size_t 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: {
            yikes("Invalid operation");
        }
    }
    return NULL;
}

OPENCSTL_FUNC void *_cstl_begin(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        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: yikes("Invalid operation");
            break;
    }
    return NULL;
}

OPENCSTL_FUNC void *_cstl_rbegin(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        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: yikes("Invalid operation");
            break;
    }
    return NULL;
}

OPENCSTL_FUNC void *_cstl_end(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        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: yikes("Invalid operation");
            break;
    }
    return NULL;
}

OPENCSTL_FUNC void *_cstl_rend(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        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: yikes("Invalid operation");
            break;
    }
    return NULL;
}
#endif //OPENCSTL_ITERATOR_H

// ==============================================================================
// END    iterator.h
// ==============================================================================
// [already included: van_emde_boas_tree.h]

bool is_even(void *it) {
    return true;
}

#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_t _value_size) {
    void *it = _begin;
    while (it != _end) {
        memcpy(it, _value, _value_size);
        it = cstl_next(it);
    }
}

// ███╗░░░███╗██╗███╗░░██╗░░░░░░░░░░░██╗░░░░░░░███╗░░░███╗░█████╗░██╗░░██╗
// ████╗░████║██║████╗░██║░░░░░░░░░░██╔╝░░░░░░░████╗░████║██╔══██╗╚██╗██╔╝
// ██╔████╔██║██║██╔██╗██║░░░░░░░░░██╔╝░░░░░░░░██╔████╔██║███████║░╚███╔╝░
// ██║╚██╔╝██║██║██║╚████║░░░░░░░░██╔╝░░░░░░░░░██║╚██╔╝██║██╔══██║░██╔██╗░
// ██║░╚═╝░██║██║██║░╚███║░░░░░░░██╔╝░░░░░░░░░░██║░╚═╝░██║██║░░██║██╔╝╚██╗
// ╚═╝░░░░░╚═╝╚═╝╚═╝░░╚══╝░░░░░░░╚═╝░░░░░░░░░░░╚═╝░░░░░╚═╝╚═╝░░╚═╝╚═╝░░╚═╝

#ifndef MAX
#define MAX(a,b) ((a)>(b)?(a):(b))
#endif
#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif


#define max_element(...) _MAX_ELEMENT_DISPATCH(__VA_ARGS__, NULL)
#define _MAX_ELEMENT_DISPATCH(_begin, _end, _cmp, ...) _cstl_max_element(_begin, _end, (_OpenCSTLCompareFunc)(_cmp))

OPENCSTL_FUNC void *_cstl_max_element(void *_begin, void *_end, _OpenCSTLCompareFunc _cmp) {
    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 (_cmp(it, max_it) > 0) {
            max_it = it;
        }
        it = cstl_next(it);
    }
    return max_it;
}

#define min_element(...) _MIN_ELEMENT_DISPATCH(__VA_ARGS__, NULL)
#define _MIN_ELEMENT_DISPATCH(_begin, _end, _cmp, ...) _cstl_min_element(_begin, _end, (_OpenCSTLCompareFunc)(_cmp))

OPENCSTL_FUNC void *_cstl_min_element(void *_begin, void *_end, _OpenCSTLCompareFunc _cmp) {
    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 *min_it = _begin;
    void *it = cstl_next(_begin);
    while (it != _end) {
        if (_cmp(it, min_it) < 0) {
            min_it = it;
        }
        it = cstl_next(it);
    }
    return min_it;
}

#endif //_OPENCSTL_C_ALGORITHM_H

// ==============================================================================
// END    algorithm.h
// ==============================================================================

// [already included: compare.h]

// ==============================================================================
// BEGIN  mt19937.h                      (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(OPENCSTL_MT19937_H)
#define OPENCSTL_MT19937_H
#include <stdint.h>
#include <time.h>
// [already included: defines.h]
// [already included: deque.h]
// [already included: list.h]
// [already included: swap.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;
}


// [0, 2^64 - 1]
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++];

    // tempering
    y ^= (y >> 29) & 0x5555555555555555ULL;
    y ^= (y << 17) & 0x71D67FFFEDA60000ULL;
    y ^= (y << 37) & 0xFFF7EEE000000000ULL;
    y ^= (y >> 43);

    return y;
}

// [0, 1) uniform real
static double __mt19937_random(void) {
    return (double) (__mt19937_64_next() >> 11) * (1.0 / 9007199254740992.0);
}


// [lo, hi] inclusive integer range (supports negative)
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;
    // time_low: 8자 (hi >> 32)
    for (int i = 60; i >= 32; i -= 4)
        buf[p++] = hex[(hi >> i) & 0xF];
    buf[p++] = '-';
    // time_mid: 4자 (hi >> 16)
    for (int i = 28; i >= 16; i -= 4)
        buf[p++] = hex[(hi >> i) & 0xF];
    buf[p++] = '-';
    // time_hi_and_version: 4자 (hi >> 0)
    for (int i = 12; i >= 0; i -= 4)
        buf[p++] = hex[(hi >> i) & 0xF];
    buf[p++] = '-';
    // clock_seq: 4자 (lo >> 48)
    for (int i = 60; i >= 48; i -= 4)
        buf[p++] = hex[(lo >> i) & 0xF];
    buf[p++] = '-';
    // node: 12자 (lo >> 0)
    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_t type_size = OPENCSTL_NIDX(container, NIDX_TSIZE);
    size_t length = OPENCSTL_NIDX(container, -1);

    for (size_t i = length - 1; i > 0; i--) {
        size_t 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_t type_size = *(size_t *) ((char *) *(void **) container + NIDX_TSIZE * sizeof(size_t) + distance);
    size_t length = *(size_t *) ((char *) *(void **) container + -2 * sizeof(size_t) + distance);

    for (size_t i = length - 1; i > 0; i--) {
        size_t 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_t 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;

    // Copy list data to flat array
    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);
    }
    // Fisher-Yates shuffle on flat array
    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);
    }
    // Copy shuffled data back to list nodes
    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_t container_type;
    if (__is_deque((void **) &container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)&container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) &container + NIDX_CTYPE * sizeof(size_t) + 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: yikes("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
};

#endif //OPENCSTL_MT19937_H

// ==============================================================================
// END    mt19937.h
// ==============================================================================

// ==============================================================================
// BEGIN  chrono.h                       (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_CSTL_TICKTOCK_H)
#define _OPENCSTL_CSTL_TICKTOCK_H
#include <stdio.h>

#if defined(_WIN32) || defined(_WIN64) || defined(_MSC_VER)

#include <windows.h>

typedef LARGE_INTEGER watch;

static watch _now() {
    watch t;
    QueryPerformanceCounter(&t);
    return t;
}

static double _duration(const watch t_beg, const watch t_end) {
    LARGE_INTEGER freq;
    QueryPerformanceFrequency(&freq);
    double ms = (double) (t_end.QuadPart - t_beg.QuadPart) * 1000.0 / (double) freq.QuadPart;
    return ms > 0 ? ms : -ms;
}

#elif defined(__MINGW32__) || defined(__MINGW64__) || defined(__GNUC__) || defined(__TINYC__)

#include <sys/time.h>
#include <time.h>

typedef struct timeval watch;

static watch _now(void) {
    watch tv;
    gettimeofday(&tv, NULL);
    return tv;
}

static double _duration(const watch t_beg, const watch t_end) {
    double ms = (t_end.tv_sec - t_beg.tv_sec) * 1000.0 +
                (t_end.tv_usec - t_beg.tv_usec) / 1000.0;
    return ms > 0 ? ms : -ms;
}


#else
#error Unsupported compiler/platform
#endif
typedef watch (*now_fn)(void);

typedef double (*duration_fn)(const watch, const watch);

typedef struct {
    now_fn now;
    duration_fn duration;
} CHRONO;

static CHRONO chrono = {
    _now,
    _duration,
};
#endif

// ==============================================================================
// END    chrono.h
// ==============================================================================

// ==============================================================================
// BEGIN  fstream.h                      (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#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_t 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_t 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_t 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_t len = strlen(buf);
    fwrite(buf, 1, len, new_fp) == len;
    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_t *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 fstream = {
    __cstl_fopen,
    __cstl_fclose,
    __cstl_get_line,
    __cstl_fread_all,
    __cstl_fwrite_all
};


#endif //_OPENCSTL_CSTL_FILE_H

// ==============================================================================
// END    fstream.h
// ==============================================================================

// ==============================================================================
// BEGIN  filesystem.h                   (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#ifndef OPENCSTL_FILESYSTEM_H
#define OPENCSTL_FILESYSTEM_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
// [already included: zalloc.h]
// [already included: tracer.h]
// [already included: crossplatform.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_t l = strlen(path2);
        char *ret = (char *) malloc(l + 1);
        memcpy(ret, path2, l + 1);
        return ret;
    }
    size_t l1 = strlen(path1);
    size_t 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_t total = l1 + (need_sep ? 1 : 0) + l2;
    char *ret = (char *) malloc(total + 1);
    memcpy(ret, path1, l1);
    size_t 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_t len = strlen(path);
    size_t start = 0;
    for (size_t i = 0; i < len; i++) {
        if (__cstl_is_sep(path[i])) start = i + 1;
    }
    size_t 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_t len = strlen(path);
    size_t base_start = 0;
    for (size_t i = 0; i < len; i++) {
        if (__cstl_is_sep(path[i])) base_start = i + 1;
    }
    size_t nonleading = base_start;
    while (nonleading < len && path[nonleading] == '.') nonleading++;
    size_t dot_pos = (size_t) -1;
    for (size_t i = nonleading; i < len; i++) {
        if (path[i] == '.') dot_pos = i;
    }
    size_t root_len = (dot_pos == (size_t) -1) ? len : dot_pos;
    size_t ext_len = (dot_pos == (size_t) -1) ? 0 : (len - dot_pos);
    size_t 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_t __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_t) sz.QuadPart;
#else
    struct stat st;
    if (stat(path, &st) != 0) return 0;
    return (size_t) st.st_size;
#endif
}

static void __cstl_makedirs(char *path) {
    size_t len = strlen(path);
    if (len == 0) return;
    char *tmp = (char *) malloc(len + 1);
    memcpy(tmp, path, len + 1);
    for (size_t 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_t len = strlen(path);
    size_t last_sep = (size_t) -1;
    for (size_t i = 0; i < len; i++) {
        if (__cstl_is_sep(path[i])) last_sep = i;
    }
    if (last_sep == (size_t) -1) {
        char *ret = (char *) malloc(1);
        ret[0] = '\0';
        return ret;
    }
    size_t 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_t l = strlen(resolved);
        char *ret = (char *) malloc(l + 1);
        memcpy(ret, resolved, l + 1);
        return ret;
    }
    if (path[0] == '/') {
        size_t 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_t 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_t (*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 // OPENCSTL_FILESYSTEM_H

// ==============================================================================
// END    filesystem.h
// ==============================================================================


// ==============================================================================
// BEGIN  sort.h                         (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//

#if !defined(_OPENCSTL_SORT_H)
#define _OPENCSTL_SORT_H
#include <stdlib.h>
#include <string.h>
// [already included: crossplatform.h]

// ==============================================================================
// BEGIN  msort.h                        (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_MSORT_H)
#define _OPENCSTL_MSORT_H
#include <stdlib.h>
#include <string.h>

// ==============================================================================
// BEGIN  isort.h                        (depth 3)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_ISORT_H)
#define _OPENCSTL_ISORT_H


#include <stdlib.h>
#include <string.h>
// [already included: types.h]

static void isort(void *base, size_t number, size_t width, CSTL_COMPARE compare) {
    char *arr = (char *) base;
    char sbuf[1024];
    char *tmp = (width <= sizeof(sbuf)) ? sbuf : (char *) malloc(width);
    for (size_t i = 1; i < number; i++) {
        memcpy(tmp, arr + i * width, width);
        size_t lo = 0, hi = i;
        while (lo < hi) {
            size_t 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

// ==============================================================================
// END    isort.h
// ==============================================================================
#define MSORT_ISORT_THRESH 32


static void msort_merge(char *arr, size_t len1, size_t len2, size_t 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_t) (e1 - c1));
    } else {
        memcpy(buf, arr + len1 * sz, len2 * sz);
        size_t 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_t number, size_t width, CSTL_COMPARE compare) {
    if (number < 2) return;
    char *arr = (char *) base;
    size_t sz = width;
    for (size_t i = 0; i < number; i += MSORT_ISORT_THRESH) {
        size_t 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_t mb = MSORT_ISORT_THRESH; mb < number; mb *= 2) {
        for (size_t i = 0; i + mb < number; i += 2 * mb) {
            size_t len1 = mb;
            size_t len2 = number - i - mb;
            if (len2 > mb) len2 = mb;
            msort_merge(arr + i * sz, len1, len2, sz, compare, buf);
        }
    }
    free(buf);
}

#endif

// ==============================================================================
// END    msort.h
// ==============================================================================

// ==============================================================================
// BEGIN  tsort.h                        (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#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_t base;
    size_t len;
};

static inline size_t ts_minrun(size_t n) {
    size_t r = 0;
    while (n >= TS_MIN_MERGE) {
        r |= (n & 1);
        n >>= 1;
    }
    return n + r;
}

static void ts_binsort(char *arr, size_t lo, size_t hi, size_t start,
                       size_t sz, CSTL_COMPARE cmp) {
    char sbuf[1024];
    char *tmp = (sz <= sizeof(sbuf)) ? sbuf : (char *) malloc(sz);
    for (size_t i = start; i < hi; i++) {
        memcpy(tmp, arr + i * sz, sz);
        size_t left = lo, right = i;
        while (left < right) {
            size_t 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_t ts_count_run(char *arr, size_t lo, size_t hi,
                           size_t sz, CSTL_COMPARE cmp) {
    if (hi - lo < 2) return hi - lo;
    size_t 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_t 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_t ts_gallop_right(const char *key, const char *a, size_t n,
                              size_t sz, CSTL_COMPARE cmp) {
    if (n == 0 || cmp(key, a) < 0) return 0;
    size_t 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_t lo = last + 1, hi = ofs;
    while (lo < hi) {
        size_t m = lo + ((hi - lo) >> 1);
        if (cmp(key, a + m * sz) >= 0) lo = m + 1;
        else hi = m;
    }
    return lo;
}

static size_t ts_gallop_left(const char *key, const char *a, size_t n,
                             size_t sz, CSTL_COMPARE cmp) {
    if (n == 0 || cmp(key, a) <= 0) return 0;
    size_t 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_t lo = last + 1, hi = ofs;
    while (lo < hi) {
        size_t 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_t len1, size_t len2,
                        size_t 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_t mg = TS_MIN_GALLOP;
    for (;;) {
        size_t 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_t) (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_t) (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_t) (e1 - c1));
}

static void ts_merge_hi(char *base, size_t len1, size_t len2,
                        size_t sz, CSTL_COMPARE cmp, char *buf) {
    memcpy(buf, base + len1 * sz, len2 * sz);
    size_t i = len1, j = len2;
    size_t 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_t base1, size_t len1,
                               size_t len2, size_t sz, CSTL_COMPARE cmp,
                               char *buf) {
    size_t 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_t *sp,
                              size_t sz, CSTL_COMPARE cmp, char *buf) {
    while (*sp > 1) {
        size_t 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_t 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_t *sp,
                           size_t sz, CSTL_COMPARE cmp, char *buf) {
    while (*sp > 1) {
        size_t 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_t i = n + 1; i + 1 < *sp; i++)
            stk[i] = stk[i + 1];
        (*sp)--;
    }
}

static void tsort(void *base, const size_t number, const size_t width, CSTL_COMPARE cmp) {
    if (number < 2) return;
    char *arr = (char *) base;
    size_t sz = width;
    if (number < TS_MIN_MERGE) {
        size_t 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_t sp = 0;
    size_t minrun = ts_minrun(number);
    size_t lo = 0;
    while (lo < number) {
        size_t run_len = ts_count_run(arr, lo, number, sz, cmp);
        if (run_len < minrun) {
            size_t 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

// ==============================================================================
// END    tsort.h
// ==============================================================================

// ==============================================================================
// BEGIN  pdqsort.h                      (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#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 inline void pdq__swap(unsigned char *a, unsigned char *b, size_t 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_t 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_t pdq_log2(size_t n) {
    size_t r = 0;
    while (n > 1) {
        n >>= 1;
        ++r;
    }
    return r;
}

static void pdq_isort(unsigned char *base, size_t n, size_t sz,
                      int (*cmp)(const void *, const void *), unsigned char *tmp) {
    if (n < 2) return;
    for (size_t i = 1; i < n; ++i)
        if (cmp(PDQ_ELEM(base, i), base) < 0)
            pdq__swap(PDQ_ELEM(base, i), base, sz);
    for (size_t 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_t n, size_t sz,
                              int (*cmp)(const void *, const void *), unsigned char *tmp) {
    for (size_t 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_t n, size_t sz,
                             int (*cmp)(const void *, const void *), unsigned char *tmp) {
    if (n < 2) return 1;
    size_t cnt = 0;
    for (size_t 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_t a, size_t b,
                         size_t 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_t a, size_t b, size_t c,
                         size_t 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_t n, size_t sz,
                          int (*cmp)(const void *, const void *)) {
    size_t mid = n >> 1;
    int sw = 0;
    if (n >= PDQ_NINTHER_THRESH) {
        size_t 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_t root, size_t n,
                     size_t sz, int (*cmp)(const void *, const void *)) {
    for (;;) {
        size_t c = root * 2 + 1;
        if (c >= n) break;
        size_t 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_t n, size_t sz, int (*cmp)(const void *, const void *)) {
    if (n < 2) return;
    for (size_t i = n / 2; i-- > 0;) pdq_sift(base, i, n, sz, cmp);
    for (size_t 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_t n, size_t sz, uint64_t *rs) {
    if (n < 8) return;
    size_t 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_t pdq_part_r(unsigned char *base, size_t n, size_t 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_t) (pp - base) / sz;
}

static inline size_t pdq_part_l(unsigned char *base, size_t n, size_t 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_t) (hi - base) / sz;
}

static void pdqsort(void *base, size_t number, size_t width, CSTL_COMPARE cmp) {
    if (!base || !cmp || width == 0 || number < 2) return;
    const size_t sz = width;

    unsigned char *arr = (unsigned char *) base;
    unsigned char sbuf[512];
    unsigned char *scratch;
    size_t 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_t n;
        size_t 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_t n = stk[sp].n;
        size_t 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_t 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_t pp = pdq_part_r(base, n, sz, cmp, piv, &ap);
        size_t lsz = pp;
        size_t 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

// ==============================================================================
// END    pdqsort.h
// ==============================================================================
// [already included: deque.h]

// ==============================================================================
// BEGIN  pmsort.h                       (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_PMSORT_H)
#define _OPENCSTL_PMSORT_H

// ==============================================================================
// BEGIN  pthread_cc.h                   (depth 3)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#ifndef OPENCSTL_PTHREAD_H
#define OPENCSTL_PTHREAD_H
#ifdef __cplusplus
extern "C" {



#endif
// [already included: crossplatform.h]
#if defined(OCSTL_OS_WINDOWS)

#include<windows.h>
#include<process.h>
#include<errno.h>
#include<assert.h>
#if !defined(sleep)
#define sleep(num) Sleep(1000*(num))
#endif
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_t index;
    struct _pthread_cleanup_stack *next;
} _pthread_cleanup_stack;

__declspec(selectany) _pthread_cleanup_stack *_pthread_cleanup_stack_head= NULL;
__declspec(selectany) HANDLE _pthread_cleanup_mutex= NULL;

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

inline 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);
}

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

inline pthread_t pthread_self(void) {
    pthread_t pt;
    pt.handle = GetCurrentThread();
    return pt;
}

inline int pthread_detach(pthread_t thread) {
    CloseHandle(thread.handle);
}

inline int pthread_cancel(pthread_t thread) {
    TerminateThread(thread.handle, 1);
    return 0;
}

inline 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;
            assert((*head)->index >= 0);
            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);
}

inline int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) {
    return 0;
}

inline int pthread_mutexattr_init(pthread_mutexattr_t *attr) {
    return 0;
}

inline int pthread_mutex_destroy(pthread_mutex_t *mutex) {
    return !CloseHandle(mutex->handle);
}

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

inline int pthread_mutex_lock(pthread_mutex_t *mutex) {
    return (WaitForSingleObject(mutex->handle, INFINITE) == WAIT_OBJECT_0) ? 0 : EINVAL;
}

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

inline int pthread_mutex_unlock(pthread_mutex_t *mutex) {
    return !ReleaseMutex(mutex->handle);
}

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

inline int pthread_key_delete(pthread_key_t key) {
    return TlsFree(key) ? 0 : EINVAL;
}

inline int pthread_setspecific(pthread_key_t key, const void *pointer) {
    return TlsSetValue(key, (LPVOID) pointer) ? 0 : EINVAL;
}

inline void *pthread_getspecific(pthread_key_t key) {
    return TlsGetValue(key);
}
#else
#include <pthread.h>
#endif
#ifdef __cplusplus
}
#endif

#endif //OPENCSTL_PTHREAD_H

// ==============================================================================
// END    pthread_cc.h
// ==============================================================================
#include <stdlib.h>
#include <string.h>
// [already included: msort.h]
#ifndef PS_MAX_DEPTH
#define PS_MAX_DEPTH 4
#endif

#ifndef PS_SEQ_CUTOFF
#define PS_SEQ_CUTOFF 4096
#endif

typedef int (*ps_cmp_t)(const void *, const void *);

struct ps_args {
    char *base;
    char *buf;
    size_t n;
    size_t sz;
    ps_cmp_t cmp;
    int depth;
};

static void ps_merge(char *base, char *buf, size_t n1, size_t n2,
                     size_t sz, ps_cmp_t 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_t) (l_end - l));
    if (r < r_end)
        memcpy(d, r, (size_t) (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_t 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_t number, const size_t 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

// ==============================================================================
// END    pmsort.h
// ==============================================================================
// [already included: list.h]
// [already included: defines.h]

// [already included: compare.h]

// ==============================================================================
// BEGIN  bestsort.h                     (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//

#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 //OPENCSTL_BESTSORT_H
// ==============================================================================
// END    bestsort.h
// ==============================================================================

// ==============================================================================
// BEGIN  rsort.h                        (depth 2)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//

#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_t n) {
    if (__base == NULL || n <= 1) {
        return;
    }

    int32_t *tmp = (int32_t *) malloc(n * sizeof(int32_t));
    if (tmp == NULL) {
        return;
    }

    {
        size_t count[256];
        size_t pass, i;
        uint32_t sign_mask = (uint32_t) 1u << (sizeof(int32_t) * CHAR_BIT - 1);

        for (pass = 0; pass < sizeof(int32_t); ++pass) {
            size_t 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_t n) {
    if (__base == NULL || n <= 1) {
        return;
    }

    int64_t *tmp = (int64_t *) malloc(n * sizeof(int64_t));
    if (tmp == NULL) {
        return;
    }

    {
        size_t count[256];
        size_t pass, i;
        uint64_t sign_mask = (uint64_t) 1ULL << (sizeof(int64_t) * CHAR_BIT - 1);

        for (pass = 0; pass < sizeof(int64_t); ++pass) {
            size_t 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 //OPENCSTL_RSORT_H

// ==============================================================================
// END    rsort.h
// ==============================================================================
// #if !defined(cstl_stable_sort)
// #define cstl_stable_sort tsort
// #endif
// #if !defined(cstl_unstable_sort)
// #define cstl_unstable_sort pdqsort
// #endif

// ██╗░░░██╗███╗░░██╗░██████╗████████╗░█████╗░██████╗░██╗░░░░░███████╗░░░░░░░██████╗░█████╗░██████╗░████████╗
// ██║░░░██║████╗░██║██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██║░░░░░██╔════╝░░░░░░██╔════╝██╔══██╗██╔══██╗╚══██╔══╝
// ██║░░░██║██╔██╗██║╚█████╗░░░░██║░░░███████║██████╦╝██║░░░░░█████╗░░░░░░░░╚█████╗░██║░░██║██████╔╝░░░██║░░░
// ██║░░░██║██║╚████║░╚═══██╗░░░██║░░░██╔══██║██╔══██╗██║░░░░░██╔══╝░░░░░░░░░╚═══██╗██║░░██║██╔══██╗░░░██║░░░
// ╚██████╔╝██║░╚███║██████╔╝░░░██║░░░██║░░██║██████╦╝███████╗███████╗█████╗██████╔╝╚█████╔╝██║░░██║░░░██║░░░
// ░╚═════╝░╚═╝░░╚══╝╚═════╝░░░░╚═╝░░░╚═╝░░╚═╝╚═════╝░╚══════╝╚══════╝╚════╝╚═════╝░░╚════╝░╚═╝░░╚═╝░░░╚═╝░░░

#define _cstl_sort_func(CONTAINER,...) _CSTL_SORT_DISPATCH(CONTAINER, ##__VA_ARGS__, 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_t container_type = __opencstl_container_type((void **) &container, &distance);
    if (container_type == 0) return;

    switch (container_type) {
        case OPENCSTL_VECTOR: {
            size_t type_size = (size_t) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            size_t length = (size_t) OPENCSTL_NIDX(&container, -1);
            _OpenCSTLCompareFunc cmp = (_OpenCSTLCompareFunc) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                yikes("Compare function is NULL");
            }

            cstl_unstable_sort(container, length, type_size, cmp);
        }
        break;
        case OPENCSTL_LIST: {
            size_t type_size = (size_t) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            _OpenCSTLCompareFunc cmp = (_OpenCSTLCompareFunc) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                yikes("Compare function is NULL");
            }
            __cstl_list_qsort(&container, cmp);
        }
        break;
        case OPENCSTL_DEQUE: {
            size_t type_size = *(size_t *) ((char *) *(void **) &container + NIDX_TSIZE * sizeof(size_t) + distance);
            size_t length = *(size_t *) ((char *) *(void **) &container + -2 * sizeof(size_t) + distance);
            char *type_name = (char *) *(size_t *) ((char *) *(void **) &container + -4 * sizeof(size_t) + distance);
            _OpenCSTLCompareFunc cmp = (_OpenCSTLCompareFunc) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                yikes("Compare function is NULL");
            }
            cstl_unstable_sort(container, length, type_size, cmp);
        }
        break;
        default: {
            yikes("Invalid Operation");
        }
        break;
    }
}

// ░██████╗████████╗░█████╗░██████╗░██╗░░░░░███████╗░░░░░░░██████╗░█████╗░██████╗░████████╗
// ██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██║░░░░░██╔════╝░░░░░░██╔════╝██╔══██╗██╔══██╗╚══██╔══╝
// ╚█████╗░░░░██║░░░███████║██████╦╝██║░░░░░█████╗░░░░░░░░╚█████╗░██║░░██║██████╔╝░░░██║░░░
// ░╚═══██╗░░░██║░░░██╔══██║██╔══██╗██║░░░░░██╔══╝░░░░░░░░░╚═══██╗██║░░██║██╔══██╗░░░██║░░░
// ██████╔╝░░░██║░░░██║░░██║██████╦╝███████╗███████╗█████╗██████╔╝╚█████╔╝██║░░██║░░░██║░░░
// ╚═════╝░░░░╚═╝░░░╚═╝░░╚═╝╚═════╝░╚══════╝╚══════╝╚════╝╚═════╝░░╚════╝░╚═╝░░╚═╝░░░╚═╝░░░
#define _cstl_stable_sort_func(CONTAINER,...) _CSTL_STABLE_SORT_DISPATCH(CONTAINER, ##__VA_ARGS__, 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_t container_type = __opencstl_container_type((void **) &container, &distance);
    if (container_type == 0) return;

    switch (container_type) {
        case OPENCSTL_VECTOR: {
            size_t type_size = (size_t) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            size_t length = (size_t) OPENCSTL_NIDX(&container, -1);
            _OpenCSTLCompareFunc cmp = (_OpenCSTLCompareFunc) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                yikes("Compare function is NULL");
            }
            cstl_best_stable_sort(container, length, type_size, cmp);
        }
        break;
        case OPENCSTL_LIST: {
            size_t type_size = (size_t) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            _OpenCSTLCompareFunc cmp = (_OpenCSTLCompareFunc) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                yikes("Compare function is NULL");
            }
            __cstl_list_msort(&container, cmp);
        }
        break;
        case OPENCSTL_DEQUE: {
            size_t type_size = *(size_t *) ((char *) *(void **) &container + NIDX_TSIZE * sizeof(size_t) + distance);
            size_t length = *(size_t *) ((char *) *(void **) &container + -2 * sizeof(size_t) + distance);
            char *type_name = (char *) *(size_t *) ((char *) *(void **) &container + -4 * sizeof(size_t) + distance);
            _OpenCSTLCompareFunc cmp = (_OpenCSTLCompareFunc) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                yikes("Compare function is NULL");
            }
            cstl_best_stable_sort(container, length, type_size, cmp);
        }
        break;
        default: {
            yikes("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__)

// TCC supports typeof but not __auto_type; GCC/Clang support both.
#if defined(__TINYC__)
#define _CSTL_TYPEOF(x) typeof(x)
#else
#define _CSTL_TYPEOF(x) __auto_type
#endif

#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

// ██╗░██████╗░░░░░░░██████╗░█████╗░██████╗░████████╗███████╗██████╗░
// ██║██╔════╝░░░░░░██╔════╝██╔══██╗██╔══██╗╚══██╔══╝██╔════╝██╔══██╗
// ██║╚█████╗░░░░░░░╚█████╗░██║░░██║██████╔╝░░░██║░░░█████╗░░██║░░██║
// ██║░╚═══██╗░░░░░░░╚═══██╗██║░░██║██╔══██╗░░░██║░░░██╔══╝░░██║░░██║
// ██║██████╔╝█████╗██████╔╝╚█████╔╝██║░░██║░░░██║░░░███████╗██████╔╝
// ╚═╝╚═════╝░╚════╝╚═════╝░░╚════╝░╚═╝░░╚═╝░░░╚═╝░░░╚══════╝╚═════╝░
// [already included: iterator.h]
#define _cstl_is_sorted_func(CONTAINER,...) _CSTL_IS_SORTED_DISPATCH(CONTAINER, ##__VA_ARGS__, 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_t container_type = __opencstl_container_type((void **) &container, &distance);
    if (container_type == 0) return 0;

    switch (container_type) {
        case OPENCSTL_VECTOR: {
            size_t type_size = (size_t) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            size_t length = (size_t) OPENCSTL_NIDX(&container, -1);
            _OpenCSTLCompareFunc cmp = (_OpenCSTLCompareFunc) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                yikes("Compare function is NULL");
                return 0;
            }
            for (size_t i = 1; i < length; i++) {
                // cmp(a, b) > 0 means a > b, so prev > curr means not sorted
                if (cmp((char *) container + (i - 1) * type_size,
                        (char *) container + i * type_size) > 0) {
                    return 0;
                }
            }
            return 1;
        }
        break;
        case OPENCSTL_LIST: {
            size_t type_size = (size_t) OPENCSTL_NIDX(&container, NIDX_TSIZE);
            char *type_name = (char *) OPENCSTL_NIDX(&container, -4);
            _OpenCSTLCompareFunc cmp = (_OpenCSTLCompareFunc) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                yikes("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_t type_size = *(size_t *) ((char *) *(void **) &container + NIDX_TSIZE * sizeof(size_t) + distance);
            size_t length = *(size_t *) ((char *) *(void **) &container + -2 * sizeof(size_t) + distance);
            char *type_name = (char *) *(size_t *) ((char *) *(void **) &container + -4 * sizeof(size_t) + distance);
            _OpenCSTLCompareFunc cmp = (_OpenCSTLCompareFunc) _cmp;
            if (cmp == NULL) {
                cmp = CSTL_LESS(type_name);
            }
            if (cmp == NULL) {
                cmp = _memcmp_funcs[type_size];
            }
            if (cmp == NULL) {
                yikes("Compare function is NULL");
                return 0;
            }
            for (size_t 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: {
            yikes("Invalid Operation");
            return 0;
        }
        break;
    }
}

#if defined(USE_CSTL_FUNC)
#define is_sorted _cstl_is_sorted_func
#endif
#endif

// ==============================================================================
// END    sort.h
// ==============================================================================
// [already included: logging.h]

// ==============================================================================
// BEGIN  version.h                      (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(_OPENCSTL_VERSION_H)
#define _OPENCSTL_VERSION_H
// [already included: crossplatform.h]
static char *OPENCSTL_VERSION = "v1.2.9";

static char *opencstl_version(void) {
    return OPENCSTL_VERSION;
}

static char __opencstl_env_str[512] = {0};

char *opencstl_env(void) {
    sprintf(__opencstl_env_str, "%s, %s, %s", OCSTL_OS_STR, OCSTL_CC_STR, OCSTL_C_VERSION_STR);
    return __opencstl_env_str;
}
#endif //_OPENCSTL_VERSION_H

// ==============================================================================
// END    version.h
// ==============================================================================

// ==============================================================================
// BEGIN  bitset.h                       (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#if !defined(OPENCSTL_BITSET_H)
#define OPENCSTL_BITSET_H
// [already included: types.h]
// [already included: zalloc.h]
// [already included: crossplatform.h]

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

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)

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

// ██████╗░██╗████████╗░██████╗███████╗████████╗░░░░░░██╗███╗░░░███╗██████╗░██╗░░░░░
// ██╔══██╗██║╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝░░░░░░██║████╗░████║██╔══██╗██║░░░░░
// ██████╦╝██║░░░██║░░░╚█████╗░█████╗░░░░░██║░░░░░░░░░██║██╔████╔██║██████╔╝██║░░░░░
// ██╔══██╗██║░░░██║░░░░╚═══██╗██╔══╝░░░░░██║░░░░░░░░░██║██║╚██╔╝██║██╔═══╝░██║░░░░░
// ██████╦╝██║░░░██║░░░██████╔╝███████╗░░░██║░░░█████╗██║██║░╚═╝░██║██║░░░░░███████╗
// ╚═════╝░╚═╝░░░╚═╝░░░╚═════╝░╚══════╝░░░╚═╝░░░╚════╝╚═╝╚═╝░░░░░╚═╝╚═╝░░░░░╚══════╝
void __cstl_bitset_set(BITSET b) {
    // 모든 비트를 1로 설정
    size_type cap = __cstl_bitset_capacity(b.nbits);
    memset(b.bits, 0xFF, cap);
    // _size 이후의 여분 비트를 0으로 클리어
    size_type rem = b.nbits % 8;
    if (rem != 0) {
        b.bits[b.nbits / 8] &= (ubyte_x) ((1 << rem) - 1);
    }
}

void __cstl_bitset_reset(BITSET b) {
    // 모든 비트를 0으로 설정
    size_type cap = __cstl_bitset_capacity(b.nbits);
    memset(b.bits, 0, cap);
}

void __cstl_bitset_set_at(BITSET b, size_type idx, bool val) {
    // idx번째 비트를 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);
    }
}

size_type __cstl_bitset_count(BITSET b) {
    // 1로 설정된 비트의 개수를 반환
    size_type cap = __cstl_bitset_capacity(b.nbits);
    size_t count = 0;
    size_type i = 0;
    // 8바이트(64비트) 단위로 처리
    for (; i + 8 <= cap; i += 8) {
        long long chunk;
        memcpy(&chunk, b.bits + i, 8);
        count += __popcnt64(chunk);
    }
    // 남은 바이트를 4바이트 단위로 처리
    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 count;
}

bool __cstl_bitset_all(BITSET b) {
    // 모든 비트가 1인지 검사
    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;
}

bool __cstl_bitset_any(BITSET b) {
    // 하나라도 1인 비트가 있는지 검사
    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;
}

bool __cstl_bitset_none(BITSET b) {
    // 모든 비트가 0인지 검사
    return !__cstl_bitset_any(b);
}

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

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


size_type __cstl_bitset_nbits(BITSET b) {
    // 비트셋의 크기(비트 수)를 반환
    return b.nbits;
}

bool __cstl_bitset_test(BITSET b, size_type idx) {
    // 특정 위치의 비트가 1인지 검사
    size_type byte_idx = idx / 8;
    size_type bit_idx = idx % 8;
    return (b.bits[byte_idx] >> bit_idx) & 1;
}


char *__cstl_bitset_to_string(BITSET b) {
    // 비트셋을 문자열로 변환 (MSB가 앞, C++ bitset::to_string과 동일)
    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;
}

void __cstl_bitset_free(BITSET b) {
    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_fn1 free;
} __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,
    __cstl_bitset_free
};

#endif //OPENCSTL_BITSET_H

// ==============================================================================
// END    bitset.h
// ==============================================================================

// [already included: string.h]

// ==============================================================================
// BEGIN  glob.h                         (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//


#ifndef OPENCSTL_GLOB_H
#define OPENCSTL_GLOB_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
// [already included: crossplatform.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

// ────────────────────────────────────────────────────────────
// Filesystem helpers
// ────────────────────────────────────────────────────────────

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_t 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_t pos = la;
    if (need_sep) {
        r[pos++] = '/';
    }
    memcpy(r + pos, b, lb);
    r[pos + lb] = '\0';
    return r;
}

// Returns malloc'd char** (each entry malloc'd). "." and ".." excluded.
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_t plen = strlen(path);
    char *pat = (char *) malloc(plen + 3);
    memcpy(pat, path, plen);
    size_t 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_t 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_t 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;
}

// ────────────────────────────────────────────────────────────
// Internal: single-segment fnmatch (used by walker)
// ────────────────────────────────────────────────────────────

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

// ────────────────────────────────────────────────────────────
// Pattern parse: split "pattern" into base dir + segment list
// ────────────────────────────────────────────────────────────

static void __cstl_glob_parse_(const char *pat,
                               char **base_out, char ***segs_out, int *n_out) {
    size_t 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_t sl = (size_t) (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;
}

// ────────────────────────────────────────────────────────────
// Walker
// ────────────────────────────────────────────────────────────

typedef struct {
    char **items;
    int cnt;
    int cap;
} __cstl_glob_result_;

static void __cstl_glob_push_(__cstl_glob_result_ *r, const char *s) {
    // +1 for NULL terminator
    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_t 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];

    // ** — zero or more directories (recursive only)
    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);
}

// ────────────────────────────────────────────────────────────
// Public API
// ────────────────────────────────────────────────────────────

// Returns a NULL-terminated char** array. Iterate until *p == NULL.
// Free with glob_free().
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);

    // Ensure space for NULL sentinel
    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;

    // Normalize paths: backslash → forward slash, strip leading "./"
    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_t l = strlen(s);
            memmove(s, s + 2, l - 1); // includes '\0'
        }
    }
    return r.items;
}

static void glob_free(char **results) {
    if (!results) return;
    for (char **p = results; *p; p++) free(*p);
    free(results);
}

// Overload dispatch: glob(p) or glob(p, recursive)
#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 // OPENCSTL_GLOB_H
// ==============================================================================
// END    glob.h
// ==============================================================================

// ==============================================================================
// BEGIN  msg.h                          (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//

#if !defined(OPENCSTL_MSG_H)
#define OPENCSTL_MSG_H
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>
#include <stdarg.h>

static void MsgBoxCLI(const char *format, ...) {
#if defined(OCSTL_CC_MSVC)
    SetConsoleOutputCP(CP_UTF8);
#elif defined(OCSTL_CC_TCC)
    setvbuf(stdout, NULL, _IONBF, 0); // unbuffered — 바이트 단위 즉시 전송
#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_t) 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)
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(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");

    // 1) 사용자 메시지를 먼저 별도 버퍼에 포맷
    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;

// 2) MessageBoxExA 포인터 얻기 (컴파일러별)
#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

// 3) 컴파일러 무관하게 동일한 템플릿으로 본문 빌드
char path[MAX_PATH];
GetModuleFileNameA(NULL, path, sizeof(path));

char buf[2048]; // path(260) + userMsg(1024) + 템플릿 여유
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);

// 4) 다이얼로그 표시
    if (pMessageBoxExA) {
    r = pMessageBoxExA(
        NULL,
        buf,
        _MsgTitle(),
        MB_ABORTRETRYIGNORE | MB_ICONERROR | MB_DEFBUTTON3 | MB_TASKMODAL,
        0
    );
}

// 5) 정리는 반드시 MessageBox 호출 후에
    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>
struct lang_labels {
    const char *prefix; // LANG의 앞 2글자
    const char *abort_s;
    const char *retry_s;
    const char *ignore_s;
    const char *title_s; // "Runtime Library" 번역
};

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

    // "ko_KR.UTF-8" -> "ko" 비교
    for (int i = 0; kLangs[i].prefix; i++) {
        size_t n = strlen(kLangs[i].prefix);
        if (strncmp(lang, kLangs[i].prefix, n) == 0 &&
            (lang[n] == '\0' || lang[n] == '_' || lang[n] == '.')) {
            return &kLangs[i];
        }
    }
    // 마지막 엔트리(en) fallback
    int last = 0;
    while (kLangs[last + 1].prefix) last++;
    return &kLangs[last];
}

// MessageBoxExA 반환값과 동일한 상수 (이식성 위해)
#define IDABORT   3
#define IDRETRY   4
#define IDIGNORE  5

static void get_exe_path(char *out, size_t n) {
    ssize_t r = readlink("/proc/self/exe", out, n - 1);
    if (r < 0) r = 0;
    out[r] = '\0';
}

// Windows의 MessageBoxExA(MB_ABORTRETRYIGNORE|MB_ICONERROR) 대응
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) {
        // 자식: zenity 실행
        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);

        // zenity(GTK/Mesa)의 경고 메시지 버리기
        int devnull = open("/dev/null", O_WRONLY);
        if (devnull >= 0) {
            dup2(devnull, STDERR_FILENO);
            close(devnull);
        }

        execlp("zenity", "zenity",
               "--question",
               "--title", L->title_s, // title 인자도 로케일 반영하려면 이걸 사용
               "--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;

    // zenity 종료 코드:
    //   0  -> --ok-label (무시)          → IDIGNORE
    //   1  -> --cancel-label 또는 extra-button
    //         (extra-button을 눌렀다면 stdout에 라벨 문자열이 출력됨)
    //   5  -> 타임아웃
    if (code == 0) {
        return IDIGNORE; // --ok-label 클릭
    }
    size_t 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; // 취소 버튼, 창 닫기(X), Esc 모두 여기로
}

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[1024];
    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");
            __builtin_trap(); // = DebugBreak
        case IDIGNORE: fprintf(stderr, "ignore\n");
            break;
    }
}

#elif defined(OASTL_OS_MACOD)


#endif
#endif //OPENCSTL_MSG_H

// ==============================================================================
// END    msg.h
// ==============================================================================

// ==============================================================================
// BEGIN  json.h                         (depth 1)
// ==============================================================================

//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                               License Agreement
//                Open Source C Container Library like STL in C++
//
//               Copyright (C) 2026, Kim Bomm, all rights reserved.
//
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
#ifndef OPENCSTL_JSON_H
#define OPENCSTL_JSON_H
//#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#include<stdbool.h>
#if defined(OCSTL_CC_TCC)
// TCC는 strtok_s / strtok_r 둘 다 없으니 직접 구현
char *strtok_s(char *str, char *delimiters, char **last) {
    if (!delimiters || !last) return NULL;

    // 첫 호출이면 str에서, 재호출이면 저장된 위치에서 재개
    char *s = str ? str : *last;
    if (!s) return NULL;

    // 선행 delimiter 건너뛰기 (연속된 구분자는 하나로 취급)
    while (*s && strchr(delimiters, *s)) s++;
    if (!*s) {
        *last = NULL;
        return NULL;
    }

    // 토큰 시작 지점
    char *token = s;

    // 다음 delimiter까지 진행
    while (*s && !strchr(delimiters, *s)) s++;

    if (*s) {
        *s = '\0'; // delimiter를 NUL로 바꿔 토큰 종결
        *last = s + 1; // 다음 호출에서 여기부터 시작
    } else {
        *last = NULL; // 문자열 끝에 도달
    }
    return token;
}
#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; // as_string 결과 캐시
    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_t cap = (size_t) (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; // \uXXXX 등 미처리는 원본 유지
        }
    }
    *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'; // "true" 만 true, 나머지는 false
}

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

        // 자식의 key 필드에 복사
        size_t klen = (size_t) (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);
    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); // as_string 캐시 해제
    free(node);
}

void __free_json(JSON *root) {
    if (!root) return;
    JSON_TOKEN *c = root->children;
    while (c) {
        JSON_TOKEN *nx = c->next;
        __free_subtree(c);
        c = nx;
    }
    free(root->str_buf); // root에 as_string을 호출했을 수 있음
    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);

    void (*delete)(JSON *root);
} JSON_CLASS;

JSON_CLASS json = {__parse, __get, _dumps, __free_json};
#endif //OPENCSTL_JSON_H

// ==============================================================================
// END    json.h
// ==============================================================================
// [already included: mt19937.h]
#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
#define reverse         cstl_reverse

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

// [already included: types.h]
// [already included: verify.h]
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_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        case OPENCSTL_VECTOR: {
            if (argc >= 3) {
                yikes("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: yikes("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_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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: yikes("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_t container_type;

    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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: yikes("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_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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: yikes("Invalid operator");
            break;
    }
    __cstl_va_end(vl);
}

OPENCSTL_FUNC void _cstl_pop(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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: yikes("Invalid operator");
            break;
    }
}

OPENCSTL_FUNC void _cstl_pop_back(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_type sz = 0;
    switch (container_type) {
        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: {
            yikes("Invalid operator");
        }
    }
    return sz;
}

// OPENCSTL_FUNC size_type _cst_shrink_to_fit(void *container) {
//     size_t container_type;
//     if (__is_deque((void **) container)) {
//         ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
//         container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
//     } else {
//         container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
//     }
//     size_type sz = 0;
//     switch (container_type) {
//         case OPENCSTL_VECTOR: {
//            sz =  __cstl_vector_shrink_to_fit((void **) container);
//         }
//         break;
//         case OPENCSTL_LIST: {
//            sz =  __cstl_list_max_size((void **) container);
//         }
//         break;
//         case OPENCSTL_DEQUE: {
//             sz = __cstl_deque_shrink_to_fit((void **) container);
//         }
//         break;
//         default: {
//             verify("Invalid operator");
//         }
//     }
//     return es;
// }

OPENCSTL_FUNC void _cstl_pop_front(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_type sz = 0;
    switch (container_type) {
        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: yikes("Invalid operation");
            break;
    }
    return sz;
}

OPENCSTL_FUNC size_type _cstl_capacity(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_type sz = 0;
    switch (container_type) {
        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: yikes("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_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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
                yikes("Invalid operation");
        }
        break;
        case OPENCSTL_SET: {
            if (argc == 1) __cstl_tree_insert((void **) container, param1,NULL);
            else
                yikes("Invalid operation");
        }
        break;
        case OPENCSTL_UNORDERED_MAP: {
            if (argc == 2)__cstl_hashtable_insert((void **) container, param1, param2);
            else
                yikes("Invalid operation");
        }
        break;
        case OPENCSTL_UNORDERED_SET: {
            if (argc == 1) {
                __cstl_hashtable_insert((void **) container, param1,NULL);
            } else
                yikes("Invalid operation");
        }
        break;
        default: yikes("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_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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: yikes("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_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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: yikes("Invalid operation");
            break;
    }
    __cstl_va_end(vl);
}


OPENCSTL_FUNC void _cstl_clear(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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: {
            yikes("Invalid operation");
        }
        break;
    }
}

OPENCSTL_FUNC bool _cstl_empty(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    size_t sz = 0;
    switch (container_type) {
        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: {
            yikes("Invalid operation");
        };
    }
    return sz ? false : true;
}

OPENCSTL_FUNC void _cstl_free(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        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: yikes("Invalid operation");
            break;
    }
}

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_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        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: yikes("Invalid operator");
            break;
    }
    __cstl_va_end(vl);
    return NULL;
}


OPENCSTL_FUNC void _cstl_shrink_to_fit(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + 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: {
            yikes("Invalid operation");
        }
        break;
    }
}

OPENCSTL_FUNC void _cstl_reverse(void *container) {
    size_t container_type;
    if (__is_deque((void **) container)) {
        ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
        container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
    } else {
        container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
    }
    switch (container_type) {
        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: {
            yikes("Invalid operation");
        }
        break;
    }
}

// OPENCSTL_FUNC void ___cstl_sort(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_t container_type;
//     if (__is_deque((void **) container)) {
//         ptrdiff_t distance = OPENCSTL_NIDX(((void**)container), -1) + 1;
//         container_type = *(size_t *) ((char *) *(void **) container + NIDX_CTYPE * sizeof(size_t) + distance);
//     } else {
//         container_type = OPENCSTL_NIDX(((void**)container), NIDX_CTYPE);
//     }
//     switch (container_type) {
//         case OPENCSTL_LIST: {
//             if (argc == 1) {
// #if CSTL_USE_VAARG
//                 __cstl_list_qsort((void **) container, (int (*)(const void *, const void *)) param1);
// #else
//                 __cstl_list_qsort((void **) container, (int (*)(const void *, const void *)) *(void **) param1);
// #endif
//             }
//         }
//         break;
//
//         default: verify("Invalid operator");
//             break;
//     }
//     __cstl_va_end(vl);
// }

#if defined(__linux__) || defined(__APPLE__)
// #if !defined(__8cc__ )
// #pragma GCC pop_options
// #endif


#if defined(OCSTL_CC_CLANG)
#pragma clang diagnostic pop
#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
#if defined(OCSTL_CC_GCC)
#pragma GCC diagnostic pop
#pragma GCC diagnostic ignored "-Wpedantic"
#endif

#endif
#if defined(__cplusplus)
}
#endif

// ==============================================================================
// END    opencstl.h
// ==============================================================================

#endif // _OPENCSTL_AMALGAMATED_H