foundationallib.h

Go to the documentation of this file.

/*
 *   2023, Gregory Cohen <gregorycohennew@gmail.com>
 *
 *
 *   DONATION REQUEST: If this free software has helped you and you find
 *   it valuable, please consider making a donation to support the ongoing
 *   development and maintenance of this project. Your contribution helps
 *   ensure the availability of this library to the community and encourages
 *   further improvements.
 *
 *
 *                          Donations can be made at:
 *                 https://www.paypal.com/paypalme/cfoundationallib
 *
 *
 *
 * This code is in the public domain.
 * 
 * You are free to use it for any commercial or noncommercial purpose.
 * 
 */
 
#ifndef _FOUNDATIONAL_LIB_HEADER_GUARD
#define _FOUNDATIONAL_LIB_HEADER_GUARD
 
#ifdef _WIN32
#define _CRT_RAND_S
#endif
 
#include <stdint.h> /* FOR SIZE_MAX */
#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
 
/* Make sure memmem() is defined in all cases to avoid warnings or errors. */
void *memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen);
 
// structs (types)
struct Dict;
struct FrozenDict;
struct Set;
struct FrozenSet;
 
#ifndef FOUNDATIONAL_LIB_AGGRESSIVE_DIE_TYPE
#define FOUNDATIONAL_LIB_AGGRESSIVE_DIE_TYPE unsigned char
#endif
 
/*
 * ---------------------------------------------------------------------
 *
 * This code is in the Public domain. It is 100% original code, and
 * wholly in the public domain.
 *
 *  It is by Gregory Cohen <gregorycohennew@gmail.com>, No Copyright, 2023.
 *
 * ---------------------------------------------------------------------
 *
 * This code is quite usable. While more and more tests can
 * be added (currently there is the initial test program, and
 * another test program that is designed to stress-test every
 * single function, and a third work-in-progress test suite),
 * it does not change the fact that this code fundamentally
 * works. Try out the `run_test_suite` script, and if
 * everything works, it will tell you in green text that
 * things work on your system. Any errors or warnings are not
 * tolerated. This code should be usable for production.
 * Configure to your needs. Generate your own with a custom
 * prefix with the script at the top-level of the code.
 * Philosophy of this is in the 'Articles' folder - and it is
 * very unequivocal. -Gregory
 *
 * ---------------------------------------------------------------------
 */
 
/* -DFOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED=0 to turn off popen() and backticks() and shellescape(). */
 
#ifndef FOUNDATIONAL_LIB_USE_STATIC_ASSERTS_FOR_SAFETY
#define FOUNDATIONAL_LIB_USE_STATIC_ASSERTS_FOR_SAFETY 1
#endif
 
#if FOUNDATIONAL_LIB_USE_STATIC_ASSERTS_FOR_SAFETY
 
#ifdef __cplusplus
#ifndef FOUNDATIONAL_LIB_Static_assert
#define FOUNDATIONAL_LIB_Static_assert static_assert
#endif
#else
#ifndef FOUNDATIONAL_LIB_Static_assert
#define FOUNDATIONAL_LIB_Static_assert _Static_assert
#endif
#endif
 
#define FOUNDATIONAL_LIB_STATIC_ASSERT_MSG(true_cond, failure_message) FOUNDATIONAL_LIB_Static_assert((true_cond), failure_message)
 
#define FOUNDATIONAL_LIB_STATIC_ASSERT(true_cond) FOUNDATIONAL_LIB_Static_assert((true_cond), "(" #true_cond ") failed")
 
#define FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR 21 /* length of "18446744073709551615" plus 1 == 21 */
FOUNDATIONAL_LIB_STATIC_ASSERT_MSG((sizeof(size_t) <= 8 && FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR >= 21), "Increase SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR to more than 21");
 
#endif
#ifndef FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED
// Default true
#define FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED 1
#endif
 
#ifndef FOUNDATIONAL_LIB_VA_LIST
#define FOUNDATIONAL_LIB_VA_LIST va_list
#endif
 
#ifndef FOUNDATIONAL_LIB_VA_START
#define FOUNDATIONAL_LIB_VA_START va_start
#endif
 
#ifndef FOUNDATIONAL_LIB_VA_ARG
#define FOUNDATIONAL_LIB_VA_ARG va_arg
#endif
 
#ifndef FOUNDATIONAL_LIB_VA_END
#define FOUNDATIONAL_LIB_VA_END va_end
#endif
 
#ifdef __GNUC__
 
#ifndef FOUNDATIONAL_LIB_LIBC_LOCKING_IO_OPERATIONS
 
/* Set this to 0 to make the IO faster. */
#define FOUNDATIONAL_LIB_LIBC_LOCKING_IO_OPERATIONS 1
#endif
 
#ifndef FOUNDATIONAL_LIB_ISSPACE
#define FOUNDATIONAL_LIB_ISSPACE __builtin_isspace
#endif
#ifndef FOUNDATIONAL_LIB_ISALPHA
#define FOUNDATIONAL_LIB_ISALPHA __builtin_isalpha
#endif
#ifndef FOUNDATIONAL_LIB_ISALNUM
#define FOUNDATIONAL_LIB_ISALNUM __builtin_isalnum
#endif
#ifndef FOUNDATIONAL_LIB_ISDIGIT
#define FOUNDATIONAL_LIB_ISDIGIT __builtin_isdigit
#endif
#ifndef FOUNDATIONAL_LIB_ISPRINT
#define FOUNDATIONAL_LIB_ISPRINT __builtin_isprint
#endif
#ifndef FOUNDATIONAL_LIB_ISUPPER
#define FOUNDATIONAL_LIB_ISUPPER __builtin_isupper
#endif
#ifndef FOUNDATIONAL_LIB_ISLOWER
#define FOUNDATIONAL_LIB_ISLOWER __builtin_islower
#endif
 
#ifndef FOUNDATIONAL_LIB_STRLEN
#define FOUNDATIONAL_LIB_STRLEN __builtin_strlen
#endif
 
#ifndef FOUNDATIONAL_LIB_PRINTF
#define FOUNDATIONAL_LIB_PRINTF __builtin_printf
#endif
 
#ifndef FOUNDATIONAL_LIB_SPRINTF
#define FOUNDATIONAL_LIB_SPRINTF __builtin_sprintf
#endif
 
#ifndef FOUNDATIONAL_LIB_SNPRINTF
#define FOUNDATIONAL_LIB_SNPRINTF __builtin_snprintf
#endif
 
#ifndef FOUNDATIONAL_LIB_VSNPRINTF
#define FOUNDATIONAL_LIB_VSNPRINTF __builtin_vsnprintf
#endif
 
#ifndef FOUNDATIONAL_LIB_FPRINTF
 
#if FOUNDATIONAL_LIB_LIBC_LOCKING_IO_OPERATIONS /* Default mode IS thread-safe. */
#define FOUNDATIONAL_LIB_FPRINTF __builtin_fprintf
#else
#define FOUNDATIONAL_LIB_FPRINTF __builtin_fprintf /* GLIBC doesn't have an unlocked version of this. This is not a good thing. */
#endif
#endif
 
#ifndef FOUNDATIONAL_LIB_FPUTS
#if FOUNDATIONAL_LIB_LIBC_LOCKING_IO_OPERATIONS /* Default mode IS thread-safe. */
#define FOUNDATIONAL_LIB_FPUTS __builtin_fputs
#else
#define FOUNDATIONAL_LIB_FPUTS __builtin_fputs_unlocked
#endif
#endif
 
#ifndef FOUNDATIONAL_LIB_PUTCHAR
 
#if FOUNDATIONAL_LIB_LIBC_LOCKING_IO_OPERATIONS /* Default mode IS thread-safe. */
 
#define FOUNDATIONAL_LIB_PUTCHAR __builtin_putchar
#else
#define FOUNDATIONAL_LIB_PUTCHAR __builtin_putchar_unlocked
#endif
#endif
 
#ifndef FOUNDATIONAL_LIB_FPUTC
 
#if FOUNDATIONAL_LIB_LIBC_LOCKING_IO_OPERATIONS /* Default mode IS thread-safe. */
 
#define FOUNDATIONAL_LIB_FPUTC __builtin_fputc
#else
#define FOUNDATIONAL_LIB_FPUTC __builtin_fputc_unlocked
#endif
#endif
 
#ifndef FOUNDATIONAL_LIB_STRPBRK
#define FOUNDATIONAL_LIB_STRPBRK __builtin_strpbrk
#endif
 
/*
 *  benchmark_libc.c output
 *
 *  memcpy 0.000010
 *
 *  memcpy copy 0.000005
 *  __builtin_memcpy 0.000003
 *  Custom memcpy() (probably using __builtin_memcpy()) is 2.000000 times faster than default memcpy()
 *  __builtin_memcpy() is 3.333333 times faster than default memcpy()
 *
 *  This means, theoretically, a 6-day operation could take less than 2 days. That's speed.
 *
 */
#ifndef FOUNDATIONAL_LIB_MEMCPY
#define FOUNDATIONAL_LIB_MEMCPY __builtin_memcpy
#endif
 
#ifndef FOUNDATIONAL_LIB_STRLEN
#define FOUNDATIONAL_LIB_STRLEN __builtin_strlen
#endif
 
#ifndef FOUNDATIONAL_LIB_STRCMP
#define FOUNDATIONAL_LIB_STRCMP __builtin_strcmp
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMCMP
#define FOUNDATIONAL_LIB_MEMCMP __builtin_memcmp
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMMOVE
#define FOUNDATIONAL_LIB_MEMMOVE __builtin_memmove
#endif
 
#ifndef FOUNDATIONAL_LIB_STRCHR
#define FOUNDATIONAL_LIB_STRCHR __builtin_strchr
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMCHR
#define FOUNDATIONAL_LIB_MEMCHR __builtin_memchr
#endif
 
#ifndef FOUNDATIONAL_LIB_STRSTR
#define FOUNDATIONAL_LIB_STRSTR __builtin_strstr
#endif
 
#define  __attribute__((nonnull))
#define  __attribute__((format(printf, 1, 2)))
#define  __attribute__((warn_unused_result))
#define  __attribute__((nothrow))
#define  __attribute__((malloc))
 
#define FOUNDATIONAL_LIB_CONST __attribute__((const))
#define  __attribute__((pure))
 
#else /* ifdef GNUC */
 
#ifndef FOUNDATIONAL_LIB_PRINTF
#define FOUNDATIONAL_LIB_PRINTF printf
#endif
 
#ifndef FOUNDATIONAL_LIB_SPRINTF
#define FOUNDATIONAL_LIB_SPRINTF sprintf
#endif
 
#ifdef FOUNDATIONAL_LIB_SNPRINTF
#define FOUNDATIONAL_LIB_SNPRINTF snprintf
#endif
 
#ifndef FOUNDATIONAL_LIB_VSNPRINTF
#define FOUNDATIONAL_LIB_VSNPRINTF vsnprintf
#endif
 
#ifndef FOUNDATIONAL_LIB_FPRINTF
#define FOUNDATIONAL_LIB_FPRINTF fprintf
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMCPY
#define FOUNDATIONAL_LIB_MEMCPY memcpy
#endif
 
#ifndef FOUNDATIONAL_LIB_STRLEN
#define FOUNDATIONAL_LIB_STRLEN strlen
#endif
 
#ifndef FOUNDATIONAL_LIB_STRCMP
#define FOUNDATIONAL_LIB_STRCMP strcmp
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMCMP
#define FOUNDATIONAL_LIB_MEMCMP memcmp
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMMOVE
#define FOUNDATIONAL_LIB_MEMMOVE memmove
#endif
 
#ifndef FOUNDATIONAL_LIB_FPUTS
#define FOUNDATIONAL_LIB_FPUTS fputs
#endif
 
#ifndef FOUNDATIONAL_LIB_PUTCHAR
#define FOUNDATIONAL_LIB_PUTCHAR putchar
#endif
 
#ifndef FOUNDATIONAL_LIB_FPUTC
#define FOUNDATIONAL_LIB_FPUTC putc
#endif
 
#ifndef FOUNDATIONAL_LIB_STRPBRK
#define FOUNDATIONAL_LIB_STRPBRK strpbrk
#endif
 
#ifndef FOUNDATIONAL_LIB_STRCHR
#define FOUNDATIONAL_LIB_STRCHR
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMCHR
#define FOUNDATIONAL_LIB_MEMCHR
#endif
 
#ifndef FOUNDATIONAL_LIB_STRSTR
#define FOUNDATIONAL_LIB_STRSTR strstr
#endif
 
#ifndef FOUNDATIONAL_LIB_ISSPACE
#define FOUNDATIONAL_LIB_ISSPACE isspace
#endif
#ifndef FOUNDATIONAL_LIB_ISALPHA
#define FOUNDATIONAL_LIB_ISALPHA isalpha
#endif
#ifndef FOUNDATIONAL_LIB_ISALNUM
#define FOUNDATIONAL_LIB_ISALNUM isalnum
#endif
#ifndef FOUNDATIONAL_LIB_ISDIGIT
#define FOUNDATIONAL_LIB_ISDIGIT isdigit
#endif
#ifndef FOUNDATIONAL_LIB_ISPRINT
#define FOUNDATIONAL_LIB_ISPRINT isprint
#endif
#ifndef FOUNDATIONAL_LIB_ISUPPER
#define FOUNDATIONAL_LIB_ISUPPER isupper
#endif
#ifndef FOUNDATIONAL_LIB_ISLOWER
#define FOUNDATIONAL_LIB_ISLOWER islower
#endif
 
#if _WIN32
#include <sal.h>
 
/* All the functions that use nonnull, also work with declspec. */
#define  __declspec(noalias)
#define FOUNDATIONAL_LIB_PRINTF _Printf_format_string_impl_
#define  /* not defined for Windows at present. */
 
#define  /* not defined for Windows at present. */
#define   /* not defined for Windows at present.  */
 
#define FOUNDATIONAL_LIB_CONST              /* not defined for Windows at present. */
#define                /* not defined for Windows at present. */
#else                                       /* if WIN32 */
 
/* All the functions that use nonnull, also work with declspec. */
#define             /* not defined */
#define FOUNDATIONAL_LIB_PRINTF             /* not defined */
#define  /* not defined */
 
#define  /* not defined */
#define   /* not defined */
 
#define FOUNDATIONAL_LIB_CONST /* not defined */
#define   /* not defined */
 
#endif /* if WIN32 */
 
#endif /* if GNUC */
 
/* For the capacities of FrozenDict and FrozenSet. */
#ifndef FOUNDATIONAL_LIB_FROZEN_INITIALIZATION_SIZE_MULTIPLIER
#define FOUNDATIONAL_LIB_FROZEN_INITIALIZATION_SIZE_MULTIPLIER 3
#endif
 
/* If allocating new strings (an array), how many should be allocated? */
#ifndef FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_COUNT
#define FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_COUNT 0
#endif
 
/* If allocating new strings (an array), how much memory should be allocated at first? */
#ifndef FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE
#define FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE (sizeof(char *) * 1)
#endif
 
#if defined(__GNUC__) || defined(__clang__)
#define FOUNDATIONAL_LIB_likely(x) __builtin_expect(!!(x), 1)
#define FOUNDATIONAL_LIB_UNLIKELY(x) __builtin_expect(!!(x), 0)
#else
#define FOUNDATIONAL_LIB_likely(x) (x)
#define FOUNDATIONAL_LIB_UNLIKELY(x) (x)
#endif
 
#ifndef FOUNDATIONAL_LIB_ASSERT_ARGUMENT_CHECKING
#define FOUNDATIONAL_LIB_ASSERT_ARGUMENT_CHECKING 0 /* Argument NULL checks. Disabled by default. */
#endif
 
#ifndef FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED
#if FOUNDATIONAL_LIB_ASSERT_ARGUMENT_CHECKING
#define FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(x) assert(x)
#else
#define FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(x) /* */
#endif
#endif /* assert checking. */
 
#ifdef __GNUC__
FOUNDATIONAL_LIB_CONST
static inline size_t FOUNDATIONAL_LIB_safe_mul(size_t a, size_t b)
{
    size_t result;
 
    if (FOUNDATIONAL_LIB_UNLIKELY(__builtin_mul_overflow(a, b, &result)))
    {
        /* 0 on error (overflow). */
        return 0;
    }
 
    return result;
}
 
static inline size_t FOUNDATIONAL_LIB_safe_mul_ptr(size_t a, size_t b, size_t *ptr)
{
    if (FOUNDATIONAL_LIB_UNLIKELY(__builtin_mul_overflow(a, b, ptr)))
    {
        /* 0 on error (overflow). */
        return 0;
    }
 
    return 1;
}
 
FOUNDATIONAL_LIB_CONST
static inline size_t FOUNDATIONAL_LIB_safe_add_2(size_t a, size_t b)
{
    size_t result;
 
    if (FOUNDATIONAL_LIB_UNLIKELY(__builtin_add_overflow(a, b, &result)))
    {
        /* 0 on error (overflow). */
        return 0;
    }
 
    return result;
}
 
FOUNDATIONAL_LIB_CONST
static inline size_t FOUNDATIONAL_LIB_safe_add_3(size_t a, size_t b, size_t c)
{
    size_t result;
 
    if (FOUNDATIONAL_LIB_UNLIKELY(__builtin_add_overflow(a, b, &result)) || FOUNDATIONAL_LIB_UNLIKELY(__builtin_add_overflow(result, c, &result)))
    {
        /* 0 on error (overflow). */
        return 0;
    }
 
    return result;
}
 
static inline int FOUNDATIONAL_LIB_safe_add_3_ptr(size_t a, size_t b, size_t c, size_t *out)
{
    if (FOUNDATIONAL_LIB_UNLIKELY(__builtin_add_overflow(a, b, out)) || FOUNDATIONAL_LIB_UNLIKELY(__builtin_add_overflow(*out, c, out)))
    {
        /* 0 on error (overflow). */
        return 0;
    }
 
    return 1;
}
 
static inline int FOUNDATIONAL_LIB_safe_add_2_ptr(size_t a, size_t b, size_t *out)
{
    if (FOUNDATIONAL_LIB_UNLIKELY(__builtin_add_overflow(a, b, out)))
    {
        /* 0 on error (overflow). */
        return 0;
    }
 
    return 1;
}
 
#else  /* GNUC */
FOUNDATIONAL_LIB_CONST
static inline size_t FOUNDATIONAL_LIB_safe_mul(size_t a, size_t b)
{
    size_t result;
 
    if (b != 0 && a > SIZE_MAX / b)
    {
        /* Overflow */
        return 0;
    }
 
    result = a * b;
    return result;
}
 
static inline size_t FOUNDATIONAL_LIB_safe_mul_ptr(size_t a, size_t b, size_t *ptr)
{
    if (b != 0 && a > SIZE_MAX / b)
    {
        /* Overflow */
        return 0;
    }
 
    *ptr = a * b;
    return 1;
}
 
FOUNDATIONAL_LIB_CONST
static inline size_t FOUNDATIONAL_LIB_safe_add_2(size_t a, size_t b)
{
    size_t result;
 
    if (a > SIZE_MAX - b || a + b > SIZE_MAX - c)
    {
        /* Overflow */
        return 0;
    }
 
    result = a + b;
    return result;
}
 
FOUNDATIONAL_LIB_CONST
static inline size_t FOUNDATIONAL_LIB_safe_add_3(size_t a, size_t b, size_t c)
{
    size_t result;
 
    if (a > SIZE_MAX - b || b > SIZE_MAX - c)
    {
        /* Overflow */
        return 0;
    }
 
    result = a + b + c;
    return result;
}
 
static inline size_t FOUNDATIONAL_LIB_safe_add_2_ptr(size_t a, size_t b, size_t *ptr)
{
    if (a > SIZE_MAX - b)
    {
        /* Overflow */
        return 0;
    }
 
    *ptr = a + b;
    return 1;
}
 
static inline int FOUNDATIONAL_LIB_safe_add_3_ptr(size_t a, size_t b, size_t c, size_t *ptr)
{
    if (a > SIZE_MAX - b || b > SIZE_MAX - c)
    {
        /* Overflow */
        return 0;
    }
 
    *ptr = a + b + c;
    return 1;
}
#endif /* GNUC */
 
#define FOUNDATIONAL_LIB_safe_increment(variable, label_if_fails)                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
    if (FOUNDATIONAL_LIB_UNLIKELY(FOUNDATIONAL_LIB_safe_add_2_ptr((variable), 1, &(variable)) == 0))                                                                                                                                                                                                                                                                                                                                                                                                               \
        goto label_if_fails;
 
// Adjust as needed. On embedded platforms or low memory systems, you might want to change the algorithm to be somewhat lower than 1.5x
// new len calculations need to be checked, before and after this, for overflow.
 
#ifndef FOUNDATIONAL_LIB_LOW_MEMORY_USAGE
#define FOUNDATIONAL_LIB_LOW_MEMORY_USAGE 12
#endif
 
#ifndef FOUNDATIONAL_LIB_ALLOCATOR_DIV_AMOUNT
#define FOUNDATIONAL_LIB_ALLOCATOR_DIV_AMOUNT 2
#endif
 
// Takes an argument and makes it at least 1 bigger.
#ifdef __GNUC__ // Check if GCC compiler is being used
 
FOUNDATIONAL_LIB_CONST
static inline size_t FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(size_t old_size_to_add_at_least_one_to)
{
    size_t addition;
 
    // In 49 / 50 for example, Would equal 0. We need at least 1 of an increase.
    // Default div_amount is 2 or in low memory mode 12.
    // On embedded you could use low amounts.
 
    const size_t div_amount = old_size_to_add_at_least_one_to < FOUNDATIONAL_LIB_ALLOCATOR_DIV_AMOUNT ? 1 /* divide by 1 and so double it. */
                                                                                                      : FOUNDATIONAL_LIB_ALLOCATOR_DIV_AMOUNT
        /*
         * not a really small number (under div amount),
         * and so use the div amount
         */
        ;
 
    if (__builtin_add_overflow(old_size_to_add_at_least_one_to, old_size_to_add_at_least_one_to / div_amount, &addition))
    {
        /* 0 on error. */
        return 0;
    }
 
    return addition;
}
 
#else /* GNUC */
// Fallback implementation for other compilers
 
static inline size_t FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(size_t siz)
{
    // In 49 / 50 for example, Would equal 0. We need at least 1 of an increase.
    // Default div_amount is 2 or in low memory mode 12.
    // On embedded you could use low amounts.
 
    const size_t div_amount = old_size_to_add_at_least_one_to < FOUNDATIONAL_LIB_ALLOCATOR_DIV_AMOUNT ? 1 /* divide by 1 and so double it. */
                                                                                                      : FOUNDATIONAL_LIB_ALLOCATOR_DIV_AMOUNT
        /*
         * not a really small number (under div amount),
         * and so use the div amount
         */
        ;
 
    // Check for potential overflow before performing the addition
    if (siz > SIZE_MAX / 2 || siz > (SIZE_MAX - siz) / 2)
    {
        /* 0 on error (overflow). */
        return 0;
    }
 
    // Calculate the new size after 1.5x reallocation
    const size_t addition = siz + (siz / div_amount);
 
    // Return the result of the addition
    return addition;
}
 
#endif
 
/* For copy_file() */
#ifndef FOUNDATIONAL_LIB_COPY_SIZE_AMOUNT
#define FOUNDATIONAL_LIB_COPY_SIZE_AMOUNT 4096
#endif
 
#if FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED
/* For backticks() */
#ifndef FOUNDATIONAL_LIB_POPEN_INITIAL_ALLOC_SIZE
#define FOUNDATIONAL_LIB_POPEN_INITIAL_ALLOC_SIZE 4096
#endif
#endif
 
/* Choose which functions you want. */
 
#ifndef FOUNDATIONAL_LIB_ATOI
#define FOUNDATIONAL_LIB_ATOI atoi
#endif
 
/* File IO */
 
#if FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED
#ifdef _WIN32
#define FOUNDATIONAL_LIB_POPEN _popen
#define FOUNDATIONAL_LIB_PCLOSE _pclose
#else
#define FOUNDATIONAL_LIB_POPEN popen
#define FOUNDATIONAL_LIB_PCLOSE pclose
#endif
#endif
 
#ifndef FOUNDATIONAL_LIB_FERROR
#define FOUNDATIONAL_LIB_FERROR ferror
#endif
 
#ifdef _WIN32
#ifndef FOUNDATIONAL_LIB_FSEEKO
#define FOUNDATIONAL_LIB_FSEEKO _fseeki64
#endif
 
#ifndef FOUNDATIONAL_LIB_FTELLO
#define FOUNDATIONAL_LIB_FTELLO _ftelli64
#endif
#else
#ifndef FOUNDATIONAL_LIB_FSEEKO
#define FOUNDATIONAL_LIB_FSEEKO fseeko
#endif
 
#ifndef FOUNDATIONAL_LIB_FTELLO
#define FOUNDATIONAL_LIB_FTELLO ftello
#endif
 
#endif
 
#ifndef FOUNDATIONAL_LIB_FREAD
#define FOUNDATIONAL_LIB_FREAD fread
#endif
 
#ifndef FOUNDATIONAL_LIB_FWRITE
#define FOUNDATIONAL_LIB_FWRITE fwrite
#endif
 
#ifndef FOUNDATIONAL_LIB_FOPEN
#define FOUNDATIONAL_LIB_FOPEN fopen
#endif
 
#ifndef FOUNDATIONAL_LIB_FCLOSE
#define FOUNDATIONAL_LIB_FCLOSE fclose
#endif
 
/* Memory allocation macros that you can customize */
 
#ifndef FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC
#define FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC malloc
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC
#define FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC realloc
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC
#define FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC calloc
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE
#define FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE free
#endif
 
#ifndef FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP
#define FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP strdup
#endif
 
#ifndef FOUNDATIONAL_LIB_NETWORK_FUNCTIONS_ENABLED
#define FOUNDATIONAL_LIB_NETWORK_FUNCTIONS_ENABLED 0
#endif
 
#if FOUNDATIONAL_LIB_NETWORK_FUNCTIONS_ENABLED
#define FOUNDATIONAL_LIB_INITIAL_NETWORK_DOWNLOAD_BUFFER_SIZE 8192
#endif
 
#ifndef FOUNDATIONAL_LIB_HASH_INITIAL_CAPACITY
#define FOUNDATIONAL_LIB_HASH_INITIAL_CAPACITY 16
#endif
 
#ifndef FOUNDATIONAL_LIB_HASH_LOAD_FACTOR_THRESHOLD
#define FOUNDATIONAL_LIB_HASH_LOAD_FACTOR_THRESHOLD 0.75
#endif
 
#ifndef FOUNDATIONAL_LIB_FUNC
/*
 * One thing you can do, if you want "strict mode" on, you can define this to be  and have -Werror on.
 * That way, if any errors are not accounted for, instead of dealing with error handlers, the code just won't compile.
 */
#define FOUNDATIONAL_LIB_FUNC static inline
#endif
 
#ifndef FOUNDATIONAL_LIB_THREAD_FUNCTIONS_ENABLED
#define FOUNDATIONAL_LIB_THREAD_FUNCTIONS_ENABLED 1
#endif
 
FOUNDATIONAL_LIB_AGGRESSIVE_DIE_TYPE FOUNDATIONAL_LIB_aggressive_die = 1;
 
#define FOUNDATIONAL_LIB_set_aggressive_die(mode)                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
    {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
        FOUNDATIONAL_LIB_aggressive_die = (mode);                                                                                                                                                                                                                                                                                                                                                                                                                                                                  \
    }
 
#define FOUNDATIONAL_LIB_get_aggressive_die() FOUNDATIONAL_LIB_aggressive_die
 
#ifndef FOUNDATIONAL_LIB_die_aggressively_if_enabled
#define FOUNDATIONAL_LIB_die_aggressively_if_enabled()                                                                                                                                                                                                                                                                                                                                                                                                                                                             \
    if (FOUNDATIONAL_LIB_UNLIKELY(FOUNDATIONAL_LIB_aggressive_die))                                                                                                                                                                                                                                                                                                                                                                                                                                                \
    {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              \
        FOUNDATIONAL_LIB_FPRINTF(stderr, "Error: %s: %s.\n", __func__, strerror(errno));                                                                                                                                                                                                                                                                                                                                                                                                                           \
        exit(EXIT_FAILURE); /* Use default exit, only place in library this is used, adjust as needed. */                                                                                                                                                                                                                                                                                                                                                                                                          \
    }
#endif
 
static inline void free_array(void **array, size_t len)
{
    while (len--)
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(array[len]);
    }
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(array);
}
 
static inline void free_string_array(char **array, size_t len)
{
    while (len--)
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(array[len]);
    }
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(array);
}
 
FOUNDATIONAL_LIB_FUNC char *int_to_string(long long int number)
{
    // Allocate a fixed-size buffer for the string
    char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR + 1 /* sign */];
 
    char *p;
    long long a;
    char *b;
    char temp;
    unsigned long long u;
 
    p = buffer;
 
    if (number < 0)
    {
        *p++ = '-';
        number = 0 - number;
    }
    u = (long long)number;
 
    b = p;
 
    do
    {
        a = u % 10;
        u /= 10;
        *p++ = a + '0';
    } while (u > 0);
 
    *p-- = '\0';
    do
    {
        temp = *p;
        *p = *b;
        *b = temp;
        --p;
        ++b;
    } while (b < p);
 
    // Duplicate the buffer using strdup
    char *return_value = strdup(buffer);
    if (FOUNDATIONAL_LIB_UNLIKELY(return_value == NULL))
    {
        // Handle allocation failure
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    return return_value;
}
 
FOUNDATIONAL_LIB_FUNC void int_to_string_with_buffer(long long int number, char *buffer)
{
    char *p;
    unsigned long long a;
    char *b;
    char temp;
    unsigned long long u;
 
    p = buffer;
 
    if (number < 0)
    {
        *p++ = '-';
        number = 0 - number;
    }
    u = (unsigned long)number;
 
    b = p;
 
    do
    {
        a = u % 10;
        u /= 10;
        *p++ = a + '0';
    } while (u > 0);
 
    *p-- = '\0';
    do
    {
        temp = *p;
        *p = *b;
        *b = temp;
        --p;
        ++b;
    } while (b < p);
}
 
/*
 * @brief
 * This function is for maximally-efficient conversion of unsigned numbers to strings - no nonsense.
 * Output should be large enough to hold the number. length of "18446744073709551615" + null byte = 21 chars.
 *
 * @param unsigned_value The number
 * @param output The output buffer. Should be 21 bytes, or fewer if you are certain the number is small, of more if sizeof(size_t) > 8 (which is unlikely).
 */
FOUNDATIONAL_LIB_FUNC void utoa(size_t unsigned_value, char *output)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(output);
 
    char *p = output;
    size_t a;
    char *b = output;
    char temp;
 
    do
    {
        a = unsigned_value % 10;
        unsigned_value /= 10;
        *p++ = a + '0';
    } while (unsigned_value);
 
    *p-- = '\0';
 
    do
    {
        temp = *p;
        *p = *b;
        *b = temp;
        --p;
        ++b;
    } while (b < p);
}
 
FOUNDATIONAL_LIB_FUNC char *uint_to_string(size_t number)
{
    char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
    utoa(number, buffer);
 
    char *return_value = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(buffer);
    if (FOUNDATIONAL_LIB_UNLIKELY(return_value == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    return return_value;
}
 
FOUNDATIONAL_LIB_FUNC void print_uint_array(const unsigned long long *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const unsigned int value = array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
FOUNDATIONAL_LIB_FUNC void print_uint_ptr_array(const unsigned int **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const unsigned int value = *array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_int_array(const int *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const int value = array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_int_ptr_array(const int **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const unsigned int value = *array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
// print_uchar and print_uchar_array omitted because a uchar is too similar to a string.
 
FOUNDATIONAL_LIB_FUNC void print_string_array(char **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPUTS(array[i], stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_string_array_array(char ***array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPUTS(*(array[i]), stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_ushort_array(const unsigned short *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const unsigned short value = array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_ushort_ptr_array(const unsigned short **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const unsigned short value = *(array[i]);
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_short_array(const short *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const short value = array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_short_ptr_array(const short **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const short value = *(array[i]);
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_array(const unsigned long *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const unsigned long value = array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_ptr_array(const unsigned long **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const unsigned long value = *(array[i]);
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_long_array(const long *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const long value = array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_long_ptr_array(const long **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const long value = *(array[i]);
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_long_array(const unsigned long long *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const unsigned long long value = array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_long_ptr_array(const unsigned long long **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const unsigned long long value = *(array[i]);
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_long_long_array(const long long *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const long long value = array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_long_long_ptr_array(const long long **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const long long value = *(array[i]);
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_float_array(const float *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_PRINTF("%f", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stdout);
        }
    }
 
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_float_ptr_array(const float **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_PRINTF("%f", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stdout);
        }
    }
 
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_double_array(const double *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_PRINTF("%lf", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stdout);
        }
    }
 
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_double_ptr_array(const double **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_PRINTF("%lf", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stdout);
        }
    }
 
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_size_t_array(const size_t *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const size_t value = array[i];
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_size_t_ptr_array(const size_t **array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_PUTCHAR('[');
 
    for (size_t i = 0; i < size; ++i)
    {
        const size_t value = *(array[i]);
        char buf[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buf);
        FOUNDATIONAL_LIB_FPUTS(buf, stdout);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_PUTCHAR(',');
            FOUNDATIONAL_LIB_PUTCHAR(' ');
        }
    }
    FOUNDATIONAL_LIB_PUTCHAR(']');
}
 
FOUNDATIONAL_LIB_FUNC void print_uint_array_to_stream(const unsigned int *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%u", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_uint_ptr_array_to_stream(const unsigned int **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%u", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_int_array_to_stream(const int *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%d", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_int_ptr_array_to_stream(const int **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%d", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_uchar_array_to_stream(const unsigned char *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%c", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_char_array_to_stream(const char *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%c", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_string_array_to_stream(char **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPUTS(array[i], stream);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_string_array_array_to_stream(char ***array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPUTS(*array[i], stream);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_ushort_array_to_stream(const unsigned short *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%hu", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_ushort_ptr_array_to_stream(const unsigned short **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%hu", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_short_array_to_stream(const short *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; ++i)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%d", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_short_ptr_array_to_stream(const short **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%d", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_array_to_stream(const unsigned long *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%lu", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_ptr_array_to_stream(const unsigned long **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%lu", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_long_array_to_stream(const long *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%ld", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_long_ptr_array_to_stream(const long **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%ld", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_long_array_to_stream(const unsigned long long *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        const unsigned long long value = array[i];
        char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buffer);
        FOUNDATIONAL_LIB_FPUTS(buffer, stream);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_long_ptr_array_to_stream(const unsigned long long **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        const unsigned long long value = *(array[i]);
        char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        utoa(value, buffer);
        FOUNDATIONAL_LIB_FPUTS(buffer, stream);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_long_long_array_to_stream(const long long *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        const unsigned long long value = array[i];
        char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buffer);
 
        FOUNDATIONAL_LIB_FPUTS(buffer, stream);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_long_long_ptr_array_to_stream(const long long **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        const long long value = *(array[i]);
 
        char buffer[FOUNDATIONAL_LIB_SIZE_STRING_OF_NUMBER_SIZE_PLUS_ZERO_TERMINATOR];
 
        int_to_string_with_buffer(value, buffer);
        FOUNDATIONAL_LIB_FPUTS(buffer, stream);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_float_array_to_stream(const float *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%f", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_float_ptr_array_to_stream(const float **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%f", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_double_array_to_stream(const double *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%lf", array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_double_ptr_array_to_stream(const double **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
        FOUNDATIONAL_LIB_FPRINTF(stream, "%lf", *array[i]);
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_size_t_array_to_stream(const size_t *array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wformat-extra-args"
        FOUNDATIONAL_LIB_FPRINTF(stream, "%zu", array[i]);
 
#pragma GCC diagnostic pop
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void print_size_t_ptr_array_to_stream(const size_t **array, size_t size, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_FPUTC('[', stream);
    for (size_t i = 0; i < size; i++)
    {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wformat-extra-args"
 
        FOUNDATIONAL_LIB_FPRINTF(stream, "%zu", *array[i]);
#pragma GCC diagnostic pop
        if (i < size - 1)
        {
            FOUNDATIONAL_LIB_FPUTS(", ", stream);
        }
    }
    FOUNDATIONAL_LIB_FPUTS("]", stream);
}
 
FOUNDATIONAL_LIB_FUNC void *arraydup(const void *array, size_t num_mem, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    const size_t tot_size = FOUNDATIONAL_LIB_safe_mul(num_mem, size);
 
    // Check num_mem so safe_mul doesn't get confused.
    if (FOUNDATIONAL_LIB_UNLIKELY(num_mem && tot_size == 0))
    {
        /* Handle memory allocation failure */
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
    char *duplicate = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(tot_size);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(duplicate == NULL))
    {
        /* Handle memory allocation failure */
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    for (size_t i = 0; i < tot_size; i++)
    {
        duplicate[i] = ((char *)array)[i];
    }
 
    return (void *)duplicate;
}
 
static inline int equal_strings(const char *first, const char *second) { return FOUNDATIONAL_LIB_STRCMP(first, second) == 0; }
 
static inline int equal_array_of_uints(const unsigned int *array, const unsigned int *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_uint_ptrs(const unsigned int **array, const unsigned int **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_ints(const int *array, const int *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_int_ptrs(const int **array, const int **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_uchars(const unsigned char *array, const unsigned char *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_uchar_ptrs(const unsigned char **array, const unsigned char **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_chars(const char *array, const char *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_char_ptrs(const char **array, const char **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_ushorts(const unsigned short *array, const unsigned short *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_ushort_ptrs(const unsigned short **array, const unsigned short **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_shorts(const short *array, const short *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_short_ptrs(const short **array, const short **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_ulongs(const unsigned long *array, const unsigned long *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_ulong_ptrs(const unsigned long **array, const unsigned long **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_longs(const long *array, const long *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_long_ptrs(const long **array, const long **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_ulong_longs(const unsigned long long *array, const unsigned long long *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_ulong_long_ptrs(const unsigned long long **array, const unsigned long long **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_long_longs(const long long *array, const long long *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_long_long_ptrs(const long long **array, const long long **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_floats(const float *array, const float *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_float_ptrs(const float **array, const float **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_doubles(const double *array, const double *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_double_ptrs(const double **array, const double **array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_size_ts(const size_t *array, const size_t *array2, size_t size)
{
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
static inline int equal_array_of_size_t_ptrs(const size_t **array, const size_t **array2, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    for (size_t i = 0; i < size; ++i)
    {
        if (array[i] != array2[i])
        {
            return 0;
        }
    }
    return 1;
}
 
FOUNDATIONAL_LIB_FUNC char *string_to_json(const char *input_string)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(input_string);
    size_t escaped_length = 0;
    size_t input_length = 0;
 
    /* Calculate the length of the escaped string */
 
    while (input_string[input_length])
    {
        if (input_string[input_length] == '"' || input_string[input_length] == '\\')
        {
            // If the string uses most of memory and is filled with \ or ", there could be an overflow.
            // Check for this.
            // If you find this too slow, just change the macro definition.
            FOUNDATIONAL_LIB_safe_increment(escaped_length, overflow); // Need to escape with a backslash
        }
 
        // If the string uses most of memory and is filled with \ or ", there could be an overflow.
        // Check for this.
        FOUNDATIONAL_LIB_safe_increment(escaped_length, overflow);
 
        // Cannot overflow because it's a size_t that starts from 0.
        // (Actually, it can, if all of memory is nonzero.)
        // Do not check for this.
        ++input_length;
    }
 
    /* Calculate the length of the resulting JSON string */
 
    size_t json_length;
 
    json_length = escaped_length;
 
    // add 2 for double quotes
    if (FOUNDATIONAL_LIB_safe_add_2_ptr(json_length, 2, &json_length) == 0)
        goto overflow;
 
    size_t alloc_size;
 
    alloc_size = json_length + sizeof(""); // +1 for null terminator
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size == 0))
        goto overflow;
 
    char *json_result;
 
    json_result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(json_result == NULL))
    {
        goto memory_error;
    }
 
    /* Add double quotes around the escaped string */
    json_result[0] = '"';
 
    // Start a 1 for j because index 0 is a quote mark.
    for (size_t j = 1, i = 0; i < input_length; ++i, ++j)
    {
        // Add unlikely because this isn't that probable.
        if (FOUNDATIONAL_LIB_UNLIKELY(input_string[i] == '"' || input_string[i] == '\\'))
        {
            json_result[j] = '\\';
            ++j;
        }
 
        // i is the index for the input string and j is the index for the json result
        json_result[j] = input_string[i];
    }
 
    // Add the second quote
    json_result[json_length - 1] = '"';
 
    // Null-terminate the string
    json_result[json_length] = '\0';
 
    return json_result;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return NULL;
}
 
FOUNDATIONAL_LIB_FUNC char *strip(const char *str)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    size_t end = FOUNDATIONAL_LIB_STRLEN(str);
 
    size_t start;
 
    start = 0;
 
    /* Trim leading whitespace */
    while (FOUNDATIONAL_LIB_ISSPACE(str[start]))
    {
        ++start;
    }
 
    /* Trim trailing whitespace */
    while (end > start && FOUNDATIONAL_LIB_ISSPACE(str[end - 1]))
    {
        --end;
    }
 
    /* Copy the stripped portion into a new string */
 
    // End is always greater than start. Should never underflow.
 
    const size_t memcpy_len = end - start;
    size_t alloc_len = memcpy_len;
 
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_len == SIZE_MAX))
        goto overflow;
    ++alloc_len;
 
    char *result;
    result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_len); /* Safe. */
 
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
        goto memory_error;
 
    // Copy everything before the null byte.
    FOUNDATIONAL_LIB_MEMCPY(result, str + start, memcpy_len); /* Safe. */
    result[memcpy_len] = '\0';
 
    return result;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return NULL;
}
 
FOUNDATIONAL_LIB_FUNC char **split(const char *str, size_t *output_size, const char *delim, size_t max_times, int keep_delim_in_result)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(output_size);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(delim);
 
    /* Count the number of tokens */
    *output_size = 1;
    const size_t delim_len = FOUNDATIONAL_LIB_STRLEN(delim);
 
    for (const char *ptr = FOUNDATIONAL_LIB_STRSTR(str, delim); ptr != NULL && (max_times == 0 || *output_size < max_times); ptr = strstr(ptr + delim_len, delim))
    {
        ++(*output_size);
    }
 
    const size_t new_len = FOUNDATIONAL_LIB_safe_mul(*output_size, sizeof(char *));
 
    // Check output_size so safe_mul doesn't get confused.
    if (FOUNDATIONAL_LIB_UNLIKELY(new_len == 0 && *output_size))
        goto overflow;
 
    /* Allocate memory for the array of strings */
    char **result;
 
    result = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(new_len);
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
        goto memory_error;
 
    const char *token_start;
 
    token_start = str;
    const char *ptr;
 
    /* Split the string into tokens */
    for (size_t i = 0; i < *output_size; i++)
    {
        ptr = FOUNDATIONAL_LIB_STRSTR(token_start, delim);
 
        if (ptr != NULL)
        {
            // Should not overflow.
            size_t token_length = (size_t)(ptr - token_start);
 
            if (keep_delim_in_result)
            {
                token_length += delim_len;
            }
 
            const size_t alloc_len = token_length + sizeof("");
 
            result[i] = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_len); /* Safe. */
            if (FOUNDATIONAL_LIB_UNLIKELY(result[i] == NULL))
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
                goto memory_error;
            }
 
            FOUNDATIONAL_LIB_MEMCPY(result[i], token_start, token_length); /* Safe. */
            result[i][token_length] = '\0';
 
            token_start = ptr + delim_len; // Move to the next token
        }
        else /* ptr is NULL */
        {
            // Last token, copy the remaining part of the string
            const size_t token_length = FOUNDATIONAL_LIB_STRLEN(token_start);
 
            // The only way this could overflow is if strlen(token_length) == SIZE_MAX.
            //
            // But I don't see how that would be possible, because there would have to
            // be a null terminator for strlen() to work. So it would have to be
            // SIZE_MAX - 1, unless strlen() is broken. Since it would have to be
            // SIZE_MAX - 1, adding 1 to it wouldn't cause an overflow.
            // Therefore, this is safe code.
 
            const size_t alloc_len = token_length + sizeof("");
 
            result[i] = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_len); /* Safe. */
 
            if (FOUNDATIONAL_LIB_UNLIKELY(result[i] == NULL))
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
                goto memory_error;
            }
 
            FOUNDATIONAL_LIB_MEMCPY(result[i], token_start, token_length); /* Safe. */
            result[i][token_length] = '\0';
        }
    }
 
    return result;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return NULL;
}
 
FOUNDATIONAL_LIB_FUNC char *join(const char **array, size_t count, const char *delimiter)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(delimiter);
 
    const size_t new_size = FOUNDATIONAL_LIB_safe_mul(sizeof(size_t), count);
    // Check count so safe_mul doesn't get confused.
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0 && count))
        goto overflow;
    size_t *lens;
 
    lens = (size_t *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(new_size);
    if (FOUNDATIONAL_LIB_UNLIKELY(lens == NULL))
        goto memory_error;
    size_t delimeter_length;
 
    delimeter_length = FOUNDATIONAL_LIB_STRLEN(delimiter);
    /* Calculate the total length of the resulting string */
    size_t total_length;
 
    total_length = 1; // NUL byte
    for (size_t i = 0; i < count; i++)
    {
        const size_t new_len = FOUNDATIONAL_LIB_STRLEN(array[i]);
        lens[i] = new_len;
        total_length += new_len;
        if (i < count - 1)
        {
            total_length += delimeter_length;
        }
    }
 
    /* Allocate memory for the resulting string */
    char *result;
 
    result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(total_length);
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        goto memory_error;
    }
    size_t len_so_far;
 
    len_so_far = 0;
    size_t array_index;
 
    /* Concatenate strings with the delimiter */
    for (array_index = 0; array_index < count; ++array_index)
    {
        const size_t len = lens[array_index];
 
        /* Copy string */
        for (size_t x = 0; x < len; ++x)
        {
            result[len_so_far + x] = array[array_index][x];
        }
 
        len_so_far += len;
        if (array_index < count - 1)
        {
            /* Copy delimiter */
            for (size_t i = 0; i < delimeter_length; ++i)
            {
                result[len_so_far + i] = delimiter[i];
            }
            len_so_far += delimeter_length;
        }
    }
 
    result[len_so_far] = '\0';
 
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(lens);
 
    return result;
 
memory_error:
overflow:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return NULL;
}
#ifdef _WIN32
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wformat-extra-args"
#endif
 
FOUNDATIONAL_LIB_FUNC int append_string_to_string(char **string, size_t *string_length, size_t *string_alloc_size, const char *string_to_get_appended, size_t string_to_get_appended_length)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string_length);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string_alloc_size);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string_to_get_appended);
 
    // Calculate the new length after appending the new string.
    size_t new_size = FOUNDATIONAL_LIB_safe_add_3(*string_length, string_to_get_appended_length, 1); // Adding 1 for null terminator.
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0))
        goto overflow;
 
    // If the new length exceeds the current allocation size, reallocate memory.
    if (new_size > *string_alloc_size)
    {
        new_size = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(new_size);
 
        if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0))
            goto overflow;
 
        char *new_string = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(*string, new_size);
 
        if (FOUNDATIONAL_LIB_UNLIKELY(new_string == NULL))
            goto memory_error;
        *string = new_string;
        *string_alloc_size = new_size;
    }
 
    // Append the new string to the target string.
    FOUNDATIONAL_LIB_MEMCPY(*string + *string_length, string_to_get_appended, string_to_get_appended_length); /* Safe. */
    *string_length = *string_length + string_to_get_appended_length;
 
    // Null-terminate the resulting string.
    (*string)[*string_length] = '\0';
 
    return 0;
 
memory_error:
overflow:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
#define FOUNDATIONAL_LIB_INITIAL_DATA_ARRAY_ALLOC_SIZE FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE
 
FOUNDATIONAL_LIB_FUNC int append_data_to_array(void **array, size_t *array_size, size_t *array_current_alloc_size, void *data, size_t data_size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_size);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_current_alloc_size);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(data);
 
    // The _no_alloc functions omit this for optimization.
    if (*array_current_alloc_size == 0)
    {
        *array = (void *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(FOUNDATIONAL_LIB_INITIAL_DATA_ARRAY_ALLOC_SIZE);
        if (FOUNDATIONAL_LIB_UNLIKELY(*array == NULL))
        {
            *array_size = 0;
            *array_current_alloc_size = 0;
            goto memory_error;
        }
        *array_size = FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_COUNT;
        *array_current_alloc_size = FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE;
    }
 
    size_t new_size;
 
    new_size = FOUNDATIONAL_LIB_safe_add_2(*array_size, 1);
 
    size_t mul;
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0))
        goto overflow;
 
    mul = FOUNDATIONAL_LIB_safe_mul(new_size, data_size);
 
    // Check new_size and data_size so safe_mul doesn't get confused.
    if (FOUNDATIONAL_LIB_UNLIKELY(mul == 0 && new_size && data_size))
        goto overflow;
 
    // Realloc if needed.
    if (mul > *array_current_alloc_size)
    {
        const size_t new_size_total = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(mul);
 
        if (FOUNDATIONAL_LIB_UNLIKELY(new_size_total == 0))
            goto overflow;
 
        void **new_array = (void **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(*array, new_size_total);
        if (FOUNDATIONAL_LIB_UNLIKELY(new_array == NULL))
            goto memory_error;
 
        *array = new_array;
        *array_current_alloc_size = new_size_total;
    }
 
    /* Copy the data. */
 
    // Safe because *array_size * data_size is smaller than the number that
    // we checked for overflow.
    FOUNDATIONAL_LIB_MEMCPY((char *)*array + (*array_size) * data_size, data, data_size); /* Safe. */
    ++*array_size;
    return 0;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC int append_data_to_array_no_initial_alloc(void **array, size_t *array_size, size_t *array_current_alloc_size, void *data, size_t data_size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_size);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_current_alloc_size);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(data);
 
    const size_t new_size = FOUNDATIONAL_LIB_safe_add_2(*array_size, 1);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0))
        goto overflow;
 
    size_t nsize;
 
    nsize = FOUNDATIONAL_LIB_safe_mul(new_size, data_size);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(nsize == 0 && new_size && data_size))
        goto overflow;
 
    if (nsize > *array_current_alloc_size)
    {
        const size_t new_size_total = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(nsize);
 
        if (FOUNDATIONAL_LIB_UNLIKELY(new_size_total == 0))
            goto overflow;
 
        void **new_array = (void **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(*array, new_size_total);
        if (FOUNDATIONAL_LIB_UNLIKELY(new_array == NULL))
            goto memory_error;
        *array = new_array;
        *array_current_alloc_size = new_size_total;
    }
 
    /* Copy the data. */
 
    // Safe because *array_size * data_size is smaller than the number that
    // we checked for overflow.
    FOUNDATIONAL_LIB_MEMCPY((char *)*array + (*array_size) * data_size, data, data_size); /* Safe. */
 
    ++*array_size;
    return 0;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC int append_string_to_array(char ***array, size_t *array_size, size_t *array_current_alloc_size, const char *string)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_size);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_current_alloc_size);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
 
    // The _no_alloc functions omit this for optimization.
    if (*array_current_alloc_size == 0)
    {
        *array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE);
        if (FOUNDATIONAL_LIB_UNLIKELY(*array == NULL))
        {
            *array_size = 0;
            *array_current_alloc_size = 0;
            goto memory_error;
        }
        *array_size = FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_COUNT;
        *array_current_alloc_size = FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE;
    }
 
    size_t new_size;
 
    new_size = FOUNDATIONAL_LIB_safe_add_2(*array_size, 1); // Null terminator
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0))
        goto overflow;
    size_t new_size_total;
 
    new_size_total = FOUNDATIONAL_LIB_safe_mul(new_size, sizeof(char *));
 
    // Array size can be 0, which would confuse FOUNDATIONAL_LIB_safe_mul.
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size_total == 0 && *array_size))
        goto overflow;
 
    if (new_size_total > *array_current_alloc_size)
    {
        new_size_total = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(new_size_total);
        if (FOUNDATIONAL_LIB_UNLIKELY(new_size_total == 0))
            goto overflow;
 
        char **new_array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(*array, new_size_total);
        if (FOUNDATIONAL_LIB_UNLIKELY(new_array == NULL))
            goto memory_error;
        *array = new_array;
        *array_current_alloc_size = new_size_total;
    }
 
    (*array)[*array_size] = (char *)string;
 
    ++*array_size;
    return 0;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC int append_string_to_array_no_initial_alloc(char ***array, size_t *array_size, size_t *array_current_alloc_size, const char *string)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_size);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_current_alloc_size);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
 
    const size_t new_size = FOUNDATIONAL_LIB_safe_add_2(*array_size, 1); // Null terminator
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0))
        goto overflow;
    size_t new_size_total;
 
    new_size_total = FOUNDATIONAL_LIB_safe_mul(new_size, sizeof(char *));
 
    // Array size can be 0, which would confuse FOUNDATIONAL_LIB_safe_mul.
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size_total == 0 && *array_size))
        goto overflow;
 
    if (new_size_total > *array_current_alloc_size)
    {
        new_size_total = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(new_size_total);
        if (FOUNDATIONAL_LIB_UNLIKELY(new_size_total == 0))
            goto overflow;
 
        char **new_array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(*array, new_size_total);
        if (FOUNDATIONAL_LIB_UNLIKELY(new_array == NULL))
            goto memory_error;
        *array = new_array;
        *array_current_alloc_size = new_size_total;
    }
 
    (*array)[*array_size] = (char *)string;
 
    ++*array_size;
    return 0;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC int prepend_string_to_array(char ***array, size_t *array_size, size_t *array_current_alloc_size, char *string)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_size);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_current_alloc_size);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
    // The _no_alloc functions omit this for optimization.
    if (*array_current_alloc_size == 0)
    {
        *array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE);
        if (FOUNDATIONAL_LIB_UNLIKELY(*array == NULL))
        {
            /* Die immediately if enabled */
            FOUNDATIONAL_LIB_die_aggressively_if_enabled();
 
            *array_size = *array_current_alloc_size = 0;
            return -1;
        }
 
        *array_size = FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_COUNT;
        *array_current_alloc_size = FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE;
    }
 
    const size_t new_size = FOUNDATIONAL_LIB_safe_add_2(*array_size, 1);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0))
        goto overflow;
 
    if (new_size > *array_current_alloc_size)
    {
        const size_t new_size_total = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(new_size);
        if (FOUNDATIONAL_LIB_UNLIKELY(new_size_total == 0))
            goto overflow;
 
        char **new_array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(*array, new_size_total);
        if (FOUNDATIONAL_LIB_UNLIKELY(new_array == NULL))
            goto memory_error;
        *array = new_array;
 
        *array_current_alloc_size = new_size_total;
    }
 
    /* Move everything forward by 1 */
    FOUNDATIONAL_LIB_MEMMOVE(*array + 1 /* dest location */, *array /* src location */, ((*array_size++) * sizeof(char *)) /* size */);
 
    /* Set the string in the 0th position. */
    **array = string;
    return 0;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC int prepend_string_to_array_no_initial_alloc(char ***array, size_t *array_size, size_t *array_current_alloc_size, char *string)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_size);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_current_alloc_size);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
    const size_t copy_size = FOUNDATIONAL_LIB_safe_mul((*array_size), sizeof(char *));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(copy_size == 0 && *array_size))
        goto overflow;
 
    size_t new_size;
 
    new_size = FOUNDATIONAL_LIB_safe_add_2(*array_size, 1);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0))
        goto overflow;
 
    if (new_size > *array_current_alloc_size)
    {
        const size_t new_size_total = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(new_size);
 
        if (FOUNDATIONAL_LIB_UNLIKELY(new_size_total == 0))
            goto overflow;
 
        char **new_array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(*array, new_size_total);
 
        if (FOUNDATIONAL_LIB_UNLIKELY(new_array == NULL))
            goto memory_error;
 
        *array = new_array;
        *array_current_alloc_size = new_size_total;
    }
 
    /* Move everything forward by 1 */
    /* Does not return an error. */
 
    // If array size plus 1 does not overflow, this should be safe.
    FOUNDATIONAL_LIB_MEMMOVE(*array + 1 /* dest location */, *array /* src location */, (copy_size) /* size */);
    ++array_size;
 
    // Set the string in the 0th position.
    **array = string;
    return 0;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
FOUNDATIONAL_LIB_FUNC size_t array_total_string_length(char **array, size_t count)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    size_t length = 0;
 
    for (size_t i = 0; i < count; i++)
    {
        // NOTE: Do not check for overflows here.
        length += FOUNDATIONAL_LIB_STRLEN(array[i]);
    }
 
    return length;
}
 
#if FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED
 
FOUNDATIONAL_LIB_FUNC char *shellescape(const char *input)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(input);
    const size_t input_len = FOUNDATIONAL_LIB_STRLEN(input);
 
    const size_t size_with_null_t = input_len + 1;
    if (FOUNDATIONAL_LIB_UNLIKELY(size_with_null_t == 0))
        goto overflow;
    size_t escaped_len;
 
    escaped_len = FOUNDATIONAL_LIB_safe_mul(2, size_with_null_t);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(escaped_len == 0))
        goto overflow;
 
    char *escaped;
 
    escaped = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(escaped_len);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(escaped == NULL))
        goto memory_error;
 
    size_t j;
 
    j = 0;
 
    for (size_t i = 0; i < input_len; ++i)
    {
        // Escape special characters
        if (input[i] == ' ' || input[i] == '\t' || input[i] == '\n' || input[i] == '*' || input[i] == '?' || input[i] == '\'' || input[i] == '"' || input[i] == '\\' || input[i] == '$' || input[i] == '`' || input[i] == '(' || input[i] == ')' || input[i] == '&' || input[i] == ';' || input[i] == '|' || input[i] == '>' || input[i] == '<')
        {
            escaped[j++] = '\\';
        }
        escaped[j++] = input[i];
    }
 
    escaped[j] = '\0';
 
    return escaped;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return NULL;
}
#endif
 
FOUNDATIONAL_LIB_FUNC char *reverse_string(const char *str)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    char *new_str = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(str);
    if (FOUNDATIONAL_LIB_UNLIKELY(new_str == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
    size_t length = FOUNDATIONAL_LIB_STRLEN(new_str);
    size_t i, j;
 
    for (i = 0, j = length - 1; i < j; i++, j--)
    {
        char temp = new_str[i];
        new_str[i] = new_str[j];
        new_str[j] = temp;
    }
 
    return new_str;
}
 
static inline int starts_with(const char *str, const char *prefix) { return strncmp(str, prefix, FOUNDATIONAL_LIB_STRLEN(prefix)) == 0; }
 
static inline int ends_with(const char *str, const char *suffix)
{
    const size_t str_len = FOUNDATIONAL_LIB_STRLEN(str);
    const size_t suffix_len = FOUNDATIONAL_LIB_STRLEN(suffix);
 
    if (suffix_len > str_len)
    {
        return 0; // Suffix is longer than the string
    }
 
    return strncmp(str + str_len - suffix_len, suffix, suffix_len) == 0;
}
 
#if defined(__GNUC__) && !defined(_WIN32)
 
/* @brief Cross platform memmem() */
 
#define memory_locate memmem
 
#else
 
/* @brief Cross platform memmem(). Slower though. We need to find a faster solution for Windows. Maybe using assembly. */
FOUNDATIONAL_LIB_FUNC void *memory_locate(const void *haystack, size_t haystack_len, const void *needle, size_t needle_len)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(haystack);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(needle_len);
    if (FOUNDATIONAL_LIB_UNLIKELY(needle_len == 0))
    {
        return (void *)haystack;
    }
 
    if (FOUNDATIONAL_LIB_UNLIKELY(haystack_len < needle_len))
    {
        return NULL;
    }
 
    const char *h = (const char *)haystack;
    const char *n = (const char *)needle;
 
    const size_t max_search = haystack_len - needle_len;
    for (size_t i = 0; i <= max_search; ++i)
    {
        if (FOUNDATIONAL_LIB_MEMCMP(h + i, n, needle_len) == 0)
        {
            return (void *)(h + i);
        }
    }
 
    return NULL;
}
#endif
 
FOUNDATIONAL_LIB_FUNC size_t count_occurrences_of_substr(const char *str, const char *substring)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(substring);
    const size_t substring_length = FOUNDATIONAL_LIB_STRLEN(substring);
    const char *pos = str;
    size_t count = 0;
 
    while ((pos = FOUNDATIONAL_LIB_STRSTR(pos, substring)) != NULL)
    {
        ++count;
        pos += substring_length;
    }
 
    return count;
}
 
FOUNDATIONAL_LIB_FUNC int string_has_substr(const char *string, size_t string_length, const char *substring, size_t substring_length)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(substring);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(string_length == 0))
    {
        return 0;
    }
 
    if (FOUNDATIONAL_LIB_UNLIKELY(substring_length == 0))
    {
        return 0;
    }
 
    const char *beginning_of_substr_or_null = FOUNDATIONAL_LIB_STRSTR(string, substring);
    return beginning_of_substr_or_null != NULL;
}
 
FOUNDATIONAL_LIB_FUNC int memory_has_subchunk(void *memory, size_t memory_length, void *subchunk, size_t subchunk_length)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(memory);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(subchunk);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(memory_length == 0))
    {
        return 0;
    }
 
    // Alias to memmem() if we can.
    return (const char *)memory_locate(memory, memory_length, subchunk, subchunk_length) != NULL;
}
 
FOUNDATIONAL_LIB_FUNC size_t count_occurrences_of_substr_len(const char *string, size_t string_length, const char *substring, size_t substring_length)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(substring);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(string_length == 0))
    {
        return 0;
    }
 
    if (FOUNDATIONAL_LIB_UNLIKELY(substring_length == 0))
    {
        return 0;
    }
 
#if defined(__GNUC__) && defined(__unix__)
    size_t count = 0;
    size_t pos = 0;
 
    const size_t orig_string_length = string_length;
    /* This might be significantly faster than FOUNDATIONAL_LIB_STRSTR() */
    for (;;)
    {
        const char *beginning_of_substr_or_null = (const char *)memmem(string + pos, string_length, substring, substring_length);
 
        if (FOUNDATIONAL_LIB_UNLIKELY(beginning_of_substr_or_null == NULL))
            break;
 
        ++count;
 
        /* Update pos */
        pos = beginning_of_substr_or_null - string + substring_length;
        string_length = orig_string_length - pos;
    }
#else
    const char *pos = string;
    size_t count = 0;
    while ((pos = FOUNDATIONAL_LIB_STRSTR(pos, substring)) != NULL)
    {
        ++count;
        pos += substring_length;
    }
#endif
 
    return count;
}
 
static inline ssize_t index_of_char(const char *str, char chr)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    const char *result = FOUNDATIONAL_LIB_STRCHR(str, chr);
    return result != NULL ? result - str : -1;
}
 
static inline ssize_t last_index_of_char(const char *str, char chr)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    const char *result = strrchr(str, chr);
    return result != NULL ? result - str : -1;
}
 
FOUNDATIONAL_LIB_FUNC int is_string_numeric(const char *str)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
 
    const size_t len = FOUNDATIONAL_LIB_STRLEN(str);
 
    for (size_t i = 0; i < len; i++)
    {
        if (!FOUNDATIONAL_LIB_ISDIGIT(str[i]))
        {
            return 0; // Contains non-numeric character
        }
    }
 
    return 1; // Contains only numeric characters
}
 
FOUNDATIONAL_LIB_FUNC int is_string_alphanumeric(const char *str)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
 
    size_t len = FOUNDATIONAL_LIB_STRLEN(str);
 
    for (size_t i = 0; i < len; i++)
    {
        if (!FOUNDATIONAL_LIB_ISALNUM(str[i]))
        {
            return 0; // Contains non-alphanumeric character
        }
    }
 
    return 1; // Contains only alphanumeric characters
}
 
FOUNDATIONAL_LIB_FUNC char *longest_common_prefix(const char **strings, size_t count)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(strings);
    if (FOUNDATIONAL_LIB_UNLIKELY(count == 0))
    {
        char *ret = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(""); // Empty string for an empty array
        if (FOUNDATIONAL_LIB_UNLIKELY(ret == NULL))
        {
            FOUNDATIONAL_LIB_die_aggressively_if_enabled();
            return NULL;
        }
 
        return ret;
    }
 
    size_t max_common_len = FOUNDATIONAL_LIB_STRLEN(strings[0]);
 
    /* Find the max common length among the strings */
    for (size_t i = 1; i < count; ++i)
    {
        size_t current_len = FOUNDATIONAL_LIB_STRLEN(strings[i]);
        if (current_len < max_common_len)
        {
            max_common_len = current_len;
        }
    }
 
    /* Compare characters across the strings until a mismatch is found */
    for (size_t i = 0; i < max_common_len; ++i)
    {
        for (size_t j = 1; j < count; ++j)
        {
            if (strings[j][i] != strings[0][i])
            {
                /* Mismatch found, return the prefix up to this point */
 
                // Don't FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC 0.
                if (FOUNDATIONAL_LIB_UNLIKELY(i == SIZE_MAX))
                {
                    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                    return NULL;
                }
 
                char *result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(i + sizeof("")); /* Safe. */
                if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
                {
                    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                    return NULL;
                }
                FOUNDATIONAL_LIB_MEMCPY(result, strings[0], i);
                result[i] = '\0';
                return result;
            }
        }
    }
 
    /* All strings match up to the minimum length, return the entire prefix */
    char *dup = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(strings[0]);
    if (FOUNDATIONAL_LIB_UNLIKELY(dup == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    return dup;
}
 
FOUNDATIONAL_LIB_FUNC char *longest_common_suffix(const char **strings, size_t count)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(strings);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(count == 0))
    {
        char *return_value = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(""); // Empty string for an empty array
        if (FOUNDATIONAL_LIB_UNLIKELY(return_value == NULL))
        {
            FOUNDATIONAL_LIB_die_aggressively_if_enabled();
            return NULL;
        }
        return return_value;
    }
 
    size_t max_common_len = FOUNDATIONAL_LIB_STRLEN(strings[0]);
 
    /* Find the max common length among the strings */
    for (size_t i = 1; i < count; ++i)
    {
        size_t current_len = FOUNDATIONAL_LIB_STRLEN(strings[i]);
        if (current_len < max_common_len)
        {
            max_common_len = current_len;
        }
    }
 
    /* Compare characters across the strings until a mismatch is found */
    for (size_t i = 0; i < max_common_len; ++i)
    {
        for (size_t j = 1; j < count; ++j)
        {
            size_t current_len = FOUNDATIONAL_LIB_STRLEN(strings[j]);
            if (strings[j][current_len - i - 1] != strings[0][max_common_len - i - 1])
            {
                /* Mismatch found, return the suffix up to this point */
 
                // Don't FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC 0.
                if (FOUNDATIONAL_LIB_UNLIKELY(i == SIZE_MAX))
                {
                    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                    return NULL;
                }
 
                char *result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(i + sizeof("")); /* Safe. */
                if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
                {
                    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                    return NULL;
                }
 
                FOUNDATIONAL_LIB_MEMCPY(result, strings[0] + max_common_len - i, i); /* Safe. */
                result[i] = '\0';
                return result;
            }
        }
    }
 
    /* All strings match up to the minimum length, return the entire suffix */
    char *return_value = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(strings[0] + max_common_len); /* Should be Safe. */
    if (FOUNDATIONAL_LIB_UNLIKELY(return_value == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    return return_value;
}
 
static inline double str_to_double(const char *string)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
 
    return atof(string);
}
 
FOUNDATIONAL_LIB_FUNC ssize_t find_first_of(const char *str, const char *char_set)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(char_set);
 
    const char *result = strpbrk(str, char_set);
 
    return FOUNDATIONAL_LIB_likely(result != NULL) ? result - str : -1;
}
 
FOUNDATIONAL_LIB_FUNC ssize_t find_last_of(const char *str, const char *char_set)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(char_set);
 
    const size_t len = FOUNDATIONAL_LIB_STRLEN(str);
 
    for (ssize_t i = len - 1; i >= 0; i--)
    {
        if (FOUNDATIONAL_LIB_STRCHR(char_set, str[i]) != NULL)
        {
            return i;
        }
    }
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC void reverse_string_in_place(char *str)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
 
    const size_t len = FOUNDATIONAL_LIB_STRLEN(str);
 
    /* Swap characters from both ends towards the center */
    for (size_t i = 0, j = len - 1; i < j; ++i, --j)
    {
        char temp = str[i];
        str[i] = str[j];
        str[j] = temp;
    }
}
 
FOUNDATIONAL_LIB_FUNC int is_string_valid_integer(const char *str)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
 
    if (*str == '\0')
    {
        return 0; // Empty string is not a valid integer
    }
 
    /* Check for optional sign */
    if (*str == '+' || *str == '-')
    {
        ++str;
    }
 
    /* Check for at least one digit */
    if (!FOUNDATIONAL_LIB_ISDIGIT(*str))
    {
        return 0;
    }
 
    /* Check for remaining digits */
    while (*str != '\0')
    {
        if (!FOUNDATIONAL_LIB_ISDIGIT(*str))
        {
            return 0;
        }
        ++str;
    }
 
    return 1; // Valid integer
}
 
FOUNDATIONAL_LIB_FUNC size_t common_prefix_length(const char *str1, const char *str2)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str1);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str2);
 
    const size_t len1 = FOUNDATIONAL_LIB_STRLEN(str1);
    const size_t len2 = FOUNDATIONAL_LIB_STRLEN(str2);
 
    const size_t min_len = (len1 < len2) ? len1 : len2;
 
    for (size_t i = 0; i < min_len; i++)
    {
        if (str1[i] != str2[i])
        {
            return i; // Mismatch found, return current index
        }
    }
 
    return min_len; // No mismatch found, return the minimum length
}
 
FOUNDATIONAL_LIB_FUNC size_t common_suffix_length(const char *str1, const char *str2)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str1);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str2);
 
    const size_t len1 = FOUNDATIONAL_LIB_STRLEN(str1);
    const size_t len2 = FOUNDATIONAL_LIB_STRLEN(str2);
 
    const size_t min_len = (len1 < len2) ? len1 : len2;
 
    for (size_t i = 1; i <= min_len; i++)
    {
        if (str1[len1 - i] != str2[len2 - i])
        {
            return i - 1; // Mismatch found, return previous index
        }
    }
 
    return min_len; // No mismatch found, return the minimum length
}
 
FOUNDATIONAL_LIB_FUNC char *string_to_title_case(const char *str)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
 
    const size_t len = FOUNDATIONAL_LIB_STRLEN(str);
    if (FOUNDATIONAL_LIB_UNLIKELY(len == SIZE_MAX))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    char *title_case = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(len + sizeof("")); /* Safe. */
 
    if (FOUNDATIONAL_LIB_UNLIKELY(title_case == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    int make_upper = 1; // Start with the first character as uppercase
 
    for (size_t i = 0; i < len; i++)
    {
        if (FOUNDATIONAL_LIB_ISSPACE(str[i]))
        {
            make_upper = 1; // Set the flag to capitalize the next character
            title_case[i] = str[i];
        }
        else
        {
            title_case[i] = make_upper ? toupper(str[i]) : tolower(str[i]);
            make_upper = 0; // Reset the flag
        }
    }
 
    title_case[len] = '\0';
 
    return title_case;
}
 
FOUNDATIONAL_LIB_FUNC int find_max_int_in_array(const int *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    if (FOUNDATIONAL_LIB_UNLIKELY(size == 0))
    {
        /* Handle empty array case */
        return -1;
    }
 
    int max = array[0];
 
    for (size_t i = 1; i < size; i++)
    {
        if (array[i] > max)
        {
            max = array[i];
        }
    }
 
    return max;
}
 
FOUNDATIONAL_LIB_FUNC int find_min_int_in_array(const int *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    if (FOUNDATIONAL_LIB_UNLIKELY(size == 0))
    {
        /* Handle empty array case */
        return -1;
    }
 
    int min = array[0];
 
    for (size_t i = 1; i < size; i++)
    {
        if (array[i] < min)
        {
            min = array[i];
        }
    }
 
    return min;
}
 
FOUNDATIONAL_LIB_FUNC int sum_of_int_array(const int *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    int sum = 0;
 
    for (size_t i = 0; i < size; ++i)
    {
        sum += array[i];
    }
 
    return sum;
}
 
FOUNDATIONAL_LIB_FUNC void reverse_int_array_in_place(int *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
 
    for (size_t i = 0, j = size - 1; i < j; ++i, --j)
    {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}
 
FOUNDATIONAL_LIB_FUNC int ints_are_sorted_ascending(const int *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    for (size_t i = 1; i < size; ++i)
    {
        if (array[i] < array[i - 1])
        {
            return 0; // Not sorted in ascending order
        }
    }
    return 1; // Sorted in ascending order
}
 
FOUNDATIONAL_LIB_FUNC int ints_are_sorted_descending(const int *array, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    for (size_t i = 1; i < size; ++i)
    {
        if (array[i] > array[i - 1])
        {
            return 0; // Not sorted in descending order
        }
    }
    return 1; // Sorted in descending order
}
 
FOUNDATIONAL_LIB_FUNC size_t *generate_range(size_t start, size_t end, size_t step, size_t *range_size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(range_size);
    // Check for invalid range
    if (FOUNDATIONAL_LIB_UNLIKELY(start > end || step == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
    const size_t size = (end - start) / step + 1;
 
    if (FOUNDATIONAL_LIB_UNLIKELY(size == 0))
    { // Overflow
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    const size_t alloc_size = FOUNDATIONAL_LIB_safe_mul(size, sizeof(size_t));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size == 0))
    { // Overflow
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    size_t *range = (size_t *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(range == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    for (size_t i = 0, value = start; i < size; ++i, value += step)
    {
        range[i] = value;
    }
 
    *range_size = size;
    return range;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmpstringp(const void *p1, const void *p2)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(p1);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(p2);
    return FOUNDATIONAL_LIB_STRCMP(*(const char **)p1, *(const char **)p2);
}
 
FOUNDATIONAL_LIB_FUNC void sort_strings(char **strings, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(strings);
    qsort(strings, size, sizeof(char *), FOUNDATIONAL_LIB_cmpstringp);
}
 
FOUNDATIONAL_LIB_FUNC char **sorted_strings(char **strings, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(strings);
 
    char **dup_strings = (char **)arraydup(strings, size, sizeof(char *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_strings == NULL))
    {
        return NULL; /* No need to re die aggressively. */
    }
    qsort(dup_strings, size, sizeof(char *), FOUNDATIONAL_LIB_cmpstringp);
    return dup_strings;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_uints(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(unsigned int *)a - *(unsigned int *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_uints(unsigned int *uints, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(uints);
 
    qsort(uints, size, sizeof(unsigned int), FOUNDATIONAL_LIB_cmp_uints);
}
 
FOUNDATIONAL_LIB_FUNC unsigned int *sorted_uints(unsigned int *uints, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(uints);
 
    unsigned int *dup_uints = (unsigned int *)arraydup(uints, size, sizeof(unsigned int));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_uints == NULL))
    {
        return NULL;
    }
    qsort(uints, size, sizeof(unsigned int), FOUNDATIONAL_LIB_cmp_uints);
    return dup_uints;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_uint_ptrs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(unsigned int **)a - *(unsigned int **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_uint_ptrs(unsigned int **uint_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(uint_ptrs);
 
    qsort(uint_ptrs, size, sizeof(unsigned int *), FOUNDATIONAL_LIB_cmp_uint_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC unsigned int **sorted_uint_ptrs(unsigned int **uint_ptrs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(uint_ptrs);
 
    unsigned int **dup_uint_ptrs = (unsigned int **)arraydup(uint_ptrs, size, sizeof(unsigned int *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_uint_ptrs == NULL))
    {
        return NULL;
    }
    qsort(uint_ptrs, size, sizeof(unsigned int *), FOUNDATIONAL_LIB_cmp_uint_ptrs);
    return dup_uint_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_ints(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
 
    return (*(int *)a - *(int *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_ints(int *ints, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ints);
    qsort(ints, size, sizeof(int), FOUNDATIONAL_LIB_cmp_ints);
}
 
FOUNDATIONAL_LIB_FUNC int *sorted_ints(int *ints, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ints);
 
    int *dup_ints = (int *)arraydup(ints, size, sizeof(int));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_ints == NULL))
    {
        return NULL;
    }
 
    qsort(ints, size, sizeof(int), FOUNDATIONAL_LIB_cmp_ints);
    return dup_ints;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_int_ptrs(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(int **)a - *(int **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_int_ptrs(int **int_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(int_ptrs);
    qsort(int_ptrs, size, sizeof(int *), FOUNDATIONAL_LIB_cmp_int_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC int **sorted_int_ptrs(int **int_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(int_ptrs);
    int **dup_int_ptrs = (int **)arraydup(int_ptrs, size, sizeof(int *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_int_ptrs == NULL))
    {
        return NULL;
    }
    qsort(int_ptrs, size, sizeof(int *), FOUNDATIONAL_LIB_cmp_int_ptrs);
    return dup_int_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_uchars(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(unsigned char *)a - *(unsigned char *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_uchars(unsigned char *uchars, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(uchars);
    qsort(uchars, size, sizeof(unsigned char), FOUNDATIONAL_LIB_cmp_uchars);
}
 
FOUNDATIONAL_LIB_FUNC unsigned char *sorted_uchars(unsigned char *uchars, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(uchars);
 
    unsigned char *dup_uchars = (unsigned char *)arraydup(uchars, size, sizeof(unsigned char));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_uchars == NULL))
    {
        return NULL;
    }
    qsort(uchars, size, sizeof(unsigned char), FOUNDATIONAL_LIB_cmp_uchars);
    return dup_uchars;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_uchar_ptrs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(unsigned char **)a - *(unsigned char **)b);
}
FOUNDATIONAL_LIB_FUNC void sort_uchar_ptrs(unsigned char **uchar_ptrs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(uchar_ptrs);
    qsort(uchar_ptrs, size, sizeof(unsigned char *), FOUNDATIONAL_LIB_cmp_uchar_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC unsigned char **sorted_uchar_ptrs(unsigned char **uchar_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(uchar_ptrs);
    unsigned char **dup_uchar_ptrs = (unsigned char **)arraydup(uchar_ptrs, size, sizeof(unsigned char *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_uchar_ptrs == NULL))
    {
        return NULL;
    }
    qsort(uchar_ptrs, size, sizeof(unsigned char *), FOUNDATIONAL_LIB_cmp_uchar_ptrs);
    return dup_uchar_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_chars(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(char *)a - *(char *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_chars(char *chars, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(chars);
    qsort(chars, size, sizeof(char), FOUNDATIONAL_LIB_cmp_chars);
}
 
FOUNDATIONAL_LIB_FUNC char *sorted_chars(char *chars, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(chars);
    char *dup_chars = (char *)arraydup(chars, size, sizeof(char));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_chars == NULL))
    {
        return NULL;
    }
    qsort(chars, size, sizeof(char), FOUNDATIONAL_LIB_cmp_chars);
    return dup_chars;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_char_ptrs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
 
    return (*(char **)a - *(char **)b);
}
FOUNDATIONAL_LIB_FUNC void sort_char_ptrs(char **char_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(char_ptrs);
 
    qsort(char_ptrs, size, sizeof(char *), FOUNDATIONAL_LIB_cmp_char_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC char **sorted_char_ptrs(char **char_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(char_ptrs);
    char **dup_char_ptrs = (char **)arraydup(char_ptrs, size, sizeof(char *));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_char_ptrs == NULL))
    {
        return NULL;
    }
 
    qsort(char_ptrs, size, sizeof(char *), FOUNDATIONAL_LIB_cmp_char_ptrs);
    return dup_char_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_ushorts(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(unsigned short *)a - *(unsigned short *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_ushorts(unsigned short *ushorts, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ushorts);
 
    qsort(ushorts, size, sizeof(unsigned short), FOUNDATIONAL_LIB_cmp_ushorts);
}
 
FOUNDATIONAL_LIB_FUNC unsigned short *sorted_ushorts(unsigned short *ushorts, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ushorts);
    unsigned short *dup_ushorts = (unsigned short *)arraydup(ushorts, size, sizeof(unsigned short));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_ushorts == NULL))
    {
        return NULL;
    }
 
    qsort(ushorts, size, sizeof(unsigned short), FOUNDATIONAL_LIB_cmp_ushorts);
    return dup_ushorts;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_ushort_ptrs(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
 
    return (*(unsigned short **)a - *(unsigned short **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_ushort_ptrs(unsigned short **ushort_ptrs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ushort_ptrs);
    qsort(ushort_ptrs, size, sizeof(unsigned short *), FOUNDATIONAL_LIB_cmp_ushort_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC unsigned short **sorted_ushort_ptrs(unsigned short **ushort_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ushort_ptrs);
 
    unsigned short **dup_ushort_ptrs = (unsigned short **)arraydup(ushort_ptrs, size, sizeof(unsigned short *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_ushort_ptrs == NULL))
    {
        return NULL;
    }
 
    qsort(ushort_ptrs, size, sizeof(unsigned short *), FOUNDATIONAL_LIB_cmp_ushort_ptrs);
    return dup_ushort_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_shorts(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(short *)a - *(short *)b);
}
FOUNDATIONAL_LIB_FUNC void sort_shorts(short *shorts, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(shorts);
    qsort(shorts, size, sizeof(short), FOUNDATIONAL_LIB_cmp_shorts);
}
 
FOUNDATIONAL_LIB_FUNC short *sorted_shorts(short *shorts, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(shorts);
 
    short *dup_shorts = (short *)arraydup(shorts, size, sizeof(short));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_shorts == NULL))
    {
        return NULL;
    }
 
    qsort(shorts, size, sizeof(short), FOUNDATIONAL_LIB_cmp_shorts);
    return dup_shorts;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_short_ptrs(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(short **)a - *(short **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_short_ptrs(short **short_ptrs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(short_ptrs);
    qsort(short_ptrs, size, sizeof(short *), FOUNDATIONAL_LIB_cmp_short_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC short **sorted_short_ptrs(short **short_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(short_ptrs);
 
    short **dup_short_ptrs = (short **)arraydup(short_ptrs, size, sizeof(short *));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_short_ptrs == NULL))
    {
        return NULL;
    }
 
    qsort(short_ptrs, size, sizeof(short *), FOUNDATIONAL_LIB_cmp_short_ptrs);
    return dup_short_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_ulongs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(unsigned long *)a - *(unsigned long *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_ulongs(unsigned long *ulongs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ulongs);
    qsort(ulongs, size, sizeof(unsigned long), FOUNDATIONAL_LIB_cmp_ulongs);
}
 
FOUNDATIONAL_LIB_FUNC unsigned long *sorted_ulongs(unsigned long *ulongs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ulongs);
    unsigned long *dup_ulongs = (unsigned long *)arraydup(ulongs, size, sizeof(unsigned long));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_ulongs == NULL))
    {
        return NULL;
    }
 
    qsort(ulongs, size, sizeof(unsigned long), FOUNDATIONAL_LIB_cmp_ulongs);
    return dup_ulongs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_ulong_ptrs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
 
    return (*(unsigned long **)a - *(unsigned long **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_ulong_ptrs(unsigned long **ulong_ptrs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ulong_ptrs);
    qsort(ulong_ptrs, size, sizeof(unsigned long *), FOUNDATIONAL_LIB_cmp_ulong_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC unsigned long **sorted_ulong_ptrs(unsigned long **ulong_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ulong_ptrs);
 
    unsigned long **dup_ulong_ptrs = (unsigned long **)arraydup(ulong_ptrs, size, sizeof(unsigned long *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_ulong_ptrs == NULL))
    {
        return NULL;
    }
 
    qsort(ulong_ptrs, size, sizeof(unsigned long *), FOUNDATIONAL_LIB_cmp_ulong_ptrs);
    return dup_ulong_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_longs(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(long *)a - *(long *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_longs(long *longs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(longs);
 
    qsort(longs, size, sizeof(long), FOUNDATIONAL_LIB_cmp_longs);
}
 
FOUNDATIONAL_LIB_FUNC long *sorted_longs(long *longs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(longs);
 
    long *dup_longs = (long *)arraydup(longs, size, sizeof(long));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_longs == NULL))
    {
        return NULL;
    }
 
    qsort(longs, size, sizeof(long), FOUNDATIONAL_LIB_cmp_longs);
    return dup_longs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_long_ptrs(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(long **)a - *(long **)b);
}
FOUNDATIONAL_LIB_FUNC void sort_long_ptrs(long **long_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(long_ptrs);
    qsort(long_ptrs, size, sizeof(long *), FOUNDATIONAL_LIB_cmp_long_ptrs);
}
FOUNDATIONAL_LIB_FUNC long **sorted_long_ptrs(long **long_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(long_ptrs);
    long **dup_long_ptrs = (long **)arraydup(long_ptrs, size, sizeof(long *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_long_ptrs == NULL))
    {
        return NULL;
    }
 
    qsort(long_ptrs, size, sizeof(long *), FOUNDATIONAL_LIB_cmp_long_ptrs);
    return dup_long_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_ulong_longs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(unsigned long long *)a - *(unsigned long long *)b);
}
FOUNDATIONAL_LIB_FUNC void sort_ulong_longs(unsigned long long *ulong_longs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ulong_longs);
 
    qsort(ulong_longs, size, sizeof(unsigned long long), FOUNDATIONAL_LIB_cmp_ulong_longs);
}
FOUNDATIONAL_LIB_FUNC unsigned long long *sorted_ulong_longs(unsigned long long *ulong_longs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ulong_longs);
    unsigned long long *dup_ulong_longs = (unsigned long long *)arraydup(ulong_longs, size, sizeof(unsigned long long));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_ulong_longs == NULL))
    {
        return NULL;
    }
 
    qsort(ulong_longs, size, sizeof(unsigned long long), FOUNDATIONAL_LIB_cmp_ulong_longs);
    return dup_ulong_longs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_ulong_long_ptrs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
 
    return (*(unsigned long long **)a - *(unsigned long long **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_ulong_long_ptrs(unsigned long long **ulong_long_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ulong_long_ptrs);
    qsort(ulong_long_ptrs, size, sizeof(unsigned long long *), FOUNDATIONAL_LIB_cmp_ulong_long_ptrs);
}
FOUNDATIONAL_LIB_FUNC unsigned long long **sorted_ulong_long_ptrs(unsigned long long **ulong_long_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(ulong_long_ptrs);
 
    unsigned long long **dup_ulong_long_ptrs = (unsigned long long **)arraydup(ulong_long_ptrs, size, sizeof(unsigned long long *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_ulong_long_ptrs == NULL))
    {
        return NULL;
    }
 
    qsort(ulong_long_ptrs, size, sizeof(unsigned long long *), FOUNDATIONAL_LIB_cmp_ulong_long_ptrs);
    return dup_ulong_long_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_long_longs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(long long *)a - *(long long *)b);
}
FOUNDATIONAL_LIB_FUNC void sort_long_longs(long long *long_longs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(long_longs);
    qsort(long_longs, size, sizeof(long long), FOUNDATIONAL_LIB_cmp_long_longs);
}
FOUNDATIONAL_LIB_FUNC long long *sorted_long_longs(long long *long_longs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(long_longs);
    long long *dup_long_longs = (long long *)arraydup(long_longs, size, sizeof(long long));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_long_longs == NULL))
    {
        return NULL;
    }
 
    qsort(long_longs, size, sizeof(long long), FOUNDATIONAL_LIB_cmp_long_longs);
    return dup_long_longs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_long_long_ptrs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(long long **)a - *(long long **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_long_long_ptrs(long long **long_long_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(long_long_ptrs);
    qsort(long_long_ptrs, size, sizeof(long long *), FOUNDATIONAL_LIB_cmp_long_long_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC long long **sorted_long_long_ptrs(long long **long_long_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(long_long_ptrs);
 
    long long **dup_long_long_ptrs = (long long **)arraydup(long_long_ptrs, size, sizeof(long long *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_long_long_ptrs == NULL))
    {
        return NULL;
    }
 
    qsort(long_long_ptrs, size, sizeof(long long *), FOUNDATIONAL_LIB_cmp_long_long_ptrs);
    return dup_long_long_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_floats(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(float *)a - *(float *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_floats(float *floats, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(floats);
    qsort(floats, size, sizeof(float), FOUNDATIONAL_LIB_cmp_floats);
}
 
FOUNDATIONAL_LIB_FUNC float *sorted_floats(float *floats, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(floats);
 
    float *dup_floats = (float *)arraydup(floats, size, sizeof(float));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_floats == NULL))
    {
        return NULL;
    }
 
    qsort(floats, size, sizeof(float), FOUNDATIONAL_LIB_cmp_floats);
    return dup_floats;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_float_ptrs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(float **)a - *(float **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_float_ptrs(float **float_ptrs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(float_ptrs);
    qsort(float_ptrs, size, sizeof(float *), FOUNDATIONAL_LIB_cmp_float_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC float **sorted_float_ptrs(float **float_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(float_ptrs);
 
    float **dup_float_ptrs = (float **)arraydup(float_ptrs, size, sizeof(float *));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_float_ptrs == NULL))
    {
        return NULL;
    }
    qsort(float_ptrs, size, sizeof(float *), FOUNDATIONAL_LIB_cmp_float_ptrs);
    return dup_float_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_doubles(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
 
    return (*(double *)a - *(double *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_doubles(double *doubles, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(doubles);
    qsort(doubles, size, sizeof(double), FOUNDATIONAL_LIB_cmp_doubles);
}
 
FOUNDATIONAL_LIB_FUNC double *sorted_doubles(double *doubles, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(doubles);
    double *dup_doubles = (double *)arraydup(doubles, size, sizeof(double));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_doubles == NULL))
    {
        return NULL;
    }
    qsort(doubles, size, sizeof(double), FOUNDATIONAL_LIB_cmp_doubles);
    return dup_doubles;
}
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_double_ptrs(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(double **)a - *(double **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_double_ptrs(double **double_ptrs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(double_ptrs);
    qsort(double_ptrs, size, sizeof(double *), FOUNDATIONAL_LIB_cmp_double_ptrs);
}
 
FOUNDATIONAL_LIB_FUNC double **sorted_double_ptrs(double **double_ptrs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(double_ptrs);
 
    double **dup_double_ptrs = (double **)arraydup(double_ptrs, size, sizeof(double *));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_double_ptrs == NULL))
    {
        return NULL;
    }
    qsort(double_ptrs, size, sizeof(double *), FOUNDATIONAL_LIB_cmp_double_ptrs);
    return dup_double_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_size_ts(const void *a, const void *b)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(size_t *)a - *(size_t *)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_size_ts(size_t *size_ts, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size_ts);
    qsort(size_ts, size, sizeof(size_t), FOUNDATIONAL_LIB_cmp_size_ts);
}
 
FOUNDATIONAL_LIB_FUNC size_t *sorted_size_ts(size_t *size_ts, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size_ts);
 
    size_t *dup_size_ts = (size_t *)arraydup(size_ts, size, sizeof(size_t));
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_size_ts == NULL))
    {
        return NULL;
    }
    qsort(size_ts, size, sizeof(size_t), FOUNDATIONAL_LIB_cmp_size_ts);
    return dup_size_ts;
}
 
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_cmp_size_t_ptrs(const void *a, const void *b)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(a);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(b);
    return (*(size_t **)a - *(size_t **)b);
}
 
FOUNDATIONAL_LIB_FUNC void sort_size_t_ptrs(size_t **size_t_ptrs, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size_t_ptrs);
    qsort(size_t_ptrs, size, sizeof(size_t *), FOUNDATIONAL_LIB_cmp_size_t_ptrs);
}
FOUNDATIONAL_LIB_FUNC size_t **sorted_size_t_ptrs(size_t **size_t_ptrs, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size_t_ptrs);
 
    size_t **dup_size_t_ptrs = (size_t **)arraydup(size_t_ptrs, size, sizeof(size_t *));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(dup_size_t_ptrs == NULL))
    {
        return NULL;
    }
 
    qsort(size_t_ptrs, size, sizeof(size_t *), FOUNDATIONAL_LIB_cmp_size_t_ptrs);
 
    return dup_size_t_ptrs;
}
 
FOUNDATIONAL_LIB_FUNC int string_to_int(const char *str)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    return FOUNDATIONAL_LIB_ATOI(str);
}
 
FOUNDATIONAL_LIB_FUNC char *read_file_into_string(const char *filename, size_t *size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size);
 
    *size = 0;
 
    FILE *file = fopen(filename, "rb");
    if (FOUNDATIONAL_LIB_UNLIKELY(file == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL; // Indicate error by returning NULL
    }
 
    // Determine the file size by seeking
    if (FOUNDATIONAL_LIB_FSEEKO(file, 0, SEEK_END) != 0)
    {
        FOUNDATIONAL_LIB_FCLOSE(file); // No need to error check here because already going wrong.
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    // Get file size with tell
    const off_t file_size = FOUNDATIONAL_LIB_FTELLO(file); /* signed int type */
    if (FOUNDATIONAL_LIB_UNLIKELY(file_size == -1))
    {
        FOUNDATIONAL_LIB_FCLOSE(file); // No need to error check here because already going wrong.
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    *size = (size_t)file_size;
 
    // Since off_t is signed, it should be less than SIZE_MAX, so don't check
    // if it equals SIZE_MAX before adding 1 more to it to FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC()
 
    // Seek to the beginning again
    if (FOUNDATIONAL_LIB_FSEEKO(file, 0, SEEK_SET) != 0)
    {
        FOUNDATIONAL_LIB_FCLOSE(file); // No need to error check here because already going wrong.
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    // Allocate memory for the file contents
    char *content = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(file_size + 1); /* Safe. */
    if (FOUNDATIONAL_LIB_UNLIKELY(content == NULL))
    {
        FOUNDATIONAL_LIB_FCLOSE(file); // No need to error check here because already going wrong.
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    // Read the file contents into the string
    size_t total_read = 0;
    const size_t file_size_size_t = (size_t)file_size;
 
    while (total_read < file_size_size_t)
    {
        const size_t read_size = FOUNDATIONAL_LIB_FREAD(content + total_read, 1, file_size - total_read, file);
 
        if (read_size == 0) // Not likely or unlikely.
        {
            const int error_code = FOUNDATIONAL_LIB_FERROR(file);
            if (FOUNDATIONAL_LIB_UNLIKELY(error_code))
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(content);
                FOUNDATIONAL_LIB_FCLOSE(file); // Don't need to error check here because things are going
                                               // wrong.
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return NULL;
            }
            else
            {
                break;
            }
        }
        total_read += read_size;
    }
 
    // Null-terminate the string
    content[total_read] = '\0';
 
    // Close the file
    if (FOUNDATIONAL_LIB_UNLIKELY(fclose(file) != 0)) // Check for errors.
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(content);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    return content;
}
 
FOUNDATIONAL_LIB_FUNC int write_to_file_with_mode(const char *filename, const char *content, size_t content_length, const char *mode)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(content);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(mode);
    FILE *file = fopen(filename, mode);
    if (FOUNDATIONAL_LIB_UNLIKELY(file == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    /* Write the string to the file */
    size_t write_size;
    size_t total_written = 0;
 
    /* No need to check for EINTR. It would just slow things down here. */
    while ((write_size = FOUNDATIONAL_LIB_FWRITE(content + total_written, 1, content_length - total_written, file)) > 0)
    {
        total_written += write_size;
    }
 
    // Close the file
    if (FOUNDATIONAL_LIB_UNLIKELY(fclose(file) != 0)) // Check for errors.
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC int write_file(const char *filename, const char *content)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(content);
 
    /* This function is inlined by default. */
    return write_to_file_with_mode(filename, content, FOUNDATIONAL_LIB_STRLEN(content), "w");
}
 
FOUNDATIONAL_LIB_FUNC int append_string_to_file(const char *filename, const char *content)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(content);
 
    /* This function is inlined by default. */
    return write_to_file_with_mode(filename, content, FOUNDATIONAL_LIB_STRLEN(content), "a");
}
 
#ifdef _WIN32
#include <io.h>
#else
#include <unistd.h>
#endif
 
#include <sys/stat.h>
 
FOUNDATIONAL_LIB_FUNC int file_exists(const char *filename)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
 
#ifdef _WIN32
    return _access(filename, 0) == 0;
#else
    return access(filename, F_OK) == 0;
#endif
}
 
FOUNDATIONAL_LIB_FUNC int file_is_regular(const char *filename)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
 
    struct stat st;
#ifdef _WIN32
    if (stat(filename, &st) == 0)
        return (st.st_mode & _S_IFREG) != 0;
#else
    if (stat(filename, &st) == 0)
        return S_ISREG(st.st_mode);
#endif
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC int file_is_directory(const char *filename)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
 
    struct stat st;
#ifdef _WIN32
    if (stat(filename, &st) == 0)
        return (st.st_mode & _S_IFDIR) != 0;
#else
    if (stat(filename, &st) == 0)
        return S_ISDIR(st.st_mode);
#endif
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC int file_is_readable(const char *filename)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
 
#ifdef _WIN32
    return _access(filename, 4) == 0; // 4 is for read permission on Windows
#else
    return access(filename, R_OK) == 0; // R_OK is for read permission on POSIX systems
#endif
}
 
FOUNDATIONAL_LIB_FUNC int file_is_writable(const char *filename)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
 
#ifdef _WIN32
    return _access(filename, 2) == 0; // 2 is for write permission on Windows
#else
    return access(filename, W_OK) == 0; // W_OK is for write permission on POSIX systems
#endif
}
 
FOUNDATIONAL_LIB_FUNC int file_is_executable(const char *filename)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
 
#ifdef _WIN32
    return _access(filename, 1) == 0; // 1 is for execute permission on Windows
#else
    return access(filename, X_OK) == 0; // X_OK is for execute permission on POSIX systems
#endif
}
 
FOUNDATIONAL_LIB_FUNC int get_file_size(const char *filename, size_t *size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size);
 
    FILE *file = fopen(filename, "r");
    if (FOUNDATIONAL_LIB_UNLIKELY(file == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    // Determine the file size with seek
    if (FOUNDATIONAL_LIB_UNLIKELY(FOUNDATIONAL_LIB_FSEEKO(file, 0, SEEK_END) != 0))
    {
        FOUNDATIONAL_LIB_FCLOSE(file); // No need to error check here because already going wrong.
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    // Get the file size with tell
    const off_t file_size = ftello(file);
    if (FOUNDATIONAL_LIB_UNLIKELY(file_size == -1))
    {
        FOUNDATIONAL_LIB_FCLOSE(file); // No need to error check here because already going wrong.
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    // Close the file
    if (FOUNDATIONAL_LIB_UNLIKELY(fclose(file) != 0)) // Error check
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    *size = file_size;
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC int remove_file(const char *filename)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
 
    /* Standard c function */
    if (FOUNDATIONAL_LIB_UNLIKELY(remove(filename) != 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC int copy_file(const char *source_filename, const char *destination_filename)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(source_filename);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(destination_filename);
    FILE *source_file = fopen(source_filename, "rb");
 
    if (FOUNDATIONAL_LIB_UNLIKELY(source_file == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    FILE *destination_file = fopen(destination_filename, "wb");
    if (FOUNDATIONAL_LIB_UNLIKELY(destination_file == NULL))
    {
        FOUNDATIONAL_LIB_FCLOSE(source_file); // No need to error check here because already going
                                              // wrong.
 
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    char buffer[FOUNDATIONAL_LIB_COPY_SIZE_AMOUNT];
 
    for (;;)
    {
        // Read from the file.
        size_t read_size;
        int error_code;
 
        /* Handle interrupted system calls */
 
        do
        {
            read_size = FOUNDATIONAL_LIB_FREAD(buffer, 1, sizeof(buffer), source_file);
        } while (FOUNDATIONAL_LIB_UNLIKELY((error_code = FOUNDATIONAL_LIB_FERROR(source_file)) && errno == EINTR)); /* Check for EINTR */
 
        // If it has finished reading or if an error has occured.
        if (read_size == 0) // Not likely or unlikely.
        {
            if (FOUNDATIONAL_LIB_UNLIKELY(error_code))
            {
                /*
                 * Here, we can distinuish between errors to ignore, and errors to to
                 * about. Adjust this based on your environment or preferences.
                 */
 
                FOUNDATIONAL_LIB_FCLOSE(destination_file); // Don't need to error check here because
                                                           // things are going wrong.
                FOUNDATIONAL_LIB_FCLOSE(source_file);      // Don't need to error check here because things
                                                           // are going wrong.
 
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return -1;
            }
            else
            {
                break;
            }
        }
 
        /* Handle interrupted system calls */
 
        size_t write_size = 0;
        size_t new_write_size;
        do
        {
            new_write_size = FOUNDATIONAL_LIB_FWRITE(buffer + write_size, 1, read_size - write_size, destination_file);
            write_size += new_write_size;
        } while (write_size != read_size || FOUNDATIONAL_LIB_UNLIKELY(errno == EINTR)); /* Check for EINTR */
    }
 
    if (FOUNDATIONAL_LIB_UNLIKELY(ferror(source_file) != 0 || FOUNDATIONAL_LIB_FERROR(destination_file) != 0))
    {
        FOUNDATIONAL_LIB_FCLOSE(source_file);      // No need to error check here because already going
                                                   // wrong.
        FOUNDATIONAL_LIB_FCLOSE(destination_file); // No need to error check here because already
                                                   // going wrong.
 
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    if (FOUNDATIONAL_LIB_UNLIKELY(fclose(source_file) != 0 || FOUNDATIONAL_LIB_FCLOSE(destination_file) != 0)) // Error check
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    return 0;
}
 
#ifdef _WIN32
#include <windows.h>
 
FOUNDATIONAL_LIB_FUNC char **list_files_with_pattern(const char *directory, const char *pattern, size_t *len)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(directory);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(pattern);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(len);
 
    *len = 0;
    char search_path[MAX_PATH];
    FOUNDATIONAL_LIB_SNPRINTF(search_path, MAX_PATH, "%s\\%s", directory, pattern);
 
    WIN32_FIND_DATA find_file_data;
    HANDLE find_handle = FindFirstFile(search_path, &find_file_data);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(find_handle == INVALID_HANDLE_VALUE))
    {
 
        /* One element of size zero. */
        char **new_array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(sizeof(char *));
        *new_array = NULL;
        return new_array;
    }
 
    /* Count the number of files matching the pattern */
    int file_count = 0;
    do
    {
        if (!(find_file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
            ++file_count;
        }
    } while (FindNextFile(find_handle, &find_file_data) != 0);
 
    size_t mul;
 
    if (FOUNDATIONAL_LIB_UNLIKELY(file_count == 0))
    {
        mul = FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE;
    }
    else if (FOUNDATIONAL_LIB_UNLIKELY(FOUNDATIONAL_LIB_safe_mul_ptr(file_count, sizeof(char *), &mul) == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Allocate memory for the array of strings */
    char **files_array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(mul);
    if (FOUNDATIONAL_LIB_UNLIKELY(files_array == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Populate the array with file names matching the pattern */
    int index = 0;
    if (FOUNDATIONAL_LIB_UNLIKELY(FindClose(find_handle) == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
    find_handle = FindFirstFile(search_path, &find_file_data);
    do
    {
        if (!(find_file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
            files_array[index] = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(find_file_data.cFileName);
            if (FOUNDATIONAL_LIB_UNLIKELY(files_array[index] == NULL))
            {
                return NULL;
            }
            ++index;
        }
    } while (FindNextFile(find_handle, &find_file_data) != 0);
 
    /* Close the find handle */
    if (FOUNDATIONAL_LIB_UNLIKELY(FindClose(find_handle) == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    *len = index;
 
    return files_array;
}
 
#else
 
#include <dirent.h>
#include <fnmatch.h>
 
FOUNDATIONAL_LIB_FUNC char **list_files_with_pattern(const char *directory, const char *pattern, size_t *len)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(directory);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(pattern);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(len);
 
    *len = 0;
    DIR *dir = opendir(directory);
    if (FOUNDATIONAL_LIB_UNLIKELY(dir == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Count the number of files matching the pattern */
    int file_count = 0;
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL)
    {
        if (fnmatch(pattern, entry->d_name, FNM_PERIOD) == 0)
        {
            ++file_count;
        }
    }
 
    rewinddir(dir); // No errors with this function
 
    size_t mul;
 
    if (FOUNDATIONAL_LIB_UNLIKELY(file_count == 0))
    {
        mul = FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE;
    }
    else if (FOUNDATIONAL_LIB_UNLIKELY(FOUNDATIONAL_LIB_safe_mul_ptr(file_count, sizeof(char *), &mul) == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Allocate memory for the array of strings */
    char **files_array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(mul);
 
    /* Populate the array with file names matching the pattern */
    size_t index = 0;
    while ((entry = readdir(dir)) != NULL)
    {
        if (fnmatch(pattern, entry->d_name, FNM_PERIOD) == 0)
        {
            files_array[index] = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(entry->d_name);
            if (FOUNDATIONAL_LIB_UNLIKELY(files_array[index] == NULL))
            {
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return NULL;
            }
            ++index;
        }
    }
    if (FOUNDATIONAL_LIB_UNLIKELY(closedir(dir) == -1))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    *len = index;
 
    return files_array;
}
 
#endif
 
FOUNDATIONAL_LIB_FUNC char *concatenate_string_array(const char **strings, size_t num_strings)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(strings);
 
    /* Initialize total length and allocate initial memory for result */
    size_t alloc_size = FOUNDATIONAL_LIB_INITIAL_STRING_ARRAY_ALLOC_SIZE;
    char *result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size);
 
    // Check for initial memory allocation failure
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
        goto memory_error;
 
    size_t new_len;
 
    // If no strings, new_len will still be 0, and then a null terminator will be put at byte 0.
    new_len = 0;
 
    // Concatenate the strings char by char using FOUNDATIONAL_LIB_MEMCPY and FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC
    for (size_t i = 0; i < num_strings; ++i)
    {
        const char *current_string = strings[i];
 
        // Iterate through each character and append to the result
        size_t current_length_of_current_string = 0;
        while (current_string[current_length_of_current_string] != '\0')
        {
            if (FOUNDATIONAL_LIB_UNLIKELY(new_len == SIZE_MAX))
                goto overflow;
            /* FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM returns always at least one more */
            const size_t new_size = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(new_len + sizeof("")); /* Safe. */
 
            if (FOUNDATIONAL_LIB_UNLIKELY(new_size == 0))
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
                goto memory_error;
            }
            // Resize the result string if necessary
            if (FOUNDATIONAL_LIB_UNLIKELY(new_size > alloc_size))
            {
                char *new_result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(result, new_size);
 
                // Check for realloc failure
                if (FOUNDATIONAL_LIB_UNLIKELY(new_result == NULL))
                {
                    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
                    goto memory_error;
                }
 
                result = new_result;
            }
 
            // Append the current character to the result
            result[new_len++] = current_string[current_length_of_current_string++];
        }
    }
 
    // Add the null terminator
    result[new_len] = '\0';
 
    return result;
 
overflow:
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return NULL;
}
 
FOUNDATIONAL_LIB_FUNC char *concatenate_strings(const char *str1, const char *str2)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str1);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str2);
 
    const char *strs[2] = {str1, str2};
 
    return concatenate_string_array(strs, 2);
}
 
FOUNDATIONAL_LIB_FUNC int replace_memory(void *source, size_t source_len, void *find, size_t find_len, void *replace, size_t replace_len, void **output, size_t *output_length_without_nullt, int *should_free_after_use, size_t matches_max /* 0 for unlimited replacement */, size_t *num_matches_found, int should_nullt)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(source);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(find);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(replace);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(output);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(output_length_without_nullt);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(should_free_after_use);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(num_matches_found);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(find_len == 0))
        goto no_matches;
 
    size_t matches;
 
    matches = 0;
 
    // Count the occurrences of 'find' in 'source'
    const char *p;
 
    p = (const char *)source;
 
    const char *end_of_memory;
    end_of_memory = (const char *)source + source_len;
 
    for (;;)
    {
        if ((p = (const char *)memory_locate((const void *)p, (end_of_memory - p), find, find_len)) == NULL)
            break;
        if (matches_max && matches == matches_max)
            break;
 
        ++matches;
        p += find_len;
        puts("FOR");
    }
 
    // Let's assume that it's 'likely' to find a match.
    if (FOUNDATIONAL_LIB_UNLIKELY(matches == 0))
    {
    no_matches:
        *should_free_after_use = 0;
        *output_length_without_nullt = source_len;
        *output = source;
        return 0;
    }
 
    *should_free_after_use = 1;
    *num_matches_found = matches;
 
    size_t final_len = source_len - matches * find_len + matches * replace_len; // Overflow should not be an issue here.
 
    if (should_nullt)
    {
        ++final_len;
    }
 
    // Allocate memory for the replaced string
    char *result;
 
    result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(final_len);
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        goto memory_error;
    }
    *output_length_without_nullt = final_len;
 
    *output = result;
 
    // Perform the replacement
    char *rp;
 
    rp = result;
 
    p = (const char *)source;
 
    matches = 0;
 
    // If matches is 0, this is not run.
    for (matches = 0; !matches_max || (matches < matches_max); ++matches)
    {
        if ((p = (const char *)memory_locate((const void *)p, end_of_memory - p, find, find_len)) == NULL)
            break;
 
        if (matches_max && matches == matches_max)
            break;
 
        size_t prefix_len = p - (const char *)source;
        FOUNDATIONAL_LIB_MEMCPY(rp, source, prefix_len);
        rp += prefix_len;
        FOUNDATIONAL_LIB_MEMCPY(rp, replace, replace_len);
        rp += replace_len;
        p += find_len;
        source = (void *)p;
    }
 
    // Copy the remaining part of the source string
    size_t remaining_len;
 
    remaining_len = end_of_memory - (const char *)source;
    FOUNDATIONAL_LIB_MEMCPY(rp, source, remaining_len);
 
    if (should_nullt)
    {
        rp[remaining_len] = '\0';
    }
 
    return 0;
 
memory_error:
    *output = NULL;
    *output_length_without_nullt = 0;
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC int replace_all_with_lens(const char *source, size_t source_len, const char *find, size_t find_len, const char *replace, size_t replace_len, char **output, size_t *new_len, int *should_free_after_use, size_t matches_max, size_t *num_matches)
{
    /* replace_memory checks args if enabled. */
    return replace_memory((void *)source, source_len, (void *)find, find_len, (void *)replace, replace_len, (void **)output, new_len, should_free_after_use, matches_max, num_matches, 1);
}
 
FOUNDATIONAL_LIB_FUNC char *replace_all(const char *source, const char *find, const char *replace)
{
    /* replace_memory checks args if enabled. */
 
    size_t new_len;
    char *output;
    int should_free_after_use;
    size_t num_matches;
    const size_t matches_max = 0;
 
    if (replace_memory((void *)source, strlen(source), (void *)find, strlen(find), (void *)replace, strlen(replace), (void **)&output, &new_len, &should_free_after_use, matches_max, &num_matches, 1) == -1)
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    if (!should_free_after_use)
    {
        if (FOUNDATIONAL_LIB_UNLIKELY(new_len == SIZE_MAX))
        {
            FOUNDATIONAL_LIB_die_aggressively_if_enabled();
            return NULL;
        }
 
        char *new_output = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(new_len + 1); /* Safe. */
        memcpy(new_output, output, new_len + 1);                                          /* It was already null terminated */
        return new_output;
    }
 
    return output;
}
 
FOUNDATIONAL_LIB_FUNC char *replace_first(const char *source, const char *find, const char *replace)
{
    /* replace_memory checks args if enabled. */
 
    size_t new_len;
    char *output;
    int should_free_after_use;
    size_t num_matches;
    const size_t matches_max = 1;
 
    if (replace_memory((void *)source, strlen(source), (void *)find, strlen(find), (void *)replace, strlen(replace), (void **)&output, &new_len, &should_free_after_use, matches_max, &num_matches, 1) == -1)
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    if (!should_free_after_use)
    {
        if (FOUNDATIONAL_LIB_UNLIKELY(new_len == SIZE_MAX))
        {
            FOUNDATIONAL_LIB_die_aggressively_if_enabled();
            return NULL;
        }
 
        char *new_output = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(new_len + 1); /* Safe. */
        memcpy(new_output, output, new_len + 1);                                          /* It was already null terminated */
        return new_output;
    }
 
    return output;
}
 
FOUNDATIONAL_LIB_FUNC char *replace_count(const char *source, const char *find, const char *replace, const size_t matches_max)
{
    /* replace_memory checks args if enabled. */
 
    size_t new_len;
    char *output;
    int should_free_after_use;
    size_t num_matches;
    if (replace_memory((void *)source, strlen(source), (void *)find, strlen(find), (void *)replace, strlen(replace), (void **)&output, &new_len, &should_free_after_use, matches_max, &num_matches, 1) == -1)
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    if (!should_free_after_use)
    {
        if (FOUNDATIONAL_LIB_UNLIKELY(new_len == SIZE_MAX))
        {
            FOUNDATIONAL_LIB_die_aggressively_if_enabled();
            return NULL;
        }
 
        char *new_output = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(new_len + 1); /* Safe. */
        memcpy(new_output, output, new_len + 1);                                          /* It was already null terminated */
        return new_output;
    }
 
    return output;
}
 
FOUNDATIONAL_LIB_FUNC char *replace_all_with_callback(const char *str, const char *old_substring, char *(*callback)(const char *, void *), void *data_for_callback)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(old_substring);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(callback);
 
    const size_t str_len = strlen(str);
    const size_t old_substring_len = strlen(old_substring);
    size_t alloc_size = str_len + 1; // Start with the original string length + 1 for the null terminator
 
    // Allocate memory for the result string
    char *result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(str_len);
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    // Copy and replace substrings
    const char *pos = str;
 
    size_t new_len = 0;
 
    for (;;)
    {
        const char *found_pos = (const char *)memory_locate(pos, str_len - (pos - str), old_substring, old_substring_len);
        if (FOUNDATIONAL_LIB_UNLIKELY(found_pos == NULL))
        {
            size_t remaining_len = str_len - (pos - str);
            memcpy(result + new_len, pos, remaining_len);
            new_len += remaining_len;
 
            result[new_len] = '\0';
 
            new_len += remaining_len;
            break;
        }
 
        // Copy the segment
 
        char *replacement = callback(old_substring, data_for_callback);
 
        // Resize the result buffer if needed
        size_t replacement_len = strlen(replacement);
 
        size_t nlen;
 
        const size_t diff = found_pos - pos;
 
        if (FOUNDATIONAL_LIB_UNLIKELY(FOUNDATIONAL_LIB_safe_add_3_ptr(new_len, diff, replacement_len, &nlen) == 0))
        {
            goto overflow;
        }
 
        if (FOUNDATIONAL_LIB_UNLIKELY(nlen == SIZE_MAX))
            goto overflow;
 
        ++nlen;
 
        if (nlen >= alloc_size)
        {
            /* Makes it at least 1 bigger. */
            alloc_size = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(nlen);
            char *new_result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(result, alloc_size);
            if (FOUNDATIONAL_LIB_UNLIKELY(new_result == NULL))
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(replacement);
                goto error;
            }
            result = new_result;
        }
 
        memcpy(result + new_len, pos, found_pos - pos); /* Safe. */
        new_len += found_pos - pos;
        memcpy(result + new_len, replacement, replacement_len);
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(replacement);
        new_len += replacement_len;
        pos = found_pos + old_substring_len;
    }
 
    return result;
overflow:
 
error:
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return NULL;
}
 
FOUNDATIONAL_LIB_FUNC char *dup_format(const char *format, ...)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(format);
 
    FOUNDATIONAL_LIB_VA_LIST args;
    FOUNDATIONAL_LIB_VA_START(args, format);
 
    /* Determine the length of the formatted string */
    const int len = FOUNDATIONAL_LIB_VSNPRINTF(NULL, 0, format, args);
 
    FOUNDATIONAL_LIB_VA_END(args);
 
    if (len == -1)
        goto memory_error;
 
    /* Would-be Overflow */
    if (FOUNDATIONAL_LIB_UNLIKELY(sizeof(int) >= sizeof(size_t) && (size_t)len == SIZE_MAX))
        goto memory_error;
 
    /* Allocate memory for the formatted string */
    char *result;
 
    result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(len + sizeof("")); /* Safe */
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
        goto memory_error;
 
    FOUNDATIONAL_LIB_VA_START(args, format);
    if (FOUNDATIONAL_LIB_VSNPRINTF(result, len + 1, format, args) == -1)
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
        FOUNDATIONAL_LIB_VA_END(args);
        goto memory_error;
    }
 
    FOUNDATIONAL_LIB_VA_END(args);
 
    return result;
 
memory_error:
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return NULL;
}
FOUNDATIONAL_LIB_FUNC void map_ints(int *array, size_t size, int (*transform)(int))
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(transform);
 
    for (size_t i = 0; i < size; i++)
    {
        array[i] = transform(array[i]);
    }
}
 
FOUNDATIONAL_LIB_FUNC int reduce_ints(int *array, size_t size, int (*operation)(int, int))
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(operation);
 
    int result = array[0];
    for (size_t i = 1; i < size; i++)
    {
        result = operation(result, array[i]);
    }
    return result;
}
 
FOUNDATIONAL_LIB_FUNC int filter_ints(int *source, size_t source_size, int *destination, int (*condition)(int))
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(source);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(destination);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(condition);
 
    size_t count = 0;
    for (size_t i = 0; i < source_size; i++)
    {
        if (condition(source[i]))
        {
            destination[count++] = source[i];
        }
    }
    return count;
}
 
FOUNDATIONAL_LIB_FUNC void map(void *array, size_t size, size_t elem_size, void (*transform)(void *))
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(transform);
 
    for (size_t i = 0; i < size; i++)
    {
        transform(((char *)array) + i * elem_size);
    }
}
 
FOUNDATIONAL_LIB_FUNC void reduce(void *array, size_t size, size_t elem_size, void *result, void (*operation)(void *, void *))
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(result);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(operation);
 
    char *char_array = (char *)array;
    char *char_result = (char *)result;
 
    /* Initialize the result with the first element */
    for (size_t i = 0; i < elem_size; i++)
    {
        char_result[i] = char_array[i];
    }
 
    for (size_t i = 1; i < size; i++)
    {
        operation(char_result, char_array + i * elem_size);
    }
}
 
FOUNDATIONAL_LIB_FUNC size_t filter(void *source, size_t source_size, size_t elem_size, void *destination, size_t dest_size, int (*condition)(void *))
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(source);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(destination);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(condition);
 
    char *char_source = (char *)source;
    char *char_destination = (char *)destination;
 
    size_t count = 0;
    for (size_t i = 0; i < source_size; i++)
    {
        if (condition(char_source + i * elem_size))
        {
            if (count < dest_size)
            {
                for (size_t j = 0; j < elem_size; j++)
                {
                    char_destination[count * elem_size + j] = char_source[i * elem_size + j];
                }
            }
            count++;
        }
    }
    return count;
}
 
FOUNDATIONAL_LIB_FUNC void *list_comprehension(const void *input_array, size_t array_size, size_t elem_size, void (*transform_func)(void *value), int (*filter_func)(void *value), size_t *result_size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(input_array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(transform_func);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filter_func);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(result_size);
 
    // Set result size to 0 first thing.
    *result_size = 0;
 
    const size_t alloc_size = FOUNDATIONAL_LIB_safe_mul(array_size, elem_size);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size == 0))
    {
        /* Handle overflow error. */
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Allocate memory for the result array */
    void *result = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        /* Handle memory allocation error */
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Iterate through the input array */
    for (size_t i = 0; i < array_size; ++i)
    {
        /* Apply the filter function */
 
        // Assume that there cannot be an overflow error
        // because iterating through a size_t array from 0.
        if (filter_func((void *)((char *)input_array + i * elem_size)))
        {
            /* Apply the transformation function */
 
            void *addr = (char *)result + (*result_size) * elem_size;
            FOUNDATIONAL_LIB_MEMCPY(addr, (char *)input_array + (i * elem_size), elem_size); /* Safe. */
            transform_func(addr);
            ++(*result_size);
        }
    }
 
    // We need this so that gcc with -std=c11 under mingw32 doesn't give a
    // warning about memory possibly being accessed after freeing()
    // This only seems to happen with mingw32, and is a bug in it.
    // I included a relevant ISO/IEC statement about realloc in this file.
    //
    // This code has no bug.
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wuse-after-free"
 
    /*
     * Make the result smaller to free a bit of memory. Not necessary, but it saves memory.
     * array_size * (*result_size) will not be larger than the current size.
     *
     * Dont do safe mul here because this should be smaller than current amounts.
     */
    char *new_result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(result, array_size * (*result_size)); /* Safe. */
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_result == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return result;
    }
 
#pragma GCC diagnostic pop
 
    /*
    ISO/IEC 9899:2011:
 
    "If memory for the new object cannot be allocated,
    the old object is not deallocated and its value is unchanged."
    */
 
    return new_result;
}
 
/* For Set */
struct SetKey
{
    char *key;
    struct SetKey *next;
};
 
struct Dict
{
    struct DictKeyValue **table;
    size_t capacity;
    size_t size;
};
 
struct Set
{
    struct SetKey **table;
    size_t capacity;
    size_t size;
};
 
struct DictKeyValue
{
    char *key;
    void *value;
    struct DictKeyValue *next;
};
/* FrozenDict struct */
struct FrozenDict
{
    struct DictKeyValue **table;
    size_t capacity;
    size_t size;
};
 
/* FrozenSet struct. */
struct FrozenSet
{
    struct SetKey **table;
    size_t capacity;
    size_t size;
};
 
/* Sets */
typedef struct FrozenSet FrozenSet;
typedef struct Set Set;
 
/* Dicts */
typedef struct Dict Dict;
typedef struct FrozenDict FrozenDict;
 
#if FOUNDATIONAL_LIB_THREAD_FUNCTIONS_ENABLED
#include <threads.h>
 
// Define a structure to hold thread-specific data
struct ThreadData
{
    const void *input_array;
    size_t array_size;
    size_t elem_size;
    void (*transform_func)(void *value);
    int (*filter_func)(void *value);
    size_t *result_size;
    void *result;
    size_t start_index;
    size_t end_index;
};
 
/*
 * Define the worker function for each thread, as used by
 * list_comprehension_multithreaded()
 */
FOUNDATIONAL_LIB_FUNC int FOUNDATIONAL_LIB_list_comprehension_worker(void *data)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(data);
    struct ThreadData *thread_data = (struct ThreadData *)data;
    *thread_data->result_size = 0;
 
    const size_t subtraction = (thread_data->end_index - thread_data->start_index);
 
    const size_t mul = FOUNDATIONAL_LIB_safe_mul(thread_data->elem_size, subtraction);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(mul == 0)) // Overflow
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    void *buffer = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(mul);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(buffer == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    // Iterate through the assigned chunk of the input array
 
    // Start index and end index should be valid indices and no possiblity
    // for overflow error.
    for (size_t i = thread_data->start_index; i < thread_data->end_index; ++i)
    {
        // Apply the filter function
        if (thread_data->filter_func((void *)((char *)thread_data->input_array + i * thread_data->elem_size)))
        {
            // Copy the value to the result array
            FOUNDATIONAL_LIB_MEMCPY((char *)buffer + (*thread_data->result_size) * thread_data->elem_size, (char *)thread_data->input_array + i * thread_data->elem_size, thread_data->elem_size); /* Safe. */
 
            ++(*thread_data->result_size);
        }
    }
 
    // Apply the transformation function to the entire result chunk
    for (size_t i = 0; i < (*thread_data->result_size); ++i)
    {
        thread_data->transform_func((void *)((char *)buffer + i * thread_data->elem_size));
    }
 
    thread_data->result = buffer;
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC void *list_comprehension_multithreaded(const void *input_array, size_t array_size, size_t elem_size, void (*transform_func)(void *value), int (*filter_func)(void *value), size_t *result_size, size_t thread_count)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(input_array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(transform_func);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filter_func);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(result_size);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(thread_count == 0))
    {
        // This doesn't make sense, so assume they mean 1.
        thread_count = 1;
    }
 
    // Set result size to 0 first thing.
    *result_size = 0;
 
    const size_t alloc_size_for_result = FOUNDATIONAL_LIB_safe_mul(array_size, elem_size);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size_for_result == 0))
    {
        /* Handle overflow error. */
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Allocate memory for the result array */
    void *result = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size_for_result);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        /* Handle memory allocation error */
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Allocate memory for result sizes */
 
    const size_t alloc_size_for_thread_result_sizes = FOUNDATIONAL_LIB_safe_mul(thread_count, sizeof(size_t));
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size_for_thread_result_sizes == 0))
    {
        /* Handle overflow error. */
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    size_t *thread_result_sizes = (size_t *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size_for_thread_result_sizes);
    if (FOUNDATIONAL_LIB_UNLIKELY(thread_result_sizes == NULL))
    {
        // Handle memory allocation error
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    const size_t alloc_size_for_threads = FOUNDATIONAL_LIB_safe_mul(thread_count, sizeof(thrd_t));
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size_for_threads == 0))
    {
        /* Handle overflow error. */
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(thread_result_sizes);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    // Initialize thread data
    thrd_t *threads = (thrd_t *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size_for_threads);
    if (FOUNDATIONAL_LIB_UNLIKELY(threads == NULL))
    {
        // Handle memory allocation error
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(thread_result_sizes);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
    const size_t alloc_size_for_thread_data = FOUNDATIONAL_LIB_safe_mul(thread_count, sizeof(struct ThreadData));
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size_for_thread_data == 0))
    {
        /* Handle overflow error. */
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(thread_result_sizes);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
    struct ThreadData *thread_data = (struct ThreadData *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size_for_thread_data);
    if (FOUNDATIONAL_LIB_UNLIKELY(thread_data == NULL))
    {
    cannot_allocate_or_create:
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(result);
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(thread_result_sizes);
 
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(threads);
 
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    // Divide the input array into chunks for each thread
    size_t chunk_size = array_size / thread_count;
    size_t remaining = array_size % thread_count;
    size_t current_index = 0;
 
    for (size_t i = 0; i < thread_count; ++i)
    {
        size_t e_index;
        const size_t ret = FOUNDATIONAL_LIB_safe_add_3_ptr(current_index, chunk_size, (remaining > 0 ? 1 : 0), &e_index);
 
        if (FOUNDATIONAL_LIB_UNLIKELY(ret == 0))
            goto cannot_allocate_or_create; // Overflow
 
        thread_data[i].input_array = input_array;
        thread_data[i].array_size = array_size;
        thread_data[i].elem_size = elem_size;
        thread_data[i].transform_func = transform_func;
        thread_data[i].filter_func = filter_func;
        thread_data[i].result_size = &thread_result_sizes[i];
        thread_data[i].result = result;
        thread_data[i].start_index = current_index;
        thread_data[i].end_index = e_index;
 
        if (remaining > 0)
        {
            --remaining;
        }
 
        current_index = thread_data[i].end_index;
 
        // Create a thread for each chunk
        if (FOUNDATIONAL_LIB_UNLIKELY(thrd_create(&threads[i], FOUNDATIONAL_LIB_list_comprehension_worker, (void *)&thread_data[i]) != thrd_success))
            goto cannot_allocate_or_create;
    }
 
    // Wait for all threads to finish
    for (size_t i = 0; i < thread_count; ++i)
    {
        int return_value_of_thread;
        thrd_join(threads[i], &return_value_of_thread);
 
        // The thread failed.
        if (FOUNDATIONAL_LIB_UNLIKELY(return_value_of_thread == -1))
            goto cannot_allocate_or_create;
    }
    // Calculate the total result size
    size_t total_result_size = 0;
    for (size_t i = 0; i < thread_count; ++i)
    {
        FOUNDATIONAL_LIB_MEMCPY((char *)result + total_result_size * elem_size, thread_data[i].result, thread_result_sizes[i] * elem_size); /* Safe. */
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(thread_data[i].result);
 
        // Should always be <= SIZE_MAX
        total_result_size += thread_result_sizes[i];
    }
 
    // Update the final result size
    *result_size = total_result_size;
 
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(thread_result_sizes);
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(thread_data);
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(threads);
 
    return result;
}
 
#endif
 
FOUNDATIONAL_LIB_FUNC void *reject_array(const void *source, size_t source_size, size_t elem_size, int (*condition)(const void *), size_t *result_size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(source);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(condition);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(result_size);
    *result_size = 0;
    /* Allocate memory for the result array */
 
    const size_t mul = FOUNDATIONAL_LIB_safe_mul(source_size, elem_size);
    if (FOUNDATIONAL_LIB_UNLIKELY(mul == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    void *result = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(mul);
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    size_t result_index = 0;
 
    /* Apply the rejection condition to each element */
    for (size_t i = 0; i < source_size; ++i)
    {
        // Should be a valid index if passed a valid argument.
        const void *current_source = (char *)source + i * elem_size;
 
        /* Check condition */
        if (!condition(current_source))
        {
            void *current_result = (char *)result + result_index * elem_size;
            FOUNDATIONAL_LIB_MEMCPY(current_result, current_source, elem_size);
            result_index++;
        }
    }
 
    /* Set the result size */
    *result_size = result_index;
 
    return result;
}
 
FOUNDATIONAL_LIB_FUNC void *select_array(const void *source, size_t source_size, size_t elem_size, int (*condition)(const void *), size_t *result_size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(source);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(condition);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(result_size);
 
    *result_size = 0;
    /* Allocate memory for the result array */
 
    const size_t mul = FOUNDATIONAL_LIB_safe_mul(source_size, elem_size);
    if (FOUNDATIONAL_LIB_UNLIKELY(mul == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    void *result = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(mul);
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    size_t result_index = 0;
 
    /* Apply the selection condition to each element */
    for (size_t i = 0; i < source_size; ++i)
    {
        const void *current_source = (char *)source + i * elem_size;
 
        /* Check condition */
        if (condition(current_source))
        {
            void *current_result = (char *)result + result_index * elem_size;
            FOUNDATIONAL_LIB_MEMCPY(current_result, current_source, elem_size);
            ++result_index;
        }
    }
 
    /* Set the result size */
    *result_size = result_index;
 
    return result;
}
 
FOUNDATIONAL_LIB_FUNC void *replicate(const void *source, size_t source_size, size_t elem_size, size_t repetitions)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(source);
 
    /* elem_size * source_size * repetitions */
 
    const size_t elem_times_source = FOUNDATIONAL_LIB_safe_mul(elem_size, source_size);
    if (FOUNDATIONAL_LIB_UNLIKELY(elem_times_source == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    const size_t result_total_size = FOUNDATIONAL_LIB_safe_mul(elem_times_source, repetitions);
    if (FOUNDATIONAL_LIB_UNLIKELY(result_total_size == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Allocate memory for the result array */
    void *result = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(result_total_size);
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    /* Copy the source array to the result array multiple times */
    for (size_t i = 0; i < repetitions; ++i)
    {
        // Counting from zero so it should not be an overflow.
        FOUNDATIONAL_LIB_MEMCPY((char *)result + (i * elem_times_source), source, elem_times_source); /* Safe. */
    }
 
    return result;
}
 
FOUNDATIONAL_LIB_FUNC char *string_to_lowercase(char *string)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
 
    char *new_str = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(string);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_str == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
    char *orig_str = new_str;
    while (*new_str)
    {
        *new_str = tolower(*new_str);
        ++new_str;
    }
 
    return orig_str;
}
 
FOUNDATIONAL_LIB_FUNC char *string_to_uppercase(char *string)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
    char *new_str = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(string);
    if (FOUNDATIONAL_LIB_UNLIKELY(new_str == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
    char *orig_str = new_str;
    while (*new_str)
    {
        *new_str = toupper(*new_str);
        ++new_str;
    }
 
    return orig_str;
}
 
FOUNDATIONAL_LIB_FUNC int is_string_upper(const char *string)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
    while (*string)
    {
        if (!FOUNDATIONAL_LIB_ISUPPER(*string))
        {
            return 0;
        }
        ++string;
    }
    return 1;
}
 
FOUNDATIONAL_LIB_FUNC int is_string_lower(const char *string)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
 
    while (*string)
    {
        if (!FOUNDATIONAL_LIB_ISLOWER(*string))
        {
            return 0;
        }
        ++string;
    }
    return 1;
}
 
FOUNDATIONAL_LIB_FUNC int is_string_alpha(const char *string)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
    while (*string)
    {
        if (!FOUNDATIONAL_LIB_ISALNUM(*string))
        {
            return 0;
        }
 
        ++string;
    }
    return 1;
}
 
FOUNDATIONAL_LIB_FUNC int is_string_digit(const char *string)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
    while (*string)
    {
        if (!FOUNDATIONAL_LIB_ISDIGIT(*string))
        {
            return 0;
        }
        ++string;
    }
    return 1;
}
 
FOUNDATIONAL_LIB_FUNC int is_string_space(const char *string)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
 
    while (*string)
    {
        if (!FOUNDATIONAL_LIB_ISSPACE(*string))
        {
            return 0;
        }
        ++string;
    }
    return 1;
}
FOUNDATIONAL_LIB_FUNC int is_string_printable(const char *string)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
    while (*string)
    {
        if (!FOUNDATIONAL_LIB_ISPRINT(*string))
        {
            return 0;
        }
        ++string;
    }
    return 1;
}
 
FOUNDATIONAL_LIB_FUNC int is_array_digit(const char **array, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    for (size_t i = 0; i < size; ++i)
    {
        const char *str = array[i];
        while (*str)
        {
            if (!FOUNDATIONAL_LIB_ISDIGIT(*str))
            {
                return 0;
            }
            ++str;
        }
    }
    return 1;
}
FOUNDATIONAL_LIB_FUNC int is_array_upper(const char **array, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    for (size_t i = 0; i < size; ++i)
    {
        const char *str = array[i];
        while (*str)
        {
            if (!FOUNDATIONAL_LIB_ISUPPER(*str))
            {
                return 0;
            }
            ++str;
        }
    }
    return 1;
}
 
FOUNDATIONAL_LIB_FUNC int is_array_lower(const char **array, size_t size)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
    for (size_t i = 0; i < size; ++i)
    {
        const char *str = array[i];
        while (*str)
        {
            if (!FOUNDATIONAL_LIB_ISLOWER(*str))
            {
                return 0;
            }
            ++str;
        }
    }
    return 1;
}
 
FOUNDATIONAL_LIB_FUNC int string_array_uniq(const char **array, size_t size, char ***output, size_t *output_size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(output);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(output_size);
 
    *output_size = 0;
 
    const size_t alloc_size = FOUNDATIONAL_LIB_safe_mul(size, sizeof(char *));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    // Count the number of unique strings
    size_t count = 0;
 
    // Allocate memory for the array to store unique strings
    *output = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size);
    if (FOUNDATIONAL_LIB_UNLIKELY(*output == NULL))
    {
        // Memory allocation failed
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    // Initialize all elements to NULL
    for (size_t i = 0; i < size; i++)
    {
        (*output)[i] = NULL;
    }
 
    // Iterate through the input array to find unique strings
    for (size_t i = 0; i < size; i++)
    {
        int is_unique = 1;
 
        // Check if the current string is not equal to any previous strings
        for (size_t j = 0; j < count; j++)
        {
            if ((*output)[j] != NULL && FOUNDATIONAL_LIB_STRCMP(array[i], (*output)[j]) == 0)
            {
                is_unique = 0; // Not unique
                break;
            }
        }
 
        if (is_unique)
        {
            (*output)[count] = ((char **)array)[i]; // No strdup used.
 
            ++count;
        }
    }
 
    // Set the output size
    *output_size = count;
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC int string_array_uniq_adjacent(const char **first_array, size_t size, char ***new_array, size_t *new_size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(first_array);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(new_array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(new_size);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(first_array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(new_array);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(new_size);
 
    *new_size = 0;
    const size_t alloc_size = FOUNDATIONAL_LIB_safe_mul(size, sizeof(char *));
 
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    // Create a new dynamically allocated array
    *new_array = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size);
    if (FOUNDATIONAL_LIB_UNLIKELY(*new_array == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    // Remove adjacent duplicates from arr1 and copy to arr2
    for (size_t i = 0; i < size; ++i)
    {
        if (i == 0 || FOUNDATIONAL_LIB_STRCMP(first_array[i], first_array[i - 1]) != 0)
        {
            (*new_array)[(*new_size)++] = (char *)first_array[i]; // No strdup
        }
    }
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC char *concatenate_three_strings(const char *str1, const char *str2, const char *str3)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str1);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str2);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str3);
 
    const char *strs[3] = {str1, str2, str3};
 
    return concatenate_string_array(strs, 3);
}
 
FOUNDATIONAL_LIB_FUNC char *concatenate_four_strings(const char *str1, const char *str2, const char *str3, const char *str4)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str1);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str2);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str3);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str4);
 
    const char *strs[4] = {str1, str2, str3, str4};
 
    return concatenate_string_array(strs, 4);
}
 
FOUNDATIONAL_LIB_FUNC char *concatenate_five_strings(const char *str1, const char *str2, const char *str3, const char *str4, const char *str5)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str1);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str2);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str3);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str4);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str5);
 
    const char *strs[5] = {str1, str2, str3, str4, str5};
 
    return concatenate_string_array(strs, 5);
}
 
#ifdef _WIN32
#include <tchar.h>
#include <windows.h>
#else
#include <dirent.h>
#endif
 
#ifdef _WIN32
#define FOUNDATIONAL_LIB_DIR_SEPARATOR '\\'
#else
#define FOUNDATIONAL_LIB_DIR_SEPARATOR '/'
#endif
 
FOUNDATIONAL_LIB_FUNC int map_filesystem_files_as_strings(const char *directory, char *(*map_function)(const char *file_string_data, size_t string_size))
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(directory);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(map_function);
 
#ifdef _WIN32
    WIN32_FIND_DATA findFileData;
    HANDLE hFind = FindFirstFile(directory, &findFileData);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(hFind == INVALID_HANDLE_VALUE))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    do
    {
        if (!(findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        {
            // Regular file
            char *file_data;
            size_t size;
 
            // Get the regular file.
            char fullFilePath[MAX_PATH];
            _stprintf(fullFilePath, _T("%s%c%s"), directory, FOUNDATIONAL_LIB_DIR_SEPARATOR, findFileData.cFileName);
 
            file_data = read_file_into_string(fullFilePath, &size);
            if (FOUNDATIONAL_LIB_UNLIKELY(file_data == NULL))
            {
                // No need to re-die aggressively.
                FindClose(hFind); /* No need to error check here because there already is an error. */
                return -1;
            }
 
            // The result of the map operation
            const char *new_str = map_function(file_data, size);
 
            // Write the result to disk
            if (FOUNDATIONAL_LIB_UNLIKELY(write_file(fullFilePath, new_str) == -1))
            {
                // No need to re-die aggressively.
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(file_data);
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE((char *)new_str);
                FindClose(hFind); // No need to error check here because there already is an error.
                return -1;
            }
 
            // Free memory.
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(file_data);
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE((char *)new_str);
        }
 
    } while (FindNextFile(hFind, &findFileData) != 0);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(FindClose(hFind) == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
#else
    DIR *dir = opendir(directory);
    if (FOUNDATIONAL_LIB_UNLIKELY(dir == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL)
    {
        if (entry->d_type == DT_REG)
        { // Regular file
            char *file_data;
            size_t size;
 
            // Get the regular file.
            char fullFilePath[PATH_MAX];
            FOUNDATIONAL_LIB_SNPRINTF(fullFilePath, PATH_MAX, "%s%c%s", directory, FOUNDATIONAL_LIB_DIR_SEPARATOR, entry->d_name);
 
            file_data = read_file_into_string(fullFilePath, &size);
            if (FOUNDATIONAL_LIB_UNLIKELY(file_data == NULL))
            {
                // No need to re-die aggressively.
                return -1;
            }
 
            // The result of the map operation
            const char *new_str = map_function(file_data, size);
 
            // Write the result to disk
            if (write_file(fullFilePath, new_str) == -1)
            {
                // No need to re-die aggressively.
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(file_data);
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE((char *)new_str);
                return -1;
            }
 
            // Free memory.
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(file_data);
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE((char *)new_str);
        }
    }
 
    if (FOUNDATIONAL_LIB_UNLIKELY(closedir(dir) == -1))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
#endif
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC int filter_filesystem_files_as_strings(const char *directory, int (*filter_function)(const char *filename))
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(directory);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filter_function);
#ifdef _WIN32
    WIN32_FIND_DATA findFileData;
    HANDLE hFind = FindFirstFile(directory, &findFileData);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(hFind == INVALID_HANDLE_VALUE))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    do
    {
        if (!(findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && !filter_function(findFileData.cFileName))
        {
            // Regular file to be removed
            char fullFilePath[MAX_PATH];
            _stprintf(fullFilePath, _T("%s%c%s"), directory, FOUNDATIONAL_LIB_DIR_SEPARATOR, findFileData.cFileName);
 
            if (remove_file(fullFilePath) == -1)
            {
                // Handle error or return -1
                if (FindClose(hFind) == 0)
                {
                    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                    return -1;
                }
                return -1;
            }
        }
 
    } while (FindNextFile(hFind, &findFileData) != 0);
 
    FindClose(hFind);
 
#else
    DIR *dir = opendir(directory);
    if (FOUNDATIONAL_LIB_UNLIKELY(dir == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL)
    {
        if (entry->d_type == DT_REG)
        {
            if (!filter_function(entry->d_name))
            {
                // Regular file to be removed
                char fullFilePath[PATH_MAX];
                FOUNDATIONAL_LIB_SNPRINTF(fullFilePath, PATH_MAX, "%s%c%s", directory, FOUNDATIONAL_LIB_DIR_SEPARATOR, entry->d_name);
 
                if (remove_file(fullFilePath) == -1)
                {
                    // Handle error or return -1
                    if (closedir(dir) == -1)
                    {
                        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                        return -1;
                    }
                    return -1;
                }
            }
        }
    }
 
    if (FOUNDATIONAL_LIB_UNLIKELY(closedir(dir) == -1))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
#endif
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC char *reduce_filesystem_files_as_strings(const char *directory, const char *out_file, char *(*reduce_function)(char *value1, ...))
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(directory);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(out_file);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(reduce_function);
#ifdef _WIN32
    WIN32_FIND_DATA findFileData;
    HANDLE hFind = FindFirstFile(directory, &findFileData);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(hFind == INVALID_HANDLE_VALUE))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    char *last_value = NULL;
    char *value = NULL;
 
    do
    {
        if (!(findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && findFileData.dwFileAttributes & FILE_ATTRIBUTE_NORMAL)
        {
            // Regular file
            size_t size;
 
            // Get the regular file.
            char fullFilePath[MAX_PATH];
            _stprintf(fullFilePath, _T("%s%c%s"), directory, FOUNDATIONAL_LIB_DIR_SEPARATOR, findFileData.cFileName);
 
            value = read_file_into_string(fullFilePath, &size);
            if (FOUNDATIONAL_LIB_UNLIKELY(value == NULL))
            {
                // No need to re-die aggressively.
                FindClose(hFind); /* Don't need to care about the return value because there already is an error. */
                return NULL;
            }
 
            char *new_value = reduce_function(last_value, value, findFileData.cFileName);
            if (last_value)
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(last_value);
            }
 
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(value);
            last_value = new_value;
 
            if (FOUNDATIONAL_LIB_UNLIKELY(remove_file(fullFilePath) == -1))
            {
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return NULL;
            }
        }
 
    } while (FindNextFile(hFind, &findFileData) != 0);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(FindClose(hFind) == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
#else
    DIR *dir = opendir(directory);
    if (FOUNDATIONAL_LIB_UNLIKELY(dir == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    char *last_value = NULL;
    char *value = NULL;
    struct dirent *entry;
 
    while ((entry = readdir(dir)) != NULL)
    {
        if (entry->d_type == DT_REG)
        {
            // Regular file
            size_t size;
 
            // Get the regular file.
            char fullFilePath[PATH_MAX];
            FOUNDATIONAL_LIB_SNPRINTF(fullFilePath, PATH_MAX, "%s%c%s", directory, FOUNDATIONAL_LIB_DIR_SEPARATOR, entry->d_name);
 
            value = read_file_into_string(fullFilePath, &size);
            if (FOUNDATIONAL_LIB_UNLIKELY(value == NULL))
            {
                // No need to re-die aggressively.
                if (FOUNDATIONAL_LIB_UNLIKELY(closedir(dir) == -1))
                {
                    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                    return NULL;
                }
                return NULL;
            }
 
            char *new_value = reduce_function(last_value, value, entry->d_name);
            if (last_value)
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(last_value);
            }
 
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(value);
            last_value = new_value;
 
            if (FOUNDATIONAL_LIB_UNLIKELY(remove_file(fullFilePath) == -1))
            {
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return NULL;
            }
        }
    }
 
    if (FOUNDATIONAL_LIB_UNLIKELY(closedir(dir) == -1))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
#endif
 
    if (FOUNDATIONAL_LIB_UNLIKELY(write_file(out_file, value) == -1))
    {
        /* No need to re-die aggressively. */
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(last_value);
        return NULL;
    }
 
    return last_value;
}
 
FOUNDATIONAL_LIB_FUNC void dict_destructor(struct Dict *dict)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
 
    for (size_t i = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current_pair = dict->table[i];
        while (current_pair != NULL)
        {
            struct DictKeyValue *next_pair = current_pair->next;
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current_pair->key);
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current_pair);
            current_pair = next_pair;
        }
    }
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(dict->table);
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(dict);
}
 
FOUNDATIONAL_LIB_FUNC size_t dict_hash(const char *key, size_t capacity)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
 
    size_t hash = 5381; // Initial hash value
    int c;              // Variable to store the current character
 
    while ((c = *key++))
    {
        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
    }
 
    return hash % capacity;
}
 
FOUNDATIONAL_LIB_FUNC int dict_reserve_more(struct Dict *dict, size_t number_of_new_elements_max_one_is_expecting)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
 
    const size_t new_capacity = FOUNDATIONAL_LIB_safe_add_2(dict->capacity, number_of_new_elements_max_one_is_expecting);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(new_capacity == 0))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    /* Either calloc or realloc would be ideal here, but, if the block is large,
       then calloc might be better because there might be a cleared block of
       memory that is very large that is readily available. */
    struct DictKeyValue **new_table = (struct DictKeyValue **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(new_capacity, sizeof(struct DictKeyValue *));
    if (FOUNDATIONAL_LIB_UNLIKELY(new_table == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    for (size_t i = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current_pair = dict->table[i];
        while (current_pair)
        {
            struct DictKeyValue *next_pair = current_pair->next;
            const size_t new_index = dict_hash(current_pair->key, new_capacity);
            current_pair->next = new_table[new_index];
            new_table[new_index] = current_pair;
            current_pair = next_pair;
        }
    }
 
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(dict->table);
    dict->table = new_table;
    dict->capacity = new_capacity;
 
    return 0;
}
FOUNDATIONAL_LIB_FUNC int dict_resize(struct Dict *dict)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
 
    const size_t new_capacity = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(dict->capacity);
    if (FOUNDATIONAL_LIB_UNLIKELY(new_capacity == 0)) // Overflow.
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    /* Either calloc or realloc would be ideal here, but, if the block is large,
       then calloc might be better because there might be a cleared block of
       memory that is very large that is readily available. */
    struct DictKeyValue **new_table = (struct DictKeyValue **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(new_capacity, sizeof(struct DictKeyValue *));
    if (FOUNDATIONAL_LIB_UNLIKELY(new_table == NULL))
    {
        dict_destructor(dict);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    for (size_t i = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current_pair = dict->table[i];
        while (current_pair)
        {
            struct DictKeyValue *next_pair = current_pair->next;
            const size_t new_index = dict_hash(current_pair->key, new_capacity);
            current_pair->next = new_table[new_index];
            new_table[new_index] = current_pair;
            current_pair = next_pair;
        }
    }
 
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(dict->table);
    dict->table = new_table;
    dict->capacity = new_capacity;
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC void dict_del_key(struct Dict *dict, const char *key)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
    const size_t index = dict_hash(key, dict->capacity);
 
    struct DictKeyValue *current = dict->table[index];
    struct DictKeyValue *prev = NULL;
 
    while (current != NULL)
    {
        if (FOUNDATIONAL_LIB_STRCMP(current->key, key) == 0)
        {
            /* Key found, remove the entry */
            if (prev == NULL)
            {
                /* If it's the first node in the linked list */
                dict->table[index] = current->next;
            }
            else
            {
                prev->next = current->next;
            }
 
            /* Free memory */
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current->key);
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current);
 
            /* Update size */
            --dict->size;
 
            return;
        }
 
        /* Move to the next node in the linked list */
        prev = current;
        current = current->next;
    }
}
 
FOUNDATIONAL_LIB_FUNC int dict_add(struct Dict *dict, const char *key, void *value)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(value);
    if ((double)dict->size / dict->capacity > FOUNDATIONAL_LIB_HASH_LOAD_FACTOR_THRESHOLD)
    {
        if (FOUNDATIONAL_LIB_UNLIKELY(dict_resize(dict) == -1))
        {
            // Don't need to re die aggressively if enabled here because dict resize
            // does it.
            return -1;
        }
    }
 
    const size_t index = dict_hash(key, dict->capacity);
 
    struct DictKeyValue *new_pair = (struct DictKeyValue *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(sizeof(struct DictKeyValue));
    if (FOUNDATIONAL_LIB_UNLIKELY(new_pair == NULL))
    {
        /* Keep the old key if there was one. */
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    new_pair->key = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(key);
    if (FOUNDATIONAL_LIB_UNLIKELY(new_pair->key == NULL))
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(new_pair);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
    new_pair->next = dict->table[index];
    new_pair->value = value;
 
    /* If there is a hash collision */
    if (dict->table[index] != NULL)
    {
        struct DictKeyValue *current = new_pair->next; // First one
        struct DictKeyValue *prev = new_pair;          // New one
        /* Traverse the linked list to check for duplicates */
        do
        {
            /* This should only ever happen once unless the dict is corrupt, so we return. */
            if (FOUNDATIONAL_LIB_STRCMP(current->key, key) == 0)
            {
                prev->next = current->next;
                /* Duplicate key found */
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current->key);
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current);
                /* Dont increment size */
                /* Assume the list only has 1 key with the value (it should unless
                 * something is really wrong). */
                goto end;
            }
 
            prev = current;
            current = current->next;
        } while (current != NULL);
    }
    ++dict->size;
 
end:
    dict->table[index] = new_pair;
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC void *dict_get(struct Dict *dict, const char *key)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
    const size_t index = dict_hash(key, dict->capacity);
    struct DictKeyValue *current_pair = dict->table[index];
 
    while (current_pair != NULL)
    {
        if (FOUNDATIONAL_LIB_STRCMP(current_pair->key, key) == 0)
        {
            return current_pair->value;
        }
 
        // Hash collision, continue with linked list.
        current_pair = current_pair->next;
    }
 
    return NULL;
}
 
FOUNDATIONAL_LIB_FUNC void *dict_get_check(struct Dict *dict, const char *key, int *key_is_in_dict)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key_is_in_dict);
 
    const size_t index = dict_hash(key, dict->capacity);
    struct DictKeyValue *current_pair = dict->table[index];
 
    while (current_pair != NULL)
    {
        if (FOUNDATIONAL_LIB_STRCMP(current_pair->key, key) == 0)
        {
            *key_is_in_dict = 1;
            return current_pair->value;
        }
        current_pair = current_pair->next;
    }
 
    *key_is_in_dict = 0;
    return NULL;
}
 
FOUNDATIONAL_LIB_FUNC void frozen_dict_destructor(struct FrozenDict *dict)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    dict_destructor((struct Dict *)dict);
}
 
FOUNDATIONAL_LIB_FUNC struct FrozenDict *frozen_dict_new_instance(size_t num_pairs, ...)
{
    struct FrozenDict *frozen_dict = (struct FrozenDict *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(sizeof(struct FrozenDict));
    if (FOUNDATIONAL_LIB_UNLIKELY(frozen_dict == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    frozen_dict->capacity = num_pairs * FOUNDATIONAL_LIB_FROZEN_INITIALIZATION_SIZE_MULTIPLIER;
    frozen_dict->size = 0;
    frozen_dict->table = (struct DictKeyValue **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(FOUNDATIONAL_LIB_HASH_INITIAL_CAPACITY, sizeof(struct DictKeyValue *));
    if (FOUNDATIONAL_LIB_UNLIKELY(frozen_dict->table == NULL))
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(frozen_dict);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    FOUNDATIONAL_LIB_VA_LIST args;
    FOUNDATIONAL_LIB_VA_START(args, num_pairs);
 
    for (size_t i = 0; i < num_pairs; ++i)
    {
        char *key;
        void *value;
 
        key = FOUNDATIONAL_LIB_VA_ARG(args, char *);
        value = FOUNDATIONAL_LIB_VA_ARG(args, void *);
 
        dict_add((struct Dict *)frozen_dict, key, value);
    }
 
    FOUNDATIONAL_LIB_VA_END(args); // Clean up the va_list
 
    return frozen_dict;
}
 
FOUNDATIONAL_LIB_FUNC void *frozen_dict_get(struct FrozenDict *dict, const char *key)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
    const size_t index = dict_hash(key, dict->capacity);
    struct DictKeyValue *current_pair = dict->table[index];
 
    while (current_pair != NULL)
    {
        if (FOUNDATIONAL_LIB_STRCMP(current_pair->key, key) == 0)
        {
            return current_pair->value;
        }
        current_pair = current_pair->next;
    }
 
    return NULL;
}
 
FOUNDATIONAL_LIB_FUNC void *frozen_dict_get_check(struct FrozenDict *dict, const char *key, int *key_is_in_dict)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key_is_in_dict);
 
    const size_t index = dict_hash(key, dict->capacity);
    struct DictKeyValue *current_pair = dict->table[index];
 
    while (current_pair != NULL)
    {
        if (FOUNDATIONAL_LIB_STRCMP(current_pair->key, key) == 0)
        {
            *key_is_in_dict = 1;
            return current_pair->value;
        }
        current_pair = current_pair->next;
    }
 
    *key_is_in_dict = 0;
    return NULL;
}
 
FOUNDATIONAL_LIB_FUNC void dict_iter(struct Dict *dict, void (*callback)(char *key, void *value))
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(callback);
 
    for (size_t i = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current = dict->table[i];
 
        while (current != NULL)
        {
            /* Call the callback function with the key and value */
            callback(current->key, current->value);
 
            /* Move to the next node in the linked list */
            current = current->next;
        }
    }
}
 
FOUNDATIONAL_LIB_FUNC void frozen_dict_iter(struct FrozenDict *frozen_dict, void (*callback)(char *key, void *value))
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(frozen_dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(callback);
    for (size_t i = 0; i < frozen_dict->capacity; ++i)
    {
        struct DictKeyValue *current = frozen_dict->table[i];
 
        while (current != NULL)
        {
            /* Call the callback function with the key and value */
            callback(current->key, current->value);
 
            /* Move to the next node in the linked list */
            current = current->next;
        }
    }
}
FOUNDATIONAL_LIB_FUNC size_t dict_size(struct Dict *dict)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    return dict->size;
}
 
FOUNDATIONAL_LIB_FUNC size_t frozen_dict_size(struct FrozenDict *dict)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
 
    return dict->size;
}
 
FOUNDATIONAL_LIB_FUNC int dict_to_array(struct Dict *dict, char ***keys, void ***values, size_t *size_of_keys_and_values)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(keys);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(values);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size_of_keys_and_values);
 
    const size_t alloc_size1 = FOUNDATIONAL_LIB_safe_mul(dict->size, sizeof(char *));
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size1 == 0))
        goto overflow;
    size_t alloc_size2;
 
    alloc_size2 = FOUNDATIONAL_LIB_safe_mul(dict->size, sizeof(void *));
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size2 == 0))
        goto overflow;
 
    *keys = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size1);
    if (FOUNDATIONAL_LIB_UNLIKELY(*keys == NULL))
        goto error_handler;
 
    *values = (void **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size2);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(*values == NULL))
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(*keys);
        *keys = NULL;
        // Values is already NULL here.
        goto error_handler;
    }
 
    for (size_t i = 0, index = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current_pair = dict->table[i];
        while (current_pair != NULL)
        {
            (*keys)[index] = (current_pair->key);
            (*values)[index] = current_pair->value;
 
            ++index;
            current_pair = current_pair->next;
        }
    }
 
    *size_of_keys_and_values = dict->size;
 
    return 0;
 
overflow:
error_handler:
 
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC size_t frozen_dict_to_array(struct FrozenDict *dict, char ***keys, void ***values, size_t *size_of_keys_and_values)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(keys);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(values);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size_of_keys_and_values);
 
    const size_t alloc_size1 = FOUNDATIONAL_LIB_safe_mul(dict->size, sizeof(char *));
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size1 == 0))
        goto overflow;
    size_t alloc_size2;
 
    alloc_size2 = FOUNDATIONAL_LIB_safe_mul(dict->size, sizeof(void *));
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size2 == 0))
        goto overflow;
 
    *keys = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size1);
    if (FOUNDATIONAL_LIB_UNLIKELY(*keys == NULL))
        goto error_handler;
 
    *values = (void **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size2);
 
    if (FOUNDATIONAL_LIB_UNLIKELY(*values == NULL))
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(*keys);
        *keys = NULL;
        // Values is already NULL here.
        goto error_handler;
    }
 
    for (size_t i = 0, index = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current_pair = dict->table[i];
        while (current_pair != NULL)
        {
            (*keys)[index] = (current_pair->key);
            (*values)[index] = current_pair->value;
 
            ++index;
            current_pair = current_pair->next;
        }
    }
 
    *size_of_keys_and_values = dict->size;
 
    return 0;
 
overflow:
error_handler:
 
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
static inline void dict_del_keys(char **keys)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(keys);
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(keys);
}
 
static inline void dict_del_values(void **values)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(values);
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(values);
}
 
FOUNDATIONAL_LIB_FUNC char *dict_to_string(struct Dict *dict, int pointer_or_string) /* 0 = pointer, 1 = string */
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(pointer_or_string == 0 || pointer_or_string == 1);
 
    /* Allocate memory for the string representation */
    size_t total_length = 2;
    for (size_t i = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current_pair = dict->table[i];
        while (current_pair != NULL)
        {
            /* Calculate the length of the string representation for each key-value
             * pair */
            total_length += FOUNDATIONAL_LIB_STRLEN(current_pair->key) + 2; // 2 for ": "
            if (pointer_or_string == 0)
            {
                total_length += FOUNDATIONAL_LIB_SNPRINTF(NULL, 0, "%p",
                                                          current_pair->value); // Calculate the length of the value string
            }
            else
            {
                total_length += FOUNDATIONAL_LIB_SNPRINTF(NULL, 0, "%s",
                                                          (char *)current_pair->value); // Calculate the length of the value string
            }
            total_length += 2; // 2 for ", "
            current_pair = current_pair->next;
        }
    }
 
    // Should not reach SIZE_MAX
 
    // Add 1 for the null-terminator, at least 3 chars additional
    char *result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(total_length + sizeof("")); /* Should be Safe. */
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    result[0] = '{';
    size_t index = 1;
 
    for (size_t i = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current_pair = dict->table[i];
        while (current_pair != NULL)
        {
            /* Append the key and value to the string representation */
            if (pointer_or_string == 0)
            {
                index += FOUNDATIONAL_LIB_SNPRINTF(result + index, total_length - index, "%s: %p", current_pair->key, current_pair->value);
            }
            else if (pointer_or_string == 1)
            {
                index += FOUNDATIONAL_LIB_SNPRINTF(result + index, total_length - index, "%s: %s", current_pair->key, (char *)current_pair->value);
            }
            current_pair = current_pair->next;
 
            /* Add a separator (comma) if there are more elements */
            if (index < total_length - 2)
            {
                result[index++] = ',';
                result[index++] = ' ';
            }
        }
    }
 
    if (dict->capacity)
    {
        index -= 2;
    }
 
    result[index++] = '}';
    result[index++] = '\0'; // Null-terminate the string
    return result;
}
 
FOUNDATIONAL_LIB_FUNC char *frozen_dict_to_string(struct FrozenDict *dict, int pointer_or_string) /* 0 = pointer, 1 = string */
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(dict);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(pointer_or_string == 0 || pointer_or_string == 1);
    /* Allocate memory for the string representation */
    size_t total_length = 2;
    for (size_t i = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current_pair = dict->table[i];
        while (current_pair != NULL)
        {
            /* Calculate the length of the string representation for each key-value
             * pair */
            total_length += FOUNDATIONAL_LIB_STRLEN(current_pair->key) + 2; // 2 for ": "
 
            if (pointer_or_string == 0)
            {
                total_length += FOUNDATIONAL_LIB_SNPRINTF(NULL, 0, "%p",
                                                          current_pair->value); // Calculate the length of the value string
            }
            else
            {
                total_length += FOUNDATIONAL_LIB_SNPRINTF(NULL, 0, "%s",
                                                          (char *)current_pair->value); // Calculate the length of the value string
            }
            total_length += 2; // 2 for ", "
            current_pair = current_pair->next;
        }
    }
 
    // Should not reach SIZE_MAX
 
    // Add 1 for the null-terminator, at least 3 chars additional
    char *result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(total_length + sizeof("")); /* Safe. */
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    result[0] = '{';
    size_t index = 1;
 
    for (size_t i = 0; i < dict->capacity; ++i)
    {
        struct DictKeyValue *current_pair = dict->table[i];
        while (current_pair != NULL)
        {
            /* Append the key and value to the string representation */
            if (pointer_or_string == 0)
            {
                index += FOUNDATIONAL_LIB_SNPRINTF(result + index, total_length - index, "%s: %p", current_pair->key, current_pair->value);
            }
            else if (pointer_or_string == 1)
            {
                index += FOUNDATIONAL_LIB_SNPRINTF(result + index, total_length - index, "%s: %s", current_pair->key, (char *)current_pair->value);
            }
            current_pair = current_pair->next;
 
            /* Add a separator (comma) if there are more elements */
            if (index < total_length - 2)
            {
                result[index++] = ',';
                result[index++] = ' ';
            }
        }
    }
 
    if (dict->capacity)
    {
        index -= 2;
    }
 
    result[index++] = '}';
    result[index++] = '\0'; // Null-terminate the string
    return result;
}
 
static inline void frozen_dict_del_keys(char **keys)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(keys);
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(keys);
}
 
static inline void frozen_dict_del_values(void **values)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(values);
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(values);
}
 
FOUNDATIONAL_LIB_FUNC void set_destructor(struct Set *set)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
 
    for (size_t i = 0; i < set->capacity; ++i)
    {
        struct SetKey *current_key = set->table[i];
        while (current_key != NULL)
        {
            struct SetKey *next_key = current_key->next;
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current_key->key);
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current_key);
            current_key = next_key;
        }
    }
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(set->table);
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(set);
}
 
FOUNDATIONAL_LIB_FUNC struct Set *set_new_instance(void)
{
    struct Set *set = (struct Set *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(sizeof(struct Set));
    if (FOUNDATIONAL_LIB_UNLIKELY(set == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    set->capacity = FOUNDATIONAL_LIB_HASH_INITIAL_CAPACITY;
    set->size = 0;
    set->table = (struct SetKey **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(FOUNDATIONAL_LIB_HASH_INITIAL_CAPACITY, sizeof(struct SetKey *));
    if (FOUNDATIONAL_LIB_UNLIKELY(set->table == NULL))
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(set);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    return set;
}
 
FOUNDATIONAL_LIB_FUNC size_t set_hash(const char *key, size_t capacity)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
    size_t hash = 5381; // Initial hash value
    int c;              // Variable to store the current character
 
    while ((c = *key++))
    {
        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
    }
 
    return hash % capacity;
}
 
FOUNDATIONAL_LIB_FUNC int set_resize(struct Set *set)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
 
    const size_t new_capacity = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(set->capacity);
    if (FOUNDATIONAL_LIB_UNLIKELY(new_capacity == 0)) // Overflow.
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
    /* Either calloc or realloc would be ideal here, but, if the block is large,
       then calloc might be better because there might be a cleared block of
       memory that is very large that is readily available. */
    struct SetKey **new_table = (struct SetKey **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(new_capacity, sizeof(struct SetKey *));
    if (FOUNDATIONAL_LIB_UNLIKELY(new_table == NULL))
    {
        set_destructor(set);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    for (size_t i = 0; i < set->capacity; ++i)
    {
        struct SetKey *current_key = set->table[i];
        while (current_key)
        {
            struct SetKey *next_key = current_key->next;
            const size_t new_index = set_hash(current_key->key, new_capacity);
            current_key->next = new_table[new_index];
            new_table[new_index] = current_key;
            current_key = next_key;
        }
    }
 
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(set->table);
    set->table = new_table;
    set->capacity = new_capacity;
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC void set_del_key(struct Set *set, const char *key)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
 
    const size_t index = set_hash(key, set->capacity);
 
    struct SetKey *current = set->table[index];
    struct SetKey *prev = NULL;
 
    while (current != NULL)
    {
        if (FOUNDATIONAL_LIB_STRCMP(current->key, key) == 0)
        {
            /* Key found, remove the entry */
            if (prev == NULL)
            {
                /* If it's the first node in the linked list */
                set->table[index] = current->next;
            }
            else
            {
                prev->next = current->next;
            }
 
            /* Free memory */
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current->key);
            FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current);
 
            /* Update size */
            --set->size;
 
            return;
        }
 
        /* Move to the next node in the linked list */
        prev = current;
        current = current->next;
    }
}
 
FOUNDATIONAL_LIB_FUNC int set_add(struct Set *set, const char *key)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
 
    if ((double)set->size / set->capacity > FOUNDATIONAL_LIB_HASH_LOAD_FACTOR_THRESHOLD)
    {
        if (FOUNDATIONAL_LIB_UNLIKELY(set_resize(set) == -1))
        {
            // Don't need to re die aggressively if enabled here because set resize does it.
            return -1;
        }
    }
 
    const size_t index = set_hash(key, set->capacity);
 
    struct SetKey *new_set_key = (struct SetKey *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(sizeof(struct SetKey));
    if (FOUNDATIONAL_LIB_UNLIKELY(new_set_key == NULL))
    {
        /* Keep the old key if there was one. */
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    new_set_key->key = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_STRDUP(key);
    if (FOUNDATIONAL_LIB_UNLIKELY(new_set_key->key == NULL))
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(new_set_key);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
    new_set_key->next = set->table[index];
 
    /* If there is a hash collision */
    if (set->table[index] != NULL)
    {
        struct SetKey *current = new_set_key->next; // First one
        struct SetKey *prev = new_set_key;          // New one
        /* Traverse the linked list to check for duplicates */
        do
        {
            /* This should only ever happen once unless the set is corrupt, so we return. */
 
            if (FOUNDATIONAL_LIB_STRCMP(current->key, key) == 0)
            { /* Duplicate key found */
                prev->next = current->next;
 
                // Free the old key
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current->key);
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(current);
 
                /* Dont increment size */
                /* Assume the list only has 1 key with the value (it should unless
                 * something is really wrong). */
 
                goto end;
            }
 
            prev = current;
            current = current->next;
        } while (current != NULL);
    }
 
    ++set->size;
end:
    set->table[index] = new_set_key;
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC int set_reserve_more(struct Set *set, size_t number_of_new_elements_max_one_is_expecting)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
 
    const size_t new_capacity = FOUNDATIONAL_LIB_safe_add_2(set->capacity, number_of_new_elements_max_one_is_expecting);
    if (FOUNDATIONAL_LIB_UNLIKELY(new_capacity == 0)) // Overflow.
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
    /* Either calloc or realloc would be ideal here, but, if the block is large,
       then calloc might be better because there might be a cleared block of
       memory that is very large that is readily available. */
    struct SetKey **new_table = (struct SetKey **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(new_capacity, sizeof(struct SetKey *));
    if (FOUNDATIONAL_LIB_UNLIKELY(new_table == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return -1;
    }
 
    for (size_t i = 0; i < set->capacity; ++i)
    {
        struct SetKey *current_key = set->table[i];
        while (current_key)
        {
            struct SetKey *next_key = current_key->next;
            const size_t new_index = set_hash(current_key->key, new_capacity);
            current_key->next = new_table[new_index];
            new_table[new_index] = current_key;
            current_key = next_key;
        }
    }
 
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(set->table);
    set->table = new_table;
    set->capacity = new_capacity;
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC int set_in(struct Set *set, const char *key)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(key);
 
    const size_t index = set_hash(key, set->capacity);
    struct SetKey *current_key = set->table[index];
 
    while (current_key != NULL)
    {
        if (FOUNDATIONAL_LIB_STRCMP(current_key->key, key) == 0)
        {
            return 1;
        }
        current_key = current_key->next;
    }
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC void frozen_set_destructor(struct FrozenSet *frozen_set)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(frozen_set);
    set_destructor((struct Set *)frozen_set);
}
 
FOUNDATIONAL_LIB_FUNC struct FrozenSet *frozen_set_new_instance(size_t num_args, ...)
{
    struct FrozenSet *frozen_set = (struct FrozenSet *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(sizeof(struct FrozenSet));
    if (FOUNDATIONAL_LIB_UNLIKELY(frozen_set == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    frozen_set->capacity = num_args * FOUNDATIONAL_LIB_FROZEN_INITIALIZATION_SIZE_MULTIPLIER;
    frozen_set->size = 0;
    frozen_set->table = (struct SetKey **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(FOUNDATIONAL_LIB_HASH_INITIAL_CAPACITY, sizeof(struct SetKey *));
    if (FOUNDATIONAL_LIB_UNLIKELY(frozen_set->table == NULL))
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(frozen_set);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    FOUNDATIONAL_LIB_VA_LIST args;
    FOUNDATIONAL_LIB_VA_START(args, num_args);
 
    for (size_t i = 0; i < num_args; ++i)
    {
        char *key;
 
        key = FOUNDATIONAL_LIB_VA_ARG(args, char *);
        set_add((struct Set *)frozen_set, key);
    }
 
    FOUNDATIONAL_LIB_VA_END(args); // Clean up the va_list
 
    return frozen_set;
}
 
FOUNDATIONAL_LIB_FUNC int frozen_set_in(struct FrozenSet *set, const char *key)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
 
    const size_t index = set_hash(key, set->capacity);
    struct SetKey *current_key = set->table[index];
 
    while (current_key != NULL)
    {
        if (FOUNDATIONAL_LIB_STRCMP(current_key->key, key) == 0)
        {
            return 1;
        }
        current_key = current_key->next;
    }
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC void set_iter(struct Set *set, void (*callback)(char *key))
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(callback);
    for (size_t i = 0; i < set->capacity; ++i)
    {
        struct SetKey *current = set->table[i];
 
        while (current != NULL)
        {
            /* Call the callback function with the key and value */
            callback(current->key);
 
            /* Move to the next node in the linked list */
            current = current->next;
        }
    }
}
 
FOUNDATIONAL_LIB_FUNC size_t set_size(struct Set *set)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
    return set->size;
}
 
FOUNDATIONAL_LIB_FUNC size_t frozen_set_size(struct FrozenSet *set)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
    return set->size;
}
 
FOUNDATIONAL_LIB_FUNC int set_to_array(struct Set *set, char ***keys, size_t *size_of_keys)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(keys);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size_of_keys);
 
    const size_t alloc_size1 = FOUNDATIONAL_LIB_safe_mul(set->size, sizeof(char *));
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size1 == 0))
        goto overflow;
 
    *keys = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size1);
    if (FOUNDATIONAL_LIB_UNLIKELY(*keys == NULL))
        goto error_handler;
 
    for (size_t i = 0, index = 0; i < set->capacity; ++i)
    {
        struct SetKey *current_pair = set->table[i];
        while (current_pair != NULL)
        {
            (*keys)[index] = (current_pair->key);
 
            ++index;
            current_pair = current_pair->next;
        }
    }
 
    *size_of_keys = set->size;
 
    return 0;
 
overflow:
error_handler:
 
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC int frozen_set_to_array(struct FrozenSet *set, char ***keys, size_t *size_of_keys)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(keys);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size_of_keys);
 
    const size_t alloc_size1 = FOUNDATIONAL_LIB_safe_mul(set->size, sizeof(char *));
    if (FOUNDATIONAL_LIB_UNLIKELY(alloc_size1 == 0))
        goto overflow;
 
    *keys = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(alloc_size1);
    if (FOUNDATIONAL_LIB_UNLIKELY(*keys == NULL))
        goto error_handler;
 
    for (size_t i = 0, index = 0; i < set->capacity; ++i)
    {
        struct SetKey *current_pair = set->table[i];
        while (current_pair != NULL)
        {
            (*keys)[index] = (current_pair->key);
 
            ++index;
            current_pair = current_pair->next;
        }
    }
 
    *size_of_keys = set->size;
 
    return 0;
 
overflow:
error_handler:
 
    FOUNDATIONAL_LIB_die_aggressively_if_enabled();
    return -1;
}
 
FOUNDATIONAL_LIB_FUNC void set_del_keys(char **keys) { FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(keys); }
 
FOUNDATIONAL_LIB_FUNC char *set_to_string(struct Set *set)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
 
    /* Allocate memory for the string representation */
    size_t total_length = 2;
    for (size_t i = 0; i < set->capacity; ++i)
    {
        struct SetKey *current_key = set->table[i];
        while (current_key != NULL)
        {
            /* Calculate the length of the string representation for each key-value
             * pair */
            total_length += FOUNDATIONAL_LIB_STRLEN(current_key->key);
            total_length += 2; // 2 for ", "
            current_key = current_key->next;
        }
    }
 
    // Should not reach SIZE_MAX
 
    // Add 1 for the null-terminator, at least 3 chars additional
 
    char *result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(total_length + sizeof("")); /* Safe */
 
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    result[0] = '{';
    size_t index = 1;
 
    for (size_t i = 0; i < set->capacity; ++i)
    {
        struct SetKey *current_key = set->table[i];
        while (current_key != NULL)
        {
            /* Append the key and value to the string representation */
            index += FOUNDATIONAL_LIB_SNPRINTF(result + index, total_length - index, "%s", current_key->key);
            current_key = current_key->next;
 
            /* Add a separator (comma) if there are more elements */
            if (index < total_length - 2)
            {
                result[index++] = ',';
                result[index++] = ' ';
            }
        }
    }
 
    if (set->capacity)
    {
        index -= 2;
    }
    result[index++] = '}';
    result[index++] = '\0'; // Null-terminate the string
    return result;
}
 
FOUNDATIONAL_LIB_FUNC char *frozen_set_to_string(struct FrozenSet *frozen_set)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(frozen_set);
 
    /* Allocate memory for the string representation */
    size_t total_length = 2;
    for (size_t i = 0; i < frozen_set->capacity; ++i)
    {
        struct SetKey *current_key = frozen_set->table[i];
        while (current_key != NULL)
        {
            /* Calculate the length of the string representation for each key-value
             * pair */
            total_length += FOUNDATIONAL_LIB_STRLEN(current_key->key);
            total_length += 2; // 2 for ", "
            current_key = current_key->next;
        }
    }
 
    // Should not reach SIZE_MAX
 
    // Add 1 for the null-terminator, at least 3 chars
    char *result = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(total_length + 1 /* Safe, should not reach SIZE_MAX */);
    if (FOUNDATIONAL_LIB_UNLIKELY(result == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    result[0] = '{';
    size_t index = 1;
 
    for (size_t i = 0; i < frozen_set->capacity; ++i)
    {
        struct SetKey *current_key = frozen_set->table[i];
        while (current_key != NULL)
        {
            /* Append the key and value to the string representation */
            index += FOUNDATIONAL_LIB_SNPRINTF(result + index, total_length - index, "%s", current_key->key);
            current_key = current_key->next;
 
            /* Add a separator (comma) if there are more elements */
            if (index < total_length - 2)
            {
                result[index++] = ',';
                result[index++] = ' ';
            }
        }
    }
 
    if (frozen_set->capacity)
    {
        index -= 2;
    }
 
    result[index++] = '}';
    result[index++] = '\0'; // Null-terminate the string
 
    return result;
}
 
FOUNDATIONAL_LIB_FUNC void frozen_set_del_keys(char **keys)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(keys);
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(keys);
}
 
FOUNDATIONAL_LIB_FUNC void frozen_set_iter(struct Set *set, void (*callback)(char *key))
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(set);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(callback);
 
    for (size_t i = 0; i < set->capacity; ++i)
    {
        struct SetKey *current_key = set->table[i];
 
        while (current_key != NULL)
        {
            /* Call the callback function with the key and value */
            callback(current_key->key);
 
            /* Move to the next node in the linked list */
            current_key = current_key->next;
        }
    }
}
 
FOUNDATIONAL_LIB_FUNC int is_valid_utf8(const char *str, size_t len)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str);
 
    size_t i = 0;
 
    while (i < len)
    {
        if ((str[i] & 0x80) == 0)
        {
            // ASCII character (0xxxxxxx)
            i++;
        }
        else if ((str[i] & 0xE0) == 0xC0)
        {
            // 2-byte UTF-8 character (110xxxxx)
            if (i + 1 >= len || (str[i + 1] & 0xC0) != 0x80)
                return 0;
            i += 2;
        }
        else if ((str[i] & 0xF0) == 0xE0)
        {
            // 3-byte UTF-8 character (1110xxxx)
            if (i + 2 >= len || (str[i + 1] & 0xC0) != 0x80 || (str[i + 2] & 0xC0) != 0x80)
                return 0;
            i += 3;
        }
        else if ((str[i] & 0xF8) == 0xF0)
        {
            // 4-byte UTF-8 character (11110xxx)
            if (i + 3 >= len || (str[i + 1] & 0xC0) != 0x80 || (str[i + 2] & 0xC0) != 0x80 || (str[i + 3] & 0xC0) != 0x80)
                return 0;
            i += 4;
        }
        else
        {
            // Invalid UTF-8 encoding
            return 0;
        }
    }
 
    return 1;
}
 
FOUNDATIONAL_LIB_FUNC const char *sample_strings(const char **strings, size_t size) /* Does not dynamically allocate memory. */
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(strings);
 
    long j;
 
#ifdef _WIN32
    unsigned int rand_val;
    if (rand_s(&rand_val) != 0)
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    j = rand_val % size;
#elif defined(__linux__)
    j = (long)(drand48() * size);
#else
    j = rand() % size;
#endif
 
    return strings[j];
}
 
FOUNDATIONAL_LIB_FUNC int shuffle_strings_in_place(char **strings, size_t size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(strings);
 
    for (size_t i = size - 1; i; --i)
    {
        long j;
#ifdef _WIN32
        unsigned int rand_val;
        if (FOUNDATIONAL_LIB_UNLIKELY(rand_s(&rand_val) != 0))
        {
            FOUNDATIONAL_LIB_die_aggressively_if_enabled();
            return -1;
        }
 
        j = rand_val % (i + 1);
#elif defined(__linux__)
        j = (long)(drand48() * (i + 1));
#else
        j = rand() % (i + 1);
#endif
 
        // Swap strings[i] and strings[j]
        char *temp = strings[i];
        strings[i] = strings[j];
        strings[j] = temp;
    }
 
    return 0;
}
 
FOUNDATIONAL_LIB_FUNC long rand_number_from_range_inclusive_signed(signed long min, signed long max)
{
    const signed long long range = max - min + 1;
 
#ifdef _WIN32
    unsigned int rand_val;
    if (rand_s(&rand_val) != 0)
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return 0;
    }
 
    return min + (rand_val % range);
#elif defined(__linux__)
    return min + (long)(drand48() * range);
#else
    return min + (rand() % range);
#endif
}
 
FOUNDATIONAL_LIB_FUNC unsigned long rand_number_from_range_inclusive_unsigned(unsigned long min, unsigned long max)
{
    const unsigned long range = max - min + 1;
 
#ifdef _WIN32
    unsigned int rand_val;
    if (rand_s(&rand_val) != 0)
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return 0;
    }
 
    return min + (rand_val % range);
#elif defined(__linux__)
    return min + (unsigned long)(drand48() * range);
#else
    return min + (rand() % range);
#endif
}
 
#if FOUNDATIONAL_LIB_UNSAFE_FUNCTIONS_ENABLED
FOUNDATIONAL_LIB_FUNC char *backticks(const char *command, size_t *size)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(command);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size);
 
    FILE *pipe = FOUNDATIONAL_LIB_POPEN(command, "r");
    if (FOUNDATIONAL_LIB_UNLIKELY(pipe == NULL))
    {
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL; // Indicate error by returning NULL
    }
 
    // Read the command output into the string
    size_t output_size = FOUNDATIONAL_LIB_POPEN_INITIAL_ALLOC_SIZE; // Initial output buffer size
    char *output = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(output_size);
    if (FOUNDATIONAL_LIB_UNLIKELY(output == NULL))
    {
        pclose(pipe); // No need to check errors here because things are already
                      // going wrong.
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    size_t total_read = 0;
 
    for (;;)
    {
        const size_t read_size = FOUNDATIONAL_LIB_FREAD(output + total_read, 1, 4096, pipe);
 
        if (FOUNDATIONAL_LIB_UNLIKELY(read_size == 0))
        {
            const int error_code = FOUNDATIONAL_LIB_FERROR(pipe);
            if (FOUNDATIONAL_LIB_UNLIKELY(error_code))
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(output);
                pclose(pipe); // No need to check errors here because things are already
                              // going wrong.
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return NULL;
            }
            else
            {
                break;
            }
        }
        else if (total_read + read_size + 1 > output_size)
        {
            const size_t new_realloc_length = FOUNDATIONAL_LIB_safe_add_3(total_read, read_size, 1);
 
            if (FOUNDATIONAL_LIB_UNLIKELY(new_realloc_length == 0))
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(output);
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return NULL;
            }
            // Expand the buffer
            output_size = FOUNDATIONAL_LIB_REALLOC_REALLOCATION_ALGORITHM(new_realloc_length);
 
            if (FOUNDATIONAL_LIB_UNLIKELY(output_size == 0)) // Overflow.
            {
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return NULL;
            }
            char *new_output = (char *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_REALLOC(output, output_size);
 
            if (FOUNDATIONAL_LIB_UNLIKELY(new_output == NULL))
            {
                FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(output);
                pclose(pipe); // No need to check errors here because things are already
                              // going wrong.
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return NULL;
            }
 
            output = new_output;
        }
        total_read += read_size;
    }
 
    if (FOUNDATIONAL_LIB_UNLIKELY(ferror(pipe) != 0))
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(output);
 
        pclose(pipe); // No need to re check for errors because things are going wrong.
 
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
 
        return NULL; // Error reading from pipe
    }
 
    // Null-terminate the string
    output[total_read] = '\0';
 
    *size = total_read;
 
    // Close the pipe
    if (FOUNDATIONAL_LIB_UNLIKELY(pclose(pipe) != 0)) // Check for errors.
    {
        FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE(output);
        FOUNDATIONAL_LIB_die_aggressively_if_enabled();
        return NULL;
    }
 
    return output;
}
 
#endif
 
FOUNDATIONAL_LIB_FUNC char **read_file_into_array(const char *filename, const char *delim, size_t *num_lines)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(filename);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(delim);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(num_lines);
 
    size_t size_of_file;
 
    *num_lines = 0;
 
    /*
     * This approach uses very few system calls and is rather efficient.
     * It first gets the entire file into memory, then splits it.
     * There would be very few fread() calls, and it can predict the buffer
     * size ahead of time, for low memory usage.
     *
     * One issue with this is that it has to allocate memory twice -
     * first for read_file_into_array - second for the new array,
     * after which the first array is freed(). So that means for
     * a time, the computer needs around 2x the memory.
     * However, if you are concerned about memory usage, probably
     * better might be read_file_into_string() with strtok() used
     * to extract the parts you want, or manual code withFOUNDATIONAL_LIB_FREAD().
     *
     * Any which way, this implementation is decent and efficient
     * for many purposes.
     */
    const char *file = read_file_into_string(filename, &size_of_file);
    if (FOUNDATIONAL_LIB_UNLIKELY(file == NULL))
    {
        /* read_file_into_string() would already call die_aggressively_if_enabled */
 
        return NULL;
    }
 
    char **lines = split(file, num_lines, delim, 0, 1);
 
    FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_FREE((void *)file);
    if (FOUNDATIONAL_LIB_UNLIKELY(lines == NULL))
    {
        /* split() would already call die_aggressively_if_enabled */
 
        return NULL;
    }
 
    return lines;
}
 
FOUNDATIONAL_LIB_FUNC void print_char(const char value) { FOUNDATIONAL_LIB_PRINTF("%c", value); }
 
FOUNDATIONAL_LIB_FUNC void print_char_to_stream(const char value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%c", value);
}
 
FOUNDATIONAL_LIB_FUNC void print_double(const double value) { FOUNDATIONAL_LIB_PRINTF("%f", value); }
 
FOUNDATIONAL_LIB_FUNC void print_double_to_stream(const double value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%f", value);
}
 
FOUNDATIONAL_LIB_FUNC void print_float(const float value) { FOUNDATIONAL_LIB_PRINTF("%f", value); }
 
FOUNDATIONAL_LIB_FUNC void print_float_to_stream(const float value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%f", value);
}
 
FOUNDATIONAL_LIB_FUNC void print_int(const int value) { FOUNDATIONAL_LIB_PRINTF("%d", value); }
 
FOUNDATIONAL_LIB_FUNC void print_int_to_stream(const int value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%d", value);
}
 
FOUNDATIONAL_LIB_FUNC void print_long(const long value) { FOUNDATIONAL_LIB_PRINTF("%ld", value); }
 
FOUNDATIONAL_LIB_FUNC void print_long_to_stream(const long value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%ld", value);
}
 
FOUNDATIONAL_LIB_FUNC void print_long_long(const long long value) { FOUNDATIONAL_LIB_PRINTF("%lld", value); }
 
FOUNDATIONAL_LIB_FUNC void print_long_long_to_stream(const long long value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wformat-extra-args"
 
    FOUNDATIONAL_LIB_FPRINTF(stream, "%lld", value);
#pragma GCC diagnostic pop
}
 
FOUNDATIONAL_LIB_FUNC void print_short(const short value) { FOUNDATIONAL_LIB_PRINTF("%hd", value); }
 
FOUNDATIONAL_LIB_FUNC void print_short_to_stream(const short value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%hd", value);
}
FOUNDATIONAL_LIB_FUNC void print_size_t(const size_t value) { FOUNDATIONAL_LIB_PRINTF("%zu", value); }
 
FOUNDATIONAL_LIB_FUNC void print_size_t_to_stream(const size_t value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wformat-extra-args"
    FOUNDATIONAL_LIB_FPRINTF(stream, "%zu", value);
#pragma GCC diagnostic pop
}
 
FOUNDATIONAL_LIB_FUNC void print_string(char *value)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(value);
    FOUNDATIONAL_LIB_PRINTF("%s", value);
}
 
FOUNDATIONAL_LIB_FUNC void print_string_to_stream(char *value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(value);
 
    FOUNDATIONAL_LIB_FPRINTF(stream, "%s", value);
}
 
FOUNDATIONAL_LIB_FUNC void print_uchar(const unsigned char value) { FOUNDATIONAL_LIB_PRINTF("%c", value); }
 
FOUNDATIONAL_LIB_FUNC void print_uchar_to_stream(const unsigned char value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%c", value);
}
 
FOUNDATIONAL_LIB_FUNC void print_uint(const unsigned int value) { FOUNDATIONAL_LIB_PRINTF("%u", value); }
 
FOUNDATIONAL_LIB_FUNC void print_uint_to_stream(const unsigned int value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%u", value);
}
FOUNDATIONAL_LIB_FUNC void print_ulong(const unsigned long value) { FOUNDATIONAL_LIB_PRINTF("%lu", value); }
 
FOUNDATIONAL_LIB_FUNC void print_ulong_to_stream(const unsigned long value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%lu", value);
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_long(const unsigned long long value)
{
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wformat-extra-args"
    FOUNDATIONAL_LIB_PRINTF("%llu", value);
#pragma GCC diagnostic pop
}
 
FOUNDATIONAL_LIB_FUNC void print_ulong_long_to_stream(const unsigned long long value, FILE *stream)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wformat"
#pragma GCC diagnostic ignored "-Wformat-extra-args"
    FOUNDATIONAL_LIB_FPRINTF(stream, "%llu", value);
#pragma GCC diagnostic pop
}
FOUNDATIONAL_LIB_FUNC void print_ushort(const unsigned short value) { FOUNDATIONAL_LIB_PRINTF("%hu", value); }
 
FOUNDATIONAL_LIB_FUNC void print_ushort_to_stream(const unsigned short value, FILE *stream)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(stream);
    FOUNDATIONAL_LIB_FPRINTF(stream, "%hu", value);
}
 
FOUNDATIONAL_LIB_FUNC size_t count_occurrences_of_string_in_array(const char **array, const char *string, size_t array_length)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
 
    size_t count = 0;
 
    // Iterate through the array
    for (size_t i = 0; i < array_length; ++i)
    {
        // Compare each string in the array with the target string
        if (FOUNDATIONAL_LIB_STRCMP(array[i], string) == 0)
        {
            ++count;
        }
    }
 
    return count;
}
 
FOUNDATIONAL_LIB_FUNC size_t count_occurrences_of_adjacent_data_in_array(const void *array_of_adjacent_values, size_t array_length, const void *memory, size_t memory_length)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_of_adjacent_values);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(memory_length);
    size_t count = 0;
 
    // Iterate through the array
    for (size_t i = 0; i < array_length; ++i)
    {
        // Dereferences each pointer in the array and compare memory_length bytes.
        if (FOUNDATIONAL_LIB_MEMCMP(array_of_adjacent_values, memory, memory_length) == 0)
        {
            count++;
        }
    }
 
    return count;
}
 
FOUNDATIONAL_LIB_FUNC size_t count_occurrences_of_data_in_array(const void **array_of_pointers, size_t array_length, const void *memory, size_t memory_length)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(array_of_pointers);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(memory);
 
    size_t count = 0;
 
    // Iterate through the array
    for (size_t i = 0; i < array_length; ++i)
    {
        // Dereferences each pointer in the array and compare memory_length bytes.
        if (FOUNDATIONAL_LIB_MEMCMP(array_of_pointers[i], memory, memory_length) == 0)
        {
            count++;
        }
    }
 
    return count;
}
 
#if FOUNDATIONAL_LIB_NETWORK_FUNCTIONS_ENABLED
 
/* Chrome by default */
 
#define FOUNDATIONAL_LIB_DEFAULT_USER_AGENT "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"
 
#include <curl/curl.h>
 
/* Write callback */
FOUNDATIONAL_LIB_FUNC size_t FOUNDATIONAL_LIB_libcurl_write_callback(char *data, size_t n, size_t l, void *userp)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(data);
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(userp);
    struct StringData
    {
        char *string;
 
        size_t size;
        size_t alloc_size;
 
        size_t byte_max_cutoff;
    } *string = userp;
 
    const size_t both = n * l;
    append_string_to_string(&string->string, &string->size, &string->alloc_size, data, both);
 
    if (string->byte_max_cutoff != 0 && string->size >= string->byte_max_cutoff)
    {
        /* Curl can read in big blocks, like 9,370 bytes. So if the cutoff is low,
         * the read size still might be high. */
        /* FOUNDATIONAL_LIB_PRINTF("%zu.size >= %zu.byte_max_cutoff\n", string->size,
               string->byte_max_cutoff); */
        return CURLE_OK;
    }
    return both;
}
 
FOUNDATIONAL_LIB_FUNC int download_website(const char *website, char **string, size_t *size, size_t *str_alloc_size, size_t byte_max_cutoff, const char *user_agent)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(website);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(string);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(size);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(str_alloc_size);
 
    CURL *curl = curl_easy_init();
    if (FOUNDATIONAL_LIB_UNLIKELY(curl == NULL))
    {
        return -1;
    }
 
    if (user_agent == NULL)
    {
        user_agent = FOUNDATIONAL_LIB_DEFAULT_USER_AGENT;
    }
 
    curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, 102400L);
    curl_easy_setopt(curl, CURLOPT_URL, website);
    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
    curl_easy_setopt(curl, CURLOPT_USERAGENT, user_agent);
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
    curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, (long)CURL_HTTP_VERSION_2TLS);
    curl_easy_setopt(curl, CURLOPT_FTP_SKIP_PASV_IP, 1L);
    curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L);
    struct StringData
    {
        char *string;
        size_t size;
        size_t alloc_size;
        size_t byte_max_cutoff;
    } data;
    data.string = FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_MALLOC(FOUNDATIONAL_LIB_INITIAL_NETWORK_DOWNLOAD_BUFFER_SIZE);
    data.alloc_size = FOUNDATIONAL_LIB_INITIAL_NETWORK_DOWNLOAD_BUFFER_SIZE;
    data.size = 0;
    data.byte_max_cutoff = byte_max_cutoff;
 
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, FOUNDATIONAL_LIB_libcurl_write_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &data);
    CURLcode curlcode = curl_easy_perform(curl);
 
    curl_easy_cleanup(curl);
 
    *string = data.string;
    *size = data.size;
    *str_alloc_size = data.alloc_size;
 
    return curlcode == CURLE_OK;
}
 
FOUNDATIONAL_LIB_FUNC int download_websites(const char **websites_to_download, size_t num_websites, char ***outputs, size_t **lens, size_t byte_limit, int aggressive_stop_on_error)
{
 
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(websites_to_download);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(outputs);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(lens);
    // Initalize all to NULL in case a site can't download
    *outputs = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(num_websites, sizeof(char *));
 
    // Initalize all to 0 in case a site can't download
    *lens = (size_t *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(num_websites, sizeof(size_t));
 
    for (size_t i = 0; i < num_websites; ++i)
    {
        size_t alloc_size;
        if (download_website(websites_to_download[i], (*outputs) + i, (*lens) + i, &alloc_size, byte_limit, NULL) == -1)
        {
            if (aggressive_stop_on_error)
            {
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return -1;
            }
        }
    }
 
    return 0;
}
 
#endif /* Networking. */
 
FOUNDATIONAL_LIB_FUNC int read_files_into_array(const char **files_to_open, size_t num_files, char ***outputs, size_t **lens, int aggressive_stop_on_error)
{
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(files_to_open);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(outputs);
    FOUNDATIONAL_LIB_ASSERT_ARGUMENT_IF_ENABLED(lens);
    // Initalize all to NULL in case a site can't download
    *outputs = (char **)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(num_files, sizeof(char *));
 
    // Initalize all to 0 in case a site can't download
    *lens = (size_t *)FOUNDATIONAL_LIB_MEMORY_ALLOCATOR_CALLOC(num_files, sizeof(size_t));
 
    for (size_t i = 0; i < num_files; ++i)
    {
        size_t size;
 
        (*outputs)[i] = read_file_into_string(files_to_open[i], &size);
        (*lens)[i] = size;
 
        if ((*outputs)[i] == NULL)
        {
            if (aggressive_stop_on_error)
            {
                FOUNDATIONAL_LIB_die_aggressively_if_enabled();
                return -1;
            }
        }
    }
 
    return 0;
}
 
#pragma GCC diagnostic pop /* Niche Wformat issues */
 
#endif