From 68600e9b0f75e6b9e38e938598f50984c6451b9c Mon Sep 17 00:00:00 2001
From: retoor <retoor@molodetz.nl>
Date: Thu, 28 Nov 2024 23:28:33 +0100
Subject: [PATCH] Added rlib

---
 README.md |    4 +
 rlib.h    | 8448 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 sorm      |  Bin 216384 -> 216384 bytes
 sorm.h    |    4 +-
 sorm.so   |  Bin 256088 -> 256088 bytes
 str.h     |    4 +-
 6 files changed, 8456 insertions(+), 4 deletions(-)
 create mode 100644 rlib.h

diff --git a/README.md b/README.md
index 99467a9..e40884c 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,9 @@
 # SORM
 
+## Todo
+ - auto complete table / view names.
+
+
 ## Description
 SORM stands for SQL ORM. I made this because I have a love/hate relationship with both. I combined them together to have the best of both worlds!
 
diff --git a/rlib.h b/rlib.h
new file mode 100644
index 0000000..9151891
--- /dev/null
+++ b/rlib.h
@@ -0,0 +1,8448 @@
+// RETOOR - Nov 28 2024
+// MIT License
+// ===========
+
+// Copyright (c) 2024 Retoor
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#ifndef RLIB_H
+#define RLIB_H
+// BEGIN OF RLIB
+
+/*
+ * Line below will be filtered by rmerge
+<script language="Javva script" type="woeiii" src="Pony.html" after-tag="after
+tag" />
+*/
+
+#ifndef RTYPES_H
+#define RTYPES_H
+#ifdef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE_TEMP _POSIX_C_SOURCE
+#undef _POSIX_C_SOURCE
+#endif
+#ifndef _POSIX_C_SOURCE
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200112L
+#endif
+#include <stdbool.h>
+#include <stdint.h> // uint
+#include <string.h>
+#include <sys/types.h> // ulong
+#ifndef ulonglong
+#define ulonglong unsigned long long
+#endif
+#ifndef uint
+typedef unsigned int uint;
+#endif
+#ifndef byte
+typedef unsigned char byte;
+#endif
+#ifdef _POSIX_C_SOURCE_TEMP
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE _POSIX_C_SOURCE_TEMP
+#undef _POSIX_C_SOURCE_TEMP
+#else
+#undef _POSIX_C_SOURCE
+#endif
+#endif
+
+#ifndef NSOCK_H
+#define NSOCK_H
+#ifndef RMALLOC_H
+#define RMALLOC_H
+#ifndef RMALLOC_OVERRIDE
+#define RMALLOC_OVERRIDE 1
+#endif
+#ifdef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE_TEMP _POSIX_C_SOURCE
+#undef _POSIX_C_SOURCE
+#endif
+#ifndef _POSIX_C_SOURCE
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200112L
+#endif
+#ifndef ulonglong
+#define ulonglong unsigned long long
+#endif
+#include <locale.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef RTEMP_H
+#define RTEMP_H
+#include <pthread.h>
+#ifndef RTEMPC_SLOT_COUNT
+#define RTEMPC_SLOT_COUNT 20
+#endif
+#ifndef RTEMPC_SLOT_SIZE
+#define RTEMPC_SLOT_SIZE 1024 * 64 * 128
+#endif
+
+bool _rtempc_initialized = 0;
+pthread_mutex_t _rtempc_thread_lock;
+bool rtempc_use_mutex = true;
+byte _current_rtempc_slot = 1;
+char _rtempc_buffer[RTEMPC_SLOT_COUNT][RTEMPC_SLOT_SIZE];
+char *rtempc(char *data) {
+
+    if (rtempc_use_mutex) {
+        if (!_rtempc_initialized) {
+            _rtempc_initialized = true;
+            pthread_mutex_init(&_rtempc_thread_lock, NULL);
+        }
+
+        pthread_mutex_lock(&_rtempc_thread_lock);
+    }
+
+    uint current_rtempc_slot = _current_rtempc_slot;
+    _rtempc_buffer[current_rtempc_slot][0] = 0;
+    strcpy(_rtempc_buffer[current_rtempc_slot], data);
+    _current_rtempc_slot++;
+    if (_current_rtempc_slot == RTEMPC_SLOT_COUNT) {
+        _current_rtempc_slot = 0;
+    }
+    if (rtempc_use_mutex)
+        pthread_mutex_unlock(&_rtempc_thread_lock);
+    return _rtempc_buffer[current_rtempc_slot];
+}
+
+#define sstring(_pname, _psize)                                                                                                            \
+    static char _##_pname[_psize];                                                                                                         \
+    _##_pname[0] = 0;                                                                                                                      \
+    char *_pname = _##_pname;
+
+#define string(_pname, _psize)                                                                                                             \
+    char _##_pname[_psize];                                                                                                                \
+    _##_pname[0] = 0;                                                                                                                      \
+    char *_pname = _##_pname;
+
+#define sreset(_pname, _psize) _pname = _##_pname;
+
+#define sbuf(val) rtempc(val)
+#endif
+#ifdef _POSIX_C_SOURCE_TEMP
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE _POSIX_C_SOURCE_TEMP
+#undef _POSIX_C_SOURCE_TEMP
+#else
+#undef _POSIX_C_SOURCE
+#endif
+ulonglong rmalloc_count = 0;
+ulonglong rmalloc_alloc_count = 0;
+ulonglong rmalloc_free_count = 0;
+ulonglong rmalloc_total_bytes_allocated = 0;
+
+void *_rmalloc_prev_realloc_obj = NULL;
+size_t _rmalloc_prev_realloc_obj_size = 0;
+
+void *rmalloc(size_t size) {
+    void *result;
+    while (!(result = malloc(size))) {
+        fprintf(stderr, "Warning: malloc failed, trying again.\n");
+    }
+    rmalloc_count++;
+    rmalloc_alloc_count++;
+    rmalloc_total_bytes_allocated += size;
+    return result;
+}
+void *rcalloc(size_t count, size_t size) {
+    void *result;
+    while (!(result = calloc(count, size))) {
+        fprintf(stderr, "Warning: calloc failed, trying again.\n");
+    }
+    rmalloc_alloc_count++;
+    rmalloc_count++;
+    rmalloc_total_bytes_allocated += count * size;
+    return result;
+}
+void *rrealloc(void *obj, size_t size) {
+    if (!obj) {
+        rmalloc_count++;
+    }
+
+    rmalloc_alloc_count++;
+    if (obj == _rmalloc_prev_realloc_obj) {
+        rmalloc_total_bytes_allocated += size - _rmalloc_prev_realloc_obj_size;
+        _rmalloc_prev_realloc_obj_size = size - _rmalloc_prev_realloc_obj_size;
+
+    } else {
+        _rmalloc_prev_realloc_obj_size = size;
+    }
+    void *result;
+    while (!(result = realloc(obj, size))) {
+        fprintf(stderr, "Warning: realloc failed, trying again.\n");
+    }
+    _rmalloc_prev_realloc_obj = result;
+
+    return result;
+}
+
+char *rstrdup(const char *s) {
+    if (!s)
+        return NULL;
+
+    char *result;
+    size_t size = strlen(s) + 1;
+
+    result = rmalloc(size);
+    memcpy(result, s, size);
+    rmalloc_total_bytes_allocated += size;
+    return result;
+}
+void *rfree(void *obj) {
+    rmalloc_count--;
+    rmalloc_free_count++;
+    free(obj);
+    return NULL;
+}
+
+#if RMALLOC_OVERRIDE
+#define malloc rmalloc
+#define calloc rcalloc
+#define realloc rrealloc
+#define free rfree
+#define strdup rstrdup
+#endif
+
+char *rmalloc_lld_format(ulonglong num) {
+
+    char res[100];
+    res[0] = 0;
+    sprintf(res, "%'lld", num);
+    char *resp = res;
+    while (*resp) {
+        if (*resp == ',')
+            *resp = '.';
+        resp++;
+    }
+    return sbuf(res);
+}
+
+char *rmalloc_bytes_format(int factor, ulonglong num) {
+    char *sizes[] = {"B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"};
+    if (num > 1024) {
+        return rmalloc_bytes_format(factor + 1, num / 1024);
+    }
+    char res[100];
+    sprintf(res, "%s %s", rmalloc_lld_format(num), sizes[factor]);
+    return sbuf(res);
+}
+
+char *rmalloc_stats() {
+    static char res[200];
+    res[0] = 0;
+    // int original_locale = localeconv();
+    setlocale(LC_NUMERIC, "en_US.UTF-8");
+    sprintf(res, "Memory usage: %s, %s (re)allocated, %s unqiue free'd, %s in use.", rmalloc_bytes_format(0, rmalloc_total_bytes_allocated),
+            rmalloc_lld_format(rmalloc_alloc_count), rmalloc_lld_format(rmalloc_free_count),
+
+            rmalloc_lld_format(rmalloc_count));
+    // setlocale(LC_NUMERIC, original_locale);
+
+    setlocale(LC_NUMERIC, "");
+    return res;
+}
+
+#endif
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#ifndef RLIB_RIO
+#define RLIB_RIO
+#include <dirent.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/dir.h>
+#include <sys/select.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#ifndef RSTRING_LIST_H
+#define RSTRING_LIST_H
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct rstring_list_t {
+    unsigned int size;
+    unsigned int count;
+    char **strings;
+} rstring_list_t;
+
+rstring_list_t *rstring_list_new() {
+    rstring_list_t *rsl = (rstring_list_t *)malloc(sizeof(rstring_list_t));
+    memset(rsl, 0, sizeof(rstring_list_t));
+    return rsl;
+}
+
+void rstring_list_free(rstring_list_t *rsl) {
+    for (unsigned int i = 0; i < rsl->size; i++) {
+        free(rsl->strings[i]);
+    }
+    if (rsl->strings)
+        free(rsl->strings);
+    free(rsl);
+    rsl = NULL;
+}
+
+void rstring_list_add(rstring_list_t *rsl, char *str) {
+    if (rsl->count == rsl->size) {
+        rsl->size++;
+
+        rsl->strings = (char **)realloc(rsl->strings, sizeof(char *) * rsl->size);
+    }
+    rsl->strings[rsl->count] = strdup(str);
+    rsl->count++;
+}
+bool rstring_list_contains(rstring_list_t *rsl, char *str) {
+    for (unsigned int i = 0; i < rsl->count; i++) {
+        if (!strcmp(rsl->strings[i], str))
+            return true;
+    }
+    return false;
+}
+
+#endif
+
+bool rfile_exists(char *path) {
+    struct stat s;
+    return !stat(path, &s);
+}
+
+void rjoin_path(char *p1, char *p2, char *output) {
+    output[0] = 0;
+    strcpy(output, p1);
+
+    if (output[strlen(output) - 1] != '/') {
+        char slash[] = "/";
+        strcat(output, slash);
+    }
+    if (p2[0] == '/') {
+        p2++;
+    }
+    strcat(output, p2);
+}
+
+int risprivatedir(const char *path) {
+    struct stat statbuf;
+
+    if (stat(path, &statbuf) != 0) {
+        perror("stat");
+        return -1;
+    }
+
+    if (!S_ISDIR(statbuf.st_mode)) {
+        return -2;
+    }
+
+    if ((statbuf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) == S_IRWXU) {
+        return 1; // Private (owner has all permissions, others have none)
+    }
+
+    return 0;
+}
+bool risdir(const char *path) { return !risprivatedir(path); }
+
+void rforfile(char *path, void callback(char *)) {
+    if (!rfile_exists(path))
+        return;
+    DIR *dir = opendir(path);
+    struct dirent *d;
+    while ((d = readdir(dir)) != NULL) {
+        if (!d)
+            break;
+
+        if ((d->d_name[0] == '.' && strlen(d->d_name) == 1) || d->d_name[1] == '.') {
+            continue;
+        }
+        char full_path[4096];
+        rjoin_path(path, d->d_name, full_path);
+
+        if (risdir(full_path)) {
+            callback(full_path);
+            rforfile(full_path, callback);
+        } else {
+            callback(full_path);
+        }
+    }
+    closedir(dir);
+}
+
+bool rfd_wait(int fd, int ms) {
+
+    fd_set read_fds;
+    struct timeval timeout;
+
+    FD_ZERO(&read_fds);
+    FD_SET(fd, &read_fds);
+
+    timeout.tv_sec = 0;
+    timeout.tv_usec = 1000 * ms;
+
+    int ret = select(fd + 1, &read_fds, NULL, NULL, &timeout);
+    return ret > 0 && FD_ISSET(fd, &read_fds);
+}
+
+bool rfd_wait_forever(int fd) {
+    while ((!rfd_wait(fd, 10))) {
+    }
+    return true;
+}
+
+size_t rfile_size(char *path) {
+    struct stat s;
+    stat(path, &s);
+    return s.st_size;
+}
+
+size_t rfile_readb(char *path, void *data, size_t size) {
+    FILE *fd = fopen(path, "r");
+    if (!fd) {
+        return 0;
+    }
+    size_t bytes_read = fread(data, sizeof(char), size, fd);
+
+    fclose(fd);
+    ((char *)data)[bytes_read] = 0;
+    return bytes_read;
+}
+
+#endif
+
+int *nsock_socks = NULL;
+int *nsock_readable = NULL;
+void **nsock_data = NULL;
+int nsock_server_fd = 0;
+int nsock_max_socket_fd = 0;
+
+typedef enum nsock_type_t { NSOCK_NONE = 0, NSOCK_SERVER, NSOCK_CLIENT, NSOCK_UPSTREAM } nsock_type_t;
+
+typedef struct nsock_it {
+    int fd;
+    int *upstreams;
+    bool connected;
+    bool downstream;
+    unsigned int upstream_count;
+    nsock_type_t type;
+} nsock_t;
+
+nsock_t **nsocks = NULL;
+int nsocks_count = 0;
+
+void (*nsock_on_connect)(int fd) = NULL;
+void (*nsock_on_data)(int fd) = NULL;
+void (*nsock_on_close)(int fd) = NULL;
+void nsock_on_before_data(int fd);
+
+nsock_t *nsock_get(int fd) {
+    if (nsock_socks[fd] == 0) {
+        return NULL;
+    }
+    if (fd >= nsocks_count || nsocks[fd] == NULL) {
+        if (fd >= nsocks_count) {
+            nsocks_count = fd + 1;
+            nsocks = (nsock_t **)realloc(nsocks, sizeof(nsock_t *) * sizeof(nsock_t) * (nsocks_count));
+            nsocks[fd] = (nsock_t *)calloc(1, sizeof(nsock_t));
+        }
+        nsocks[fd]->upstreams = NULL;
+        nsocks[fd]->fd = fd;
+        nsocks[fd]->connected = false;
+        nsocks[fd]->downstream = false;
+        nsocks[fd]->upstream_count = 0;
+        nsocks[fd]->type = NSOCK_CLIENT;
+        return nsocks[fd];
+    }
+    return nsocks[fd];
+}
+
+void nsock_close(int fd) {
+    if (nsock_on_close)
+        nsock_on_close(fd);
+    nsock_t *sock = nsock_get(fd);
+    if (sock) {
+        for (unsigned int i = 0; i < sock->upstream_count; i++) {
+            nsock_close(sock->upstreams[i]);
+            sock->upstreams[i] = 0;
+        }
+        if (sock->upstream_count) {
+            free(sock->upstreams);
+        }
+        sock->upstream_count = 0;
+        sock->connected = false;
+    }
+    nsock_socks[fd] = 0;
+    close(fd);
+}
+
+nsock_t *nsock_create(int fd, nsock_type_t type) {
+    if (fd <= 0)
+        return NULL;
+    nsock_socks[fd] = fd;
+    nsock_t *sock = nsock_get(fd);
+    sock->connected = true;
+    sock->downstream = false;
+    sock->type = type;
+    return sock;
+}
+
+int *nsock_init(int socket_count) {
+    if (nsock_socks) {
+        return nsock_socks;
+    }
+    nsock_socks = (int *)calloc(1, sizeof(int) * sizeof(int *) * socket_count + 1);
+    if (nsock_data) {
+        free(nsock_data);
+        nsock_data = NULL;
+    }
+    nsock_data = (void **)malloc(sizeof(void **) * socket_count + 1);
+    nsock_socks[socket_count] = -1;
+    return nsock_socks;
+}
+
+void nsock_free() {
+    if (nsock_socks)
+        free(nsock_socks);
+    if (nsock_readable)
+        free(nsock_readable);
+    nsock_server_fd = 0;
+    nsock_max_socket_fd = 0;
+    if (nsock_data) {
+        exit(1);
+    }
+}
+
+void nsock_add_upstream(int source, int target, bool downstream) {
+    if (!nsock_socks[target])
+        return;
+    if (!nsock_socks[source])
+        return;
+    nsock_t *sock = nsock_get(source);
+    nsock_t *sock_target = nsock_get(target);
+    sock_target->type = NSOCK_UPSTREAM;
+    sock->upstreams = (int *)realloc(sock->upstreams, sizeof(int) * (sock->upstream_count + 1));
+    sock->downstream = downstream;
+    sock->upstreams[sock->upstream_count] = target;
+    sock->upstream_count++;
+}
+
+void *nsock_get_data(int socket) { return nsock_data[socket]; }
+void nsock_set_data(int socket, void *data) { nsock_data[socket] = data; }
+
+int nsock_connect(const char *host, unsigned int port) {
+    char port_str[10] = {0};
+    sprintf(port_str, "%d", port);
+    int status;
+    int socket_fd = 0;
+    struct addrinfo hints;
+    struct addrinfo *res;
+    struct addrinfo *p;
+    if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+        return false;
+    }
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    if ((status = getaddrinfo(host, port_str, &hints, &res)) != 0) {
+        return 0;
+    }
+    for (p = res; p != NULL; p = p->ai_next) {
+        if ((socket_fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
+            continue;
+        }
+        if (connect(socket_fd, p->ai_addr, p->ai_addrlen) == -1) {
+            close(socket_fd);
+            continue;
+        }
+        break;
+    }
+    if (p == NULL) {
+        freeaddrinfo(res);
+        return 0;
+    }
+    freeaddrinfo(res);
+    if (socket_fd) {
+        if (nsock_socks == NULL) {
+            nsock_init(2048);
+        }
+        nsock_socks[socket_fd] = socket_fd;
+        nsock_t *sock = nsock_create(socket_fd, NSOCK_CLIENT);
+        sock->connected = true;
+    }
+    return socket_fd;
+}
+
+void nsock_listen(int port) {
+    int server_fd;
+    struct sockaddr_in address;
+    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
+        perror("Socket failed");
+        exit(EXIT_FAILURE);
+    }
+    int opt = 1;
+    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
+        perror("setsockopt failed");
+        close(server_fd);
+        exit(EXIT_FAILURE);
+    }
+    address.sin_family = AF_INET;
+    address.sin_addr.s_addr = INADDR_ANY;
+    address.sin_port = htons(port);
+    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
+        perror("Bind failed");
+        close(server_fd);
+        exit(EXIT_FAILURE);
+    }
+    if (listen(server_fd, 8096) < 0) {
+        perror("Listen failed");
+        close(server_fd);
+        exit(EXIT_FAILURE);
+    }
+    nsock_server_fd = server_fd;
+}
+
+int *nsock_select(suseconds_t timeout) {
+    struct timeval tv;
+    tv.tv_sec = 0;
+    tv.tv_usec = timeout;
+    int server_fd = nsock_server_fd;
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(server_fd, &rfds);
+    int *socks = nsock_socks;
+    fd_set efds;
+    FD_ZERO(&efds);
+    nsock_max_socket_fd = server_fd;
+    for (int i = 0; socks[i] != -1; i++) {
+        if (i == server_fd)
+            continue;
+        ;
+        if (!socks[i])
+            continue;
+        if (socks[i] > nsock_max_socket_fd) {
+            nsock_max_socket_fd = socks[i];
+        }
+        FD_SET(socks[i], &rfds);
+        FD_SET(socks[i], &efds);
+    }
+    int activity = select(nsock_max_socket_fd + 1, &rfds, NULL, &efds, timeout == 0 ? NULL : &tv);
+    if ((activity < 0) && (errno != EINTR)) {
+        perror("Select error\n");
+        return NULL;
+    } else if (activity == 0) {
+        return NULL;
+    }
+    if (FD_ISSET(server_fd, &rfds)) {
+        struct sockaddr_in address;
+        int addrlen = sizeof(address);
+        address.sin_family = AF_INET;
+        address.sin_addr.s_addr = INADDR_ANY;
+        int new_socket = 0;
+        if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
+            perror("Accept failed");
+        } else {
+            nsock_socks[new_socket] = new_socket;
+            nsock_create(new_socket, NSOCK_CLIENT);
+            if (nsock_on_connect)
+                nsock_on_connect(new_socket);
+            if (new_socket > nsock_max_socket_fd)
+                nsock_max_socket_fd = new_socket;
+        }
+    }
+    if (nsock_readable) {
+        free(nsock_readable);
+    }
+    nsock_readable = (int *)calloc(1, sizeof(int *) + sizeof(int) * (nsock_max_socket_fd + 2));
+    nsock_readable[nsock_max_socket_fd + 1] = -1;
+    nsock_readable[0] = 0;
+    int readable_count = 0;
+    for (int i = 0; i < nsock_max_socket_fd + 1; i++) {
+        nsock_t *sock = nsock_get(i);
+        if (!sock)
+            continue;
+        if (FD_ISSET(i, &efds)) {
+            nsock_close(nsock_socks[i]);
+            nsock_socks[i] = 0;
+            nsock_readable[i] = 0;
+        } else if (FD_ISSET(i, &rfds) && i != server_fd) {
+            nsock_readable[i] = i;
+            readable_count++;
+            nsock_on_before_data(i);
+        } else {
+            nsock_readable[i] = 0;
+            sock->connected = false;
+        }
+    }
+    return nsock_readable;
+}
+
+unsigned char *nsock_read(int fd, int length) {
+    if (!nsock_socks[fd])
+        return NULL;
+    unsigned char *buffer = (unsigned char *)malloc(length + 1);
+    int bytes_read = read(fd, buffer, length);
+    if (bytes_read <= 0) {
+        nsock_close(fd);
+        return NULL;
+    }
+    buffer[bytes_read] = 0;
+    return buffer;
+}
+
+unsigned char *nsock_read_all(int fd, int length) {
+    if (!nsock_socks[fd])
+        return NULL;
+    unsigned char *buffer = (unsigned char *)malloc(length + 1);
+    int bytes_read = 0;
+    while (bytes_read < length) {
+        int bytes_chunk = read(fd, buffer + bytes_read, length - bytes_read);
+        if (bytes_chunk <= 0) {
+            nsock_close(fd);
+            return NULL;
+        }
+        bytes_read += bytes_chunk;
+    }
+    buffer[bytes_read] = 0;
+    return buffer;
+}
+
+int nsock_write_all(int fd, unsigned char *data, int length) {
+    if (!nsock_socks[fd])
+        return 0;
+    int bytes_written = 0;
+    while (bytes_written < length) {
+        int bytes_chunk = write(fd, data + bytes_written, length - bytes_written);
+        if (bytes_chunk <= 0) {
+            nsock_close(fd);
+            return 0;
+        }
+        bytes_written += bytes_chunk;
+    }
+    return bytes_written;
+}
+
+int nsock_execute_upstream(int source, size_t buffer_size) {
+    int result = 0;
+    nsock_t *sock = nsock_get(source);
+    unsigned char data[buffer_size];
+    memset(data, 0, buffer_size);
+    int bytes_read = read(source, data, buffer_size);
+    if (bytes_read <= 0) {
+        nsock_close(source);
+        return 0;
+    }
+    bool downstreamed = false;
+    for (unsigned int i = 0; i < sock->upstream_count; i++) {
+        if (!nsock_socks[sock->upstreams[i]])
+            continue;
+        int bytes_sent = nsock_write_all(sock->upstreams[i], data, bytes_read);
+        if (bytes_sent <= 0) {
+            nsock_close(sock->upstreams[i]);
+            continue;
+        }
+        if (sock->downstream && downstreamed == false) {
+            downstreamed = true;
+            unsigned char data[4096];
+            memset(data, 0, 4096);
+            int bytes_read = read(sock->upstreams[i], data, 4096);
+            if (bytes_read <= 0) {
+                nsock_close(source);
+                return 0;
+            }
+            int bytes_sent = nsock_write_all(sock->fd, data, bytes_read);
+            if (bytes_sent <= 0) {
+                nsock_close(sock->upstreams[i]);
+                return 0;
+            }
+        }
+        result++;
+    }
+    return result;
+}
+
+void nsock_on_before_data(int fd) {
+    if (!nsock_socks[fd])
+        return;
+    nsock_t *sock = nsock_get(fd);
+    if (sock->upstream_count) {
+        int upstreamed_to_count = nsock_execute_upstream(fd, 4096);
+        if (!upstreamed_to_count) {
+            nsock_close(fd);
+        }
+        return;
+    } else if (sock->type == NSOCK_UPSTREAM) {
+        while (rfd_wait(sock->fd, 0)) {
+            unsigned char *data = nsock_read(fd, 4096);
+            (void)data;
+        }
+    }
+    if (nsock_on_data)
+        nsock_on_data(fd);
+}
+
+void nsock(int port, void (*on_connect)(int fd), void (*on_data)(int fd), void (*on_close)(int fd)) {
+    nsock_init(2048);
+    nsock_listen(port);
+    nsock_on_connect = on_connect;
+    nsock_on_data = on_data;
+    nsock_on_close = on_close;
+    int serve_in_terminal = nsock_on_connect == NULL && nsock_on_data == NULL && nsock_on_close == NULL;
+    while (1) {
+        int *readable = nsock_select(0);
+        if (!serve_in_terminal)
+            continue;
+        if (!readable)
+            continue;
+        for (int i = 0; readable[i] != -1; i++) {
+            if (!readable[i])
+                continue;
+            char buffer[1024] = {0};
+            int bytes_read = read(readable[i], buffer, 1);
+            buffer[bytes_read] = 0;
+            if (bytes_read <= 0) {
+                nsock_close(readable[i]);
+                continue;
+            }
+            if (write(readable[i], buffer, bytes_read) <= 0) {
+                nsock_close(readable[i]);
+                continue;
+            }
+        }
+    }
+}
+#endif
+
+#ifndef UUID_H
+#define UUID_H
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+typedef struct {
+    unsigned char bytes[16];
+} UUID;
+
+void generate_random_bytes(unsigned char *bytes, size_t len) {
+    for (size_t i = 0; i < len; i++) {
+        bytes[i] = rand() % 256;
+    }
+}
+
+UUID generate_uuid4(void) {
+    UUID uuid;
+
+    generate_random_bytes(uuid.bytes, 16);
+
+    uuid.bytes[6] &= 0x0f;
+    uuid.bytes[6] |= 0x40;
+
+    uuid.bytes[8] &= 0x3f;
+    uuid.bytes[8] |= 0x80;
+
+    return uuid;
+}
+
+void uuid_to_string(UUID uuid, char *str) {
+    sprintf(str, "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", uuid.bytes[0], uuid.bytes[1], uuid.bytes[2],
+            uuid.bytes[3], uuid.bytes[4], uuid.bytes[5], uuid.bytes[6], uuid.bytes[7], uuid.bytes[8], uuid.bytes[9], uuid.bytes[10],
+            uuid.bytes[11], uuid.bytes[12], uuid.bytes[13], uuid.bytes[14], uuid.bytes[15]);
+}
+
+char *uuid4() {
+    srand(time(NULL));
+    UUID uuid = generate_uuid4();
+    char str[37];
+    uuid_to_string(uuid, str);
+    return sbuf(str);
+}
+#endif
+#ifndef RNET_H
+#define RNET_H
+#ifdef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE_TEMP _POSIX_C_SOURCE
+#undef _POSIX_C_SOURCE
+#endif
+#ifndef _POSIX_C_SOURCE
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200112L
+#endif
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/select.h>
+
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include <unistd.h>
+#ifdef _POSIX_C_SOURCE_TEMP
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE _POSIX_C_SOURCE_TEMP
+#undef _POSIX_C_SOURCE_TEMP
+#else
+#undef _POSIX_C_SOURCE
+#endif
+#define NET_SOCKET_MAX_CONNECTIONS 50000
+
+typedef struct rnet_socket_t {
+    int fd;
+    char name[50];
+    void *data;
+    size_t bytes_received;
+    size_t bytes_sent;
+    bool connected;
+    void (*on_read)(struct rnet_socket_t *);
+    void (*on_close)(struct rnet_socket_t *);
+    void (*on_connect)(struct rnet_socket_t *);
+} rnet_socket_t;
+
+typedef struct rnet_select_result_t {
+    int server_fd;
+    rnet_socket_t **sockets;
+    unsigned int socket_count;
+} rnet_select_result_t;
+
+typedef struct rnet_server_t {
+    int socket_fd;
+    rnet_socket_t **sockets;
+    unsigned int socket_count;
+    unsigned int port;
+    unsigned int backlog;
+    rnet_select_result_t *select_result;
+    int max_fd;
+    void (*on_connect)(rnet_socket_t *socket);
+    void (*on_close)(rnet_socket_t *socket);
+    void (*on_read)(rnet_socket_t *socket);
+} rnet_server_t;
+
+void rnet_select_result_free(rnet_select_result_t *result);
+int net_socket_accept(int server_fd);
+int net_socket_connect(const char *, unsigned int);
+int net_socket_init();
+rnet_server_t *net_socket_serve(unsigned int port, unsigned int backlog);
+rnet_select_result_t *net_socket_select(rnet_server_t *server);
+rnet_socket_t *net_socket_wait(rnet_socket_t *socket_fd);
+bool net_set_non_blocking(int sock);
+bool net_socket_bind(int sock, unsigned int port);
+bool net_socket_listen(int sock, unsigned int backlog);
+char *net_socket_name(int sock);
+size_t net_socket_write(rnet_socket_t *, unsigned char *, size_t);
+rnet_socket_t *get_net_socket_by_fd(int);
+unsigned char *net_socket_read(rnet_socket_t *, unsigned int buff_size);
+void _net_socket_close(int sock);
+void net_socket_close(rnet_socket_t *sock);
+
+rnet_server_t *rnet_server_new(int socket_fd, unsigned int port, unsigned int backlog) {
+    rnet_server_t *server = malloc(sizeof(rnet_server_t));
+    server->socket_fd = socket_fd;
+    server->sockets = NULL;
+    server->socket_count = 0;
+    server->port = port;
+    server->backlog = backlog;
+    server->max_fd = -1;
+    server->select_result = NULL;
+    server->on_connect = NULL;
+    server->on_close = NULL;
+    server->on_read = NULL;
+    return server;
+}
+
+rnet_server_t *rnet_server_add_socket(rnet_server_t *server, rnet_socket_t *sock) {
+    server->sockets = realloc(server->sockets, sizeof(rnet_socket_t *) * (server->socket_count + 1));
+    server->sockets[server->socket_count] = sock;
+    server->socket_count++;
+    sock->on_read = server->on_read;
+    sock->on_connect = server->on_connect;
+    sock->on_close = server->on_close;
+    sock->connected = true;
+    return server;
+}
+
+rnet_socket_t sockets[NET_SOCKET_MAX_CONNECTIONS] = {0};
+unsigned long sockets_connected = 0;
+int net_socket_max_fd = 0;
+unsigned long sockets_total = 0;
+unsigned long sockets_disconnected = 0;
+unsigned long sockets_concurrent_record = 0;
+unsigned long sockets_errors = 0;
+
+bool net_set_non_blocking(int sock) {
+    int flags = fcntl(sock, F_GETFL, 0);
+    if (flags < 0) {
+        perror("fcntl");
+        return false;
+    }
+
+    if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
+        perror("fcntl");
+        return false;
+    }
+
+    return true;
+}
+
+int net_socket_init() {
+    int socket_fd = -1;
+    memset(sockets, 0, sizeof(sockets));
+    int opt = 1;
+    if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
+        perror("Socket failed.\n");
+        return false;
+    }
+    if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) {
+        perror("Setsockopt failed.\n");
+        close(socket_fd);
+        return false;
+    }
+    net_set_non_blocking(socket_fd);
+    return socket_fd;
+}
+
+char *net_socket_name(int fd) {
+    rnet_socket_t *rnet_socket = get_net_socket_by_fd(fd);
+    if (rnet_socket) {
+        return rnet_socket->name;
+        ;
+    }
+
+    // If socket disconnected or is no client from server
+    return NULL;
+}
+
+bool net_socket_bind(int socket_fd, unsigned int port) {
+    struct sockaddr_in address;
+
+    address.sin_family = AF_INET;         // IPv4
+    address.sin_addr.s_addr = INADDR_ANY; // Bind to any available address
+    address.sin_port = htons(port);       // Convert port to network byte order
+
+    if (bind(socket_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
+        perror("Bind failed");
+        close(socket_fd);
+        return false;
+    }
+    return true;
+}
+
+int net_socket_connect(const char *host, unsigned int port) {
+    char port_str[10] = {0};
+    sprintf(port_str, "%d", port);
+    int status;
+    int socket_fd = -1;
+    struct addrinfo hints;
+    struct addrinfo *res;
+    struct addrinfo *p;
+    if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+        return false;
+    }
+
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+
+    if ((status = getaddrinfo(host, port_str, &hints, &res)) != 0) {
+        return -1;
+    }
+
+    for (p = res; p != NULL; p = p->ai_next) {
+        if ((socket_fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
+            continue;
+        }
+
+        if (connect(socket_fd, p->ai_addr, p->ai_addrlen) == -1) {
+            close(socket_fd);
+            continue;
+        }
+
+        break;
+    }
+
+    if (p == NULL) {
+        freeaddrinfo(res);
+        return -1;
+    }
+
+    freeaddrinfo(res);
+    return socket_fd;
+}
+
+bool net_socket_listen(int socket_fd, unsigned int backlog) {
+    if (listen(socket_fd, backlog) < 0) { // '3' is the backlog size
+        perror("Listen failed");
+        close(socket_fd);
+        return false;
+    }
+    return true;
+}
+
+rnet_server_t *net_socket_serve(unsigned int port, unsigned int backlog) {
+    signal(SIGPIPE, SIG_IGN);
+    int socket_fd = net_socket_init();
+    net_socket_bind(socket_fd, port);
+    net_socket_listen(socket_fd, backlog);
+    return rnet_server_new(socket_fd, port, backlog);
+}
+
+int net_socket_accept(int net_socket_server_fd) {
+    struct sockaddr_in address;
+    int addrlen = sizeof(address);
+    int new_socket = -1;
+    if ((new_socket = accept(net_socket_server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
+        close(new_socket);
+        return -1;
+    } else {
+
+        return new_socket;
+    }
+}
+/*
+static void net_socket_stats(WrenVM *vm)
+{
+
+    wrenSetSlotNewList(vm, 0);
+
+    wrenSetSlotString(vm, 1, "sockets_total");
+    wrenInsertInList(vm, 0, -1, 1);
+
+    wrenSetSlotDouble(vm, 1, (double)sockets_total);
+    wrenInsertInList(vm, 0, -1, 1);
+
+    wrenSetSlotString(vm, 1, "sockets_concurrent_record");
+    wrenInsertInList(vm, 0, -1, 1);
+
+    wrenSetSlotDouble(vm, 1, (double)sockets_concurrent_record);
+    wrenInsertInList(vm, 0, -1, 1);
+
+    wrenSetSlotString(vm, 1, "sockets_connected");
+    wrenInsertInList(vm, 0, -1, 1);
+
+    wrenSetSlotDouble(vm, 1, (double)sockets_connected);
+    wrenInsertInList(vm, 0, -1, 1);
+
+    wrenSetSlotString(vm, 1, "sockets_disconnected");
+    wrenInsertInList(vm, 0, -1, 1);
+
+    wrenSetSlotDouble(vm, 1, (double)sockets_disconnected);
+    wrenInsertInList(vm, 0, -1, 1);
+}*/
+
+size_t net_socket_write(rnet_socket_t *sock, unsigned char *message, size_t size) {
+    ssize_t sent_total = 0;
+    ssize_t sent = 0;
+    ssize_t to_send = size;
+    while ((sent = send(sock->fd, message, to_send, 0))) {
+        if (sent == -1) {
+            sockets_errors++;
+            net_socket_close(sock);
+            break;
+        }
+        if (sent == 0) {
+            printf("EDGE CASE?\n");
+            exit(1);
+            sockets_errors++;
+            net_socket_close(sock);
+            break;
+        }
+        sent_total += sent;
+        if (sent_total == to_send)
+            break;
+    }
+    return sent_total;
+}
+
+unsigned char *net_socket_read(rnet_socket_t *sock, unsigned int buff_size) {
+    if (buff_size > 1024 * 1024 + 1) {
+        perror("Buffer too big. Maximum is 1024*1024.\n");
+        exit(1);
+    }
+    static unsigned char buffer[1024 * 1024];
+    buffer[0] = 0;
+    ssize_t received = recv(sock->fd, buffer, buff_size, 0);
+    if (received <= 0) {
+        buffer[0] = 0;
+        net_socket_close(sock);
+        if (received < 0) {
+            sockets_errors++;
+            return NULL;
+        }
+    }
+    buffer[received + 1] = 0;
+    sock->bytes_received = received;
+    return buffer;
+}
+
+rnet_socket_t *net_socket_wait(rnet_socket_t *sock) {
+    if (!sock)
+        return NULL;
+    if (sock->fd == -1)
+        return NULL;
+    fd_set read_fds;
+    FD_ZERO(&read_fds);
+    FD_SET(sock->fd, &read_fds);
+
+    int max_socket_fd = sock->fd;
+    int activity = select(max_socket_fd + 1, &read_fds, NULL, NULL, NULL);
+    if ((activity < 0) && (errno != EINTR)) {
+        // perror("Select error");
+        net_socket_close(sock);
+        return NULL;
+    }
+    if (FD_ISSET(sock->fd, &read_fds)) {
+        return sock;
+    }
+
+    return NULL;
+}
+
+void rnet_safe_str(char *str, size_t length) {
+    if (!str || !length || !*str)
+        return;
+    for (unsigned int i = 0; i < length; i++) {
+        if (str[i] < 32 || str[i] > 126)
+            if (str[i] != 0)
+                str[i] = '.';
+    }
+    str[length] = 0;
+}
+
+rnet_select_result_t *rnet_new_socket_select_result(int socket_fd) {
+    rnet_select_result_t *result = (rnet_select_result_t *)malloc(sizeof(rnet_select_result_t));
+    memset(result, 0, sizeof(rnet_select_result_t));
+    result->server_fd = socket_fd;
+    result->socket_count = 0;
+    result->sockets = NULL;
+    return result;
+}
+
+void rnet_select_result_add(rnet_select_result_t *result, rnet_socket_t *sock) {
+    result->sockets = realloc(result->sockets, sizeof(rnet_socket_t *) * (result->socket_count + 1));
+    result->sockets[result->socket_count] = sock;
+    result->socket_count++;
+}
+void rnet_select_result_free(rnet_select_result_t *result) { free(result); }
+rnet_select_result_t *net_socket_select(rnet_server_t *server) {
+    fd_set read_fds;
+    FD_ZERO(&read_fds);
+    FD_SET(server->socket_fd, &read_fds);
+
+    server->max_fd = server->socket_fd;
+    int socket_fd = -1;
+    for (unsigned int i = 0; i < server->socket_count; i++) {
+        socket_fd = server->sockets[i]->fd;
+        if (!server->sockets[i]->connected) {
+            continue;
+        }
+        if (socket_fd > 0) {
+            FD_SET(socket_fd, &read_fds);
+            if (socket_fd > server->max_fd) {
+                server->max_fd = socket_fd;
+            }
+        }
+    }
+    int new_socket = -1;
+    struct sockaddr_in address;
+    int addrlen = sizeof(struct sockaddr_in);
+    int activity = select(server->max_fd + 1, &read_fds, NULL, NULL, NULL);
+    if ((activity < 0) && (errno != EINTR)) {
+        perror("Select error\n");
+        return NULL;
+    }
+    if (FD_ISSET(server->socket_fd, &read_fds)) {
+        if ((new_socket = accept(server->socket_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0) {
+            perror("Accept failed\n");
+            return NULL;
+        }
+
+        // net_set_non_blocking(new_socket);
+        char name[50] = {0};
+        sprintf(name, "fd:%.4d:ip:%12s:port:%.6d", new_socket, inet_ntoa(address.sin_addr), ntohs(address.sin_port));
+        rnet_socket_t *sock_obj = NULL;
+        for (unsigned int i = 0; i < server->socket_count; i++) {
+            if (server->sockets && server->sockets[i]->fd == -1) {
+                sock_obj = server->sockets[i];
+            }
+        }
+        if (!sock_obj) {
+            sock_obj = (rnet_socket_t *)malloc(sizeof(rnet_socket_t));
+            rnet_server_add_socket(server, sock_obj);
+        }
+        sock_obj->fd = new_socket;
+        strcpy(sock_obj->name, name);
+        sockets_connected++;
+        sockets_total++;
+        sockets_concurrent_record = sockets_connected > sockets_concurrent_record ? sockets_connected : sockets_concurrent_record;
+        if (new_socket > net_socket_max_fd) {
+            net_socket_max_fd = new_socket;
+        }
+        sock_obj->connected = true;
+        sock_obj->on_connect(sock_obj);
+    }
+    rnet_select_result_t *result = rnet_new_socket_select_result(server->socket_fd);
+    unsigned int readable_count = 0;
+    for (unsigned int i = 0; i < server->socket_count; i++) {
+        if (server->sockets[i]->fd == -1)
+            continue;
+        if (FD_ISSET(server->sockets[i]->fd, &read_fds)) {
+            rnet_select_result_add(result, server->sockets[i]);
+            readable_count++;
+            if (server->sockets[i]->on_read) {
+                server->sockets[i]->on_read(server->sockets[i]);
+            }
+        }
+    }
+    if (server->select_result) {
+        rnet_select_result_free(server->select_result);
+        server->select_result = NULL;
+    }
+    if (readable_count == 0)
+        rnet_select_result_free(result);
+    return readable_count ? result : NULL;
+}
+
+rnet_socket_t *get_net_socket_by_fd(int sock) {
+    for (int i = 0; i < net_socket_max_fd; i++) {
+        if (sockets[i].fd == sock) {
+            return &sockets[i];
+        }
+    }
+    return NULL;
+}
+
+void _net_socket_close(int sock) {
+    if (sock > 0) {
+        sockets_connected--;
+        sockets_disconnected++;
+        if (sock > 0) {
+            if (close(sock) == -1) {
+                perror("Error closing socket.\n");
+            }
+        }
+    }
+}
+
+void net_socket_close(rnet_socket_t *sock) {
+    sock->connected = false;
+    if (sock->on_close)
+        sock->on_close(sock);
+    _net_socket_close(sock->fd);
+    sock->fd = -1;
+}
+#undef _POSIX_C_SOURCE
+#endif
+
+#include <stdio.h>
+#ifndef RLIB_RARGS_H
+#define RLIB_RARGS_H
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool rargs_isset(int argc, char *argv[], char *key) {
+
+    for (int i = 0; i < argc; i++) {
+        if (!strcmp(argv[i], key)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+char *rargs_get_option_string(int argc, char *argv[], char *key, const char *def) {
+
+    for (int i = 0; i < argc; i++) {
+        if (!strcmp(argv[i], key)) {
+            if (i < argc - 1) {
+                return argv[i + 1];
+            }
+        }
+    }
+    return (char *)def;
+}
+
+int rargs_get_option_int(int argc, char *argv[], char *key, int def) {
+
+    for (int i = 0; i < argc; i++) {
+        if (!strcmp(argv[i], key)) {
+            if (i < argc - 1) {
+                return atoi(argv[i + 1]);
+            }
+        }
+    }
+    return def;
+}
+
+bool rargs_get_option_bool(int argc, char *argv[], char *key, bool def) {
+
+    for (int i = 0; i < argc; i++) {
+        if (!strcmp(argv[i], key)) {
+            if (i < argc - 1) {
+                if (!strcmp(argv[i + 1], "false"))
+                    return false;
+                if (!strcmp(argv[i + 1], "0"))
+                    return false;
+                return true;
+            }
+        }
+    }
+
+    return def;
+}
+#endif
+#ifndef RCAT_H
+#define RCAT_H
+#include <stdio.h>
+#include <stdlib.h>
+
+void rcat(char *filename) {
+    FILE *f = fopen(filename, "rb");
+    if (!f) {
+        printf("rcat: couldn't open \"%s\" for read.\n", filename);
+        return;
+    }
+    unsigned char c;
+    while ((c = fgetc(f)) && !feof(f)) {
+        printf("%c", c);
+    }
+    fclose(f);
+    fflush(stdout);
+}
+
+int rcat_main(int argc, char *argv[]) {
+    if (argc < 2) {
+        printf("Usage: [filename]\n");
+        return 1;
+    }
+    rcat(argv[1]);
+    return 0;
+}
+
+#endif
+
+#ifndef RLIZA_H
+#define RLIZA_H
+#ifndef RBUFFER_H
+#define RBUFFER_H
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+typedef struct rbuffer_t {
+    unsigned char *data;
+    unsigned char *_data;
+    size_t size;
+    size_t pos;
+    bool eof;
+} rbuffer_t;
+
+rbuffer_t *rbuffer_new(unsigned char *data, size_t size);
+void rbuffer_free(rbuffer_t *rfb);
+void rbuffer_reset(rbuffer_t *rfb);
+void rbuffer_write(rbuffer_t *rfb, const unsigned char *data, size_t size);
+size_t rbuffer_push(rbuffer_t *rfb, unsigned char);
+unsigned char rbuffer_pop(rbuffer_t *rfb);
+unsigned char *rbuffer_expect(rbuffer_t *rfb, char *options, char *ignore);
+void rbuffer_set(rbuffer_t *rfb, const unsigned char *data, size_t size);
+
+void rbuffer_set(rbuffer_t *rfb, const unsigned char *data, size_t size) {
+    if (rfb->_data) {
+        free(rfb->_data);
+        rfb->_data = NULL;
+        rfb->data = NULL;
+        rfb->eof = true;
+    }
+    if (size) {
+        rfb->_data = (unsigned char *)malloc(size);
+        memcpy(rfb->_data, data, size);
+        rfb->data = rfb->_data;
+        rfb->eof = false;
+    }
+    rfb->size = size;
+    rfb->pos = 0;
+}
+
+rbuffer_t *rbuffer_new(unsigned char *data, size_t size) {
+    rbuffer_t *rfb = (rbuffer_t *)malloc(sizeof(rbuffer_t));
+    if (size) {
+        rfb->_data = (unsigned char *)malloc(size);
+        memcpy(rfb->_data, data, size);
+        rfb->eof = false;
+    } else {
+        rfb->_data = NULL;
+        rfb->eof = true;
+    }
+    rfb->size = size;
+    rfb->pos = 0;
+    rfb->data = rfb->_data;
+    return rfb;
+}
+void rbuffer_free(rbuffer_t *rfb) {
+    if (rfb->_data)
+        free(rfb->_data);
+    free(rfb);
+}
+
+size_t rbuffer_push(rbuffer_t *rfb, unsigned char c) {
+    if (rfb->pos < rfb->size) {
+        rfb->_data[rfb->pos++] = c;
+        return 1;
+    }
+    rfb->_data = realloc(rfb->_data, rfb->size ? rfb->size + 1 : rfb->size + 2);
+    rfb->_data[rfb->pos++] = c;
+    rfb->size++;
+    return rfb->pos;
+}
+void rbuffer_write(rbuffer_t *rfb, const unsigned char *data, size_t size) {
+    unsigned char *data_ptr = (unsigned char *)data;
+    for (size_t i = 0; i < size; i++) {
+        rbuffer_push(rfb, data_ptr[i]);
+    }
+}
+
+unsigned char rbuffer_peek(rbuffer_t *rfb) {
+    unsigned char result = EOF;
+    if (rfb->pos != rfb->size) {
+        result = rfb->_data[rfb->pos];
+        return result;
+    }
+    rfb->eof = true;
+    return EOF;
+}
+unsigned char rbuffer_pop(rbuffer_t *rfb) {
+    unsigned char result = EOF;
+    if (rfb->pos <= rfb->size) {
+        result = rfb->_data[rfb->pos];
+        rfb->pos++;
+        rfb->data++;
+        if (rfb->pos == rfb->size) {
+            rfb->eof = true;
+        }
+        return result;
+    }
+    rfb->eof = true;
+    return result;
+}
+void rbuffer_reset(rbuffer_t *rfb) {
+    rfb->data = rfb->_data;
+    rfb->pos = 0;
+}
+
+unsigned char ustrncmp(const unsigned char *s1, const unsigned char *s2, size_t n) {
+    return strncmp((char *)s1, (char *)s2, n);
+    while (n && *s1 == *s2) {
+        n--;
+        s1++;
+        s2++;
+    }
+    return *s1 != *s2;
+}
+size_t ustrlen(const unsigned char *s) { return strlen((char *)s); }
+
+unsigned char *rbuffer_to_string(rbuffer_t *rfb) {
+    unsigned char *result = rfb->_data;
+    rfb->_data = NULL;
+    rfb->data = NULL;
+    rbuffer_free(rfb);
+    return result;
+}
+
+unsigned char *rbuffer_match_option(rbuffer_t *rfb, char *options) {
+    char *option = NULL;
+    char options_cpy[1024] = {0};
+    strcpy(options_cpy, options);
+    char *memory = options_cpy;
+    while ((option = strtok_r(option == NULL ? memory : NULL, "|", &memory)) != NULL) {
+
+        size_t option_length = strlen(option);
+        if (option_length > rfb->size - rfb->pos) {
+            continue;
+        }
+        if (!strcmp(option, "\\d") && *rfb->data >= '0' && *rfb->data <= '9') {
+            return rfb->data;
+        }
+        if (rfb->size - rfb->pos >= 5 && !strcmp(option, "\\b") &&
+            ((!ustrncmp(rfb->data, (unsigned char *)"true", 4) || !ustrncmp(rfb->data, (unsigned char *)"false", 5)))) {
+            return rfb->data;
+        }
+        if (!ustrncmp(rfb->data, (unsigned char *)option, option_length)) {
+            return rfb->data;
+        }
+    }
+    return NULL;
+}
+
+unsigned char *rbuffer_expect(rbuffer_t *rfb, char *options, char *ignore) {
+    while (rfb->pos < rfb->size) {
+        if (rbuffer_match_option(rfb, options) != NULL) {
+            return rfb->data;
+        }
+        if (rbuffer_match_option(rfb, ignore)) {
+            printf("SKIP:%s\n", rfb->data);
+            rbuffer_pop(rfb);
+            continue;
+        }
+        break;
+    }
+    return NULL;
+}
+unsigned char *rbuffer_consume(rbuffer_t *rfb, char *options, char *ignore) {
+    unsigned char *result = NULL;
+    if ((result = rbuffer_expect(rfb, options, ignore)) != NULL) {
+        rbuffer_pop(rfb);
+    }
+    return result;
+}
+#endif
+#ifndef RSTRING_H
+#define RSTRING_H
+#ifndef RMATH_H
+#define RMATH_H
+#include <math.h>
+
+#ifndef ceil
+double ceil(double x) {
+    if (x == (double)(long long)x) {
+        return x;
+    } else if (x > 0.0) {
+        return (double)(long long)x + 1.0;
+    } else {
+        return (double)(long long)x;
+    }
+}
+#endif
+
+#ifndef floor
+double floor(double x) {
+    if (x >= 0.0) {
+        return (double)(long long)x;
+    } else {
+        double result = (double)(long long)x;
+        return (result == x) ? result : result - 1.0;
+    }
+}
+#endif
+
+#ifndef modf
+double modf(double x, double *iptr) {
+    double int_part = (x >= 0.0) ? floor(x) : ceil(x);
+    *iptr = int_part;
+    return x - int_part;
+}
+#endif
+#endif
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+char *rstrtimestamp() {
+    time_t current_time;
+    time(&current_time);
+    struct tm *local_time = localtime(&current_time);
+    static char time_string[100];
+    time_string[0] = 0;
+    strftime(time_string, sizeof(time_string), "%Y-%m-%d %H:%M:%S", local_time);
+    return time_string;
+}
+
+ulonglong _r_generate_key_current = 0;
+
+char *_rcat_int_int(int a, int b) {
+    static char res[20];
+    res[0] = 0;
+    sprintf(res, "%d%d", a, b);
+    return res;
+}
+char *_rcat_int_double(int a, double b) {
+    static char res[20];
+    res[0] = 0;
+    sprintf(res, "%d%f", a, b);
+    return res;
+}
+
+char *_rcat_charp_int(char *a, int b) {
+    char res[20];
+    sprintf(res, "%c", b);
+    return strcat(a, res);
+}
+
+char *_rcat_charp_double(char *a, double b) {
+    char res[20];
+    sprintf(res, "%f", b);
+    return strcat(a, res);
+}
+
+char *_rcat_charp_charp(char *a, char *b) {
+    ;
+    return strcat(a, b);
+}
+char *_rcat_charp_char(char *a, char b) {
+    char extra[] = {b, 0};
+    return strcat(a, extra);
+}
+char *_rcat_charp_bool(char *a, bool *b) {
+    if (b) {
+        return strcat(a, "true");
+    } else {
+        return strcat(a, "false");
+    }
+}
+
+#define rcat(x, y)                                                                                                                         \
+    _Generic((x),                                                                                                                          \
+        int: _Generic((y), int: _rcat_int_int, double: _rcat_int_double, char *: _rcat_charp_charp),                                       \
+        char *: _Generic((y),                                                                                                              \
+        int: _rcat_charp_int,                                                                                                              \
+        double: _rcat_charp_double,                                                                                                        \
+        char *: _rcat_charp_charp,                                                                                                         \
+        char: _rcat_charp_char,                                                                                                            \
+        bool: _rcat_charp_bool))((x), (y))
+
+char *rgenerate_key() {
+    _r_generate_key_current++;
+    static char key[100];
+    key[0] = 0;
+    sprintf(key, "%lld", _r_generate_key_current);
+    return key;
+}
+
+char *rformat_number(long long lnumber) {
+    static char formatted[1024];
+
+    char number[1024] = {0};
+    sprintf(number, "%lld", lnumber);
+
+    int len = strlen(number);
+    int commas_needed = (len - 1) / 3;
+    int new_len = len + commas_needed;
+
+    formatted[new_len] = '\0';
+
+    int i = len - 1;
+    int j = new_len - 1;
+    int count = 0;
+
+    while (i >= 0) {
+        if (count == 3) {
+            formatted[j--] = '.';
+            count = 0;
+        }
+        formatted[j--] = number[i--];
+        count++;
+    }
+    if (lnumber < 0)
+        formatted[j--] = '-';
+    return formatted;
+}
+
+bool rstrextractdouble(char *str, double *d1) {
+    for (size_t i = 0; i < strlen(str); i++) {
+        if (isdigit(str[i])) {
+            str += i;
+            sscanf(str, "%lf", d1);
+            return true;
+        }
+    }
+    return false;
+}
+
+void rstrstripslashes(const char *content, char *result) {
+    size_t content_length = strlen((char *)content);
+    unsigned int index = 0;
+    for (unsigned int i = 0; i < content_length; i++) {
+        char c = content[i];
+        if (c == '\\') {
+            i++;
+            c = content[i];
+            if (c == 'r') {
+                c = '\r';
+            } else if (c == 't') {
+                c = '\t';
+            } else if (c == 'b') {
+                c = '\b';
+            } else if (c == 'n') {
+                c = '\n';
+            } else if (c == 'f') {
+                c = '\f';
+            } else if (c == '\\') {
+                // No need tbh
+                c = '\\';
+                i++;
+            }
+        }
+        result[index] = c;
+        index++;
+    }
+    result[index] = 0;
+}
+
+int rstrstartswith(const char *s1, const char *s2) {
+    if (s1 == NULL)
+        return s2 == NULL;
+    if (s1 == s2 || s2 == NULL || *s2 == 0)
+        return true;
+    size_t len_s2 = strlen(s2);
+    size_t len_s1 = strlen(s1);
+    if (len_s2 > len_s1)
+        return false;
+    return !strncmp(s1, s2, len_s2);
+}
+
+bool rstrendswith(const char *s1, const char *s2) {
+    if (s1 == NULL)
+        return s2 == NULL;
+    if (s1 == s2 || s2 == NULL || *s2 == 0)
+        return true;
+    size_t len_s2 = strlen(s2);
+    size_t len_s1 = strlen(s1);
+    if (len_s2 > len_s1) {
+        return false;
+    }
+    s1 += len_s1 - len_s2;
+    return !strncmp(s1, s2, len_s2);
+}
+
+void rstraddslashes(const char *content, char *result) {
+    size_t content_length = strlen((char *)content);
+    unsigned int index = 0;
+    for (unsigned int i = 0; i < content_length; i++) {
+        if (content[i] == '\r') {
+            result[index] = '\\';
+            index++;
+            result[index] = 'r';
+            index++;
+            continue;
+        } else if (content[i] == '\t') {
+            result[index] = '\\';
+            index++;
+            result[index] = 't';
+            index++;
+            continue;
+        } else if (content[i] == '\n') {
+            result[index] = '\\';
+            index++;
+            result[index] = 'n';
+            index++;
+            continue;
+        } else if (content[i] == '\\') {
+            result[index] = '\\';
+            index++;
+            result[index] = '\\';
+            index++;
+            continue;
+        } else if (content[i] == '\b') {
+            result[index] = '\\';
+            index++;
+            result[index] = 'b';
+            index++;
+            continue;
+        } else if (content[i] == '\f') {
+            result[index] = '\\';
+            index++;
+            result[index] = 'f';
+            index++;
+            continue;
+        } else if (content[i] == '"') {
+            result[index] = '\\';
+            index++;
+            result[index] = '"';
+            index++;
+            continue;
+        }
+        result[index] = content[i];
+        index++;
+        result[index] = 0;
+    }
+}
+
+int rstrip_whitespace(char *input, char *output) {
+    output[0] = 0;
+    int count = 0;
+    size_t len = strlen(input);
+    for (size_t i = 0; i < len; i++) {
+        if (input[i] == '\t' || input[i] == ' ' || input[i] == '\n') {
+            continue;
+        }
+        count = i;
+        size_t j;
+        for (j = 0; j < len - count; j++) {
+            output[j] = input[j + count];
+        }
+        output[j] = '\0';
+        break;
+    }
+    return count;
+}
+
+/*
+ * Converts "pony" to \"pony\". Addslashes does not
+ * Converts "pony\npony" to "pony\n"
+ * 			    "pony"
+ */
+void rstrtocstring(const char *input, char *output) {
+    int index = 0;
+    char clean_input[strlen(input) * 2];
+    char *iptr = clean_input;
+    rstraddslashes(input, clean_input);
+    output[index] = '"';
+    index++;
+    while (*iptr) {
+        if (*iptr == '"') {
+            output[index] = '\\';
+            output++;
+        } else if (*iptr == '\\' && *(iptr + 1) == 'n') {
+            output[index] = '\\';
+            output++;
+            output[index] = 'n';
+            output++;
+            output[index] = '"';
+            output++;
+            output[index] = '\n';
+            output++;
+            output[index] = '"';
+            output++;
+            iptr++;
+            iptr++;
+            continue;
+        }
+        output[index] = *iptr;
+        index++;
+        iptr++;
+    }
+    if (output[index - 1] == '"' && output[index - 2] == '\n') {
+        output[index - 1] = 0;
+    } else if (output[index - 1] != '"') {
+        output[index] = '"';
+        output[index + 1] = 0;
+    }
+}
+
+size_t rstrtokline(char *input, char *output, size_t offset, bool strip_nl) {
+
+    size_t len = strlen(input);
+    output[0] = 0;
+    size_t new_offset = 0;
+    size_t j;
+    size_t index = 0;
+
+    for (j = offset; j < len + offset; j++) {
+        if (input[j] == 0) {
+            index++;
+            break;
+        }
+        index = j - offset;
+        output[index] = input[j];
+
+        if (output[index] == '\n') {
+            index++;
+            break;
+        }
+    }
+    output[index] = 0;
+
+    new_offset = index + offset;
+
+    if (strip_nl) {
+        if (output[index - 1] == '\n') {
+            output[index - 1] = 0;
+        }
+    }
+    return new_offset;
+}
+
+void rstrjoin(char **lines, size_t count, char *glue, char *output) {
+    output[0] = 0;
+    for (size_t i = 0; i < count; i++) {
+        strcat(output, lines[i]);
+        if (i != count - 1)
+            strcat(output, glue);
+    }
+}
+
+int rstrsplit(char *input, char **lines) {
+    int index = 0;
+    size_t offset = 0;
+    char line[1024];
+    while ((offset = rstrtokline(input, line, offset, false)) && *line) {
+        if (!*line) {
+            break;
+        }
+        lines[index] = (char *)malloc(strlen(line) + 1);
+        strcpy(lines[index], line);
+        index++;
+    }
+    return index;
+}
+
+bool rstartswithnumber(char *str) { return isdigit(str[0]); }
+
+void rstrmove2(char *str, unsigned int start, size_t length, unsigned int new_pos) {
+    size_t str_len = strlen(str);
+    char new_str[str_len + 1];
+    memset(new_str, 0, str_len);
+    if (start < new_pos) {
+        strncat(new_str, str + length, str_len - length - start);
+        new_str[new_pos] = 0;
+        strncat(new_str, str + start, length);
+        strcat(new_str, str + strlen(new_str));
+        memset(str, 0, str_len);
+        strcpy(str, new_str);
+    } else {
+        strncat(new_str, str + start, length);
+        strncat(new_str, str, start);
+        strncat(new_str, str + start + length, str_len - start);
+        memset(str, 0, str_len);
+        strcpy(str, new_str);
+    }
+    new_str[str_len] = 0;
+}
+
+void rstrmove(char *str, unsigned int start, size_t length, unsigned int new_pos) {
+    size_t str_len = strlen(str);
+    if (start >= str_len || new_pos >= str_len || start + length > str_len) {
+        return;
+    }
+    char temp[length + 1];
+    strncpy(temp, str + start, length);
+    temp[length] = 0;
+    if (start < new_pos) {
+        memmove(str + start, str + start + length, new_pos - start);
+        strncpy(str + new_pos - length + 1, temp, length);
+    } else {
+        memmove(str + new_pos + length, str + new_pos, start - new_pos);
+        strncpy(str + new_pos, temp, length);
+    }
+}
+
+int cmp_line(const void *left, const void *right) {
+    char *l = *(char **)left;
+    char *r = *(char **)right;
+
+    char lstripped[strlen(l) + 1];
+    rstrip_whitespace(l, lstripped);
+    char rstripped[strlen(r) + 1];
+    rstrip_whitespace(r, rstripped);
+
+    double d1, d2;
+    bool found_d1 = rstrextractdouble(lstripped, &d1);
+    bool found_d2 = rstrextractdouble(rstripped, &d2);
+
+    if (found_d1 && found_d2) {
+        double frac_part1;
+        double int_part1;
+        frac_part1 = modf(d1, &int_part1);
+        double frac_part2;
+        double int_part2;
+        frac_part2 = modf(d2, &int_part2);
+        if (d1 == d2) {
+            return strcmp(lstripped, rstripped);
+        } else if (frac_part1 && frac_part2) {
+            return d1 > d2;
+        } else if (frac_part1 && !frac_part2) {
+            return 1;
+        } else if (frac_part2 && !frac_part1) {
+            return -1;
+        } else if (!frac_part1 && !frac_part2) {
+            return d1 > d2;
+        }
+    }
+    return 0;
+}
+
+int rstrsort(char *input, char *output) {
+    char **lines = (char **)malloc(strlen(input) * 10);
+    int line_count = rstrsplit(input, lines);
+    qsort(lines, line_count, sizeof(char *), cmp_line);
+    rstrjoin(lines, line_count, "", output);
+    for (int i = 0; i < line_count; i++) {
+        free(lines[i]);
+    }
+    free(lines);
+    return line_count;
+}
+
+#endif
+
+#include <assert.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef enum rliza_type_t {
+    RLIZA_STRING = 's',
+    RLIZA_BOOLEAN = 'b',
+    RLIZA_NUMBER = 'n',
+    RLIZA_OBJECT = 'o',
+    RLIZA_ARRAY = 'a',
+    RLIZA_NULL = 0,
+    RLIZA_KEY = 'k',
+    RLIZA_INTEGER = 'i'
+} rliza_type_t;
+
+typedef struct rliza_t {
+    rliza_type_t type;
+    struct rliza_t *value;
+    char *key;
+    union {
+        char *string;
+        bool boolean;
+        double number;
+        struct rliza_t **map;
+        long long integer;
+    } content;
+    unsigned int count;
+    char *(*get_string)(struct rliza_t *, char *);
+    long long (*get_integer)(struct rliza_t *, char *);
+    double (*get_number)(struct rliza_t *, char *);
+    bool (*get_boolean)(struct rliza_t *, char *);
+    struct rliza_t *(*get_array)(struct rliza_t *, char *);
+    struct rliza_t *(*get_object)(struct rliza_t *, char *);
+    void (*set_string)(struct rliza_t *, char *, char *);
+    void (*set_integer)(struct rliza_t *, char *, long long);
+    void (*set_number)(struct rliza_t *, char *, double);
+    void (*set_boolean)(struct rliza_t *, char *, bool);
+    void (*set_array)(struct rliza_t *self, char *key, struct rliza_t *array);
+    void (*set_object)(struct rliza_t *self, char *key, struct rliza_t *object);
+} rliza_t;
+
+void rliza_free(rliza_t *rliza) {
+    if (rliza->key) {
+        free(rliza->key);
+        rliza->key = NULL;
+    }
+    if (rliza->value) {
+        rliza_free(rliza->value);
+        rliza->value = NULL;
+    }
+    // if (rliza->content.array) {
+    //     printf("JAAAA\n");
+    // }
+    // if (rliza->content.object) {
+    //     rliza_free(rliza->content.object);
+    //    rliza->content.object = NULL;
+    //}
+    if (rliza->type == RLIZA_STRING) {
+        if (rliza->content.string) {
+            free(rliza->content.string);
+            rliza->content.string = NULL;
+            // else if (rliza->type == RLIZA_NUMBER) {
+            //    printf("STDring freed\n");
+        }
+    } else if (rliza->type == RLIZA_OBJECT || rliza->type == RLIZA_ARRAY) {
+
+        if (rliza->content.map) {
+            for (unsigned int i = 0; i < rliza->count; i++) {
+                rliza_free(rliza->content.map[i]);
+            }
+            free(rliza->content.map);
+        }
+    }
+    // free(rliza->content.array);
+    //}
+
+    free(rliza);
+}
+
+rliza_t *rliza_new(rliza_type_t type);
+rliza_t *rliza_new_string(char *string);
+rliza_t *rliza_new_null();
+rliza_t *rliza_new_boolean(bool value);
+rliza_t *rliza_new_number(double value);
+rliza_t *rliza_new_integer(long long value);
+rliza_t *rliza_new_key_value(char *key, rliza_t *value);
+rliza_t *rliza_new_key_string(char *key, char *string);
+rliza_t *rliza_new_key_bool(char *key, bool value);
+rliza_t *rliza_new_key_number(char *key, double value);
+void rliza_push(rliza_t *self, rliza_t *obj);
+void rliza_push_object(rliza_t *self, rliza_t *object);
+void rliza_set_object(rliza_t *self, char *key, rliza_t *object);
+void rliza_set_string(rliza_t *self, char *key, char *string);
+void rliza_set_boolean(rliza_t *self, char *key, bool value);
+void rliza_set_number(rliza_t *self, char *key, double value);
+void rliza_set_integer(rliza_t *self, char *key, long long value);
+char *rliza_get_string(rliza_t *self, char *key);
+long long rliza_get_integer(rliza_t *self, char *key);
+double rliza_get_number(rliza_t *self, char *key);
+bool rliza_get_boolean(rliza_t *self, char *key);
+rliza_t *rliza_get_array(rliza_t *self, char *key);
+rliza_t *rliza_get_object(rliza_t *self, char *key);
+void rliza_set_array(rliza_t *self, char *key, rliza_t *array);
+
+char *rliza_dumps(rliza_t *rliza);
+rliza_t *rliza_loads(char **content);
+rliza_t *_rliza_loads(char **content);
+
+char *rliza_get_string(rliza_t *self, char *key) {
+    for (unsigned int i = 0; i < self->count; i++) {
+        if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
+            if (self->content.map[i]->type == RLIZA_STRING || self->content.map[i]->type == RLIZA_NULL) {
+                return self->content.map[i]->content.string;
+            }
+        }
+    }
+    return NULL;
+}
+long long rliza_get_integer(rliza_t *self, char *key) {
+    for (unsigned int i = 0; i < self->count; i++) {
+        if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
+            if (self->content.map[i]->type == RLIZA_INTEGER || self->content.map[i]->type == RLIZA_NULL) {
+                return self->content.map[i]->content.integer;
+            }
+        }
+    }
+    return 0;
+}
+
+double rliza_get_number(rliza_t *self, char *key) {
+    for (unsigned int i = 0; i < self->count; i++) {
+        if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
+            if (self->content.map[i]->type == RLIZA_NUMBER || self->content.map[i]->type == RLIZA_NULL) {
+                return self->content.map[i]->content.number;
+            }
+        }
+    }
+    return 0;
+}
+
+bool rliza_get_boolean(rliza_t *self, char *key) {
+    for (unsigned int i = 0; i < self->count; i++) {
+        if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
+            if (self->content.map[i]->type == RLIZA_BOOLEAN || self->content.map[i]->type == RLIZA_NULL) {
+                return self->content.map[i]->content.boolean;
+            }
+        }
+    }
+    return false;
+}
+
+rliza_t *rliza_get_object(rliza_t *self, char *key) {
+    for (unsigned int i = 0; i < self->count; i++) {
+        if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
+            return self->content.map[i];
+        }
+    }
+    return NULL;
+}
+
+rliza_t *rliza_get_array(rliza_t *self, char *key) {
+    for (unsigned int i = 0; i < self->count; i++) {
+        if (self->content.map[i]->key != NULL && strcmp(self->content.map[i]->key, key) == 0) {
+            if (self->content.map[i]->type == RLIZA_ARRAY || self->content.map[i]->type == RLIZA_NULL) {
+                return self->content.map[i];
+            }
+        }
+    }
+    return NULL;
+}
+
+rliza_t *rliza_new_null() {
+    rliza_t *rliza = rliza_new(RLIZA_NULL);
+    return rliza;
+}
+rliza_t *rliza_new_string(char *string) {
+    rliza_t *rliza = rliza_new(RLIZA_STRING);
+    if (string == NULL) {
+        rliza->type = RLIZA_NULL;
+        rliza->content.string = NULL;
+        return rliza;
+    } else {
+        rliza->content.string = strdup(string);
+    }
+    return rliza;
+}
+rliza_t *rliza_new_boolean(bool value) {
+    rliza_t *rliza = rliza_new(RLIZA_BOOLEAN);
+    rliza->content.boolean = value;
+    return rliza;
+}
+
+rliza_t *rliza_new_number(double value) {
+    rliza_t *rliza = rliza_new(RLIZA_NUMBER);
+    rliza->content.number = value;
+    return rliza;
+}
+
+rliza_t *rliza_new_integer(long long value) {
+    rliza_t *rliza = rliza_new(RLIZA_INTEGER);
+    rliza->content.integer = value;
+    return rliza;
+}
+rliza_t *rliza_new_key_array(char *key) {
+    rliza_t *rliza = rliza_new(RLIZA_ARRAY);
+    rliza->key = strdup(key);
+    return rliza;
+}
+
+rliza_t *rliza_new_key_value(char *key, rliza_t *value) {
+    rliza_t *rliza = rliza_new(RLIZA_OBJECT);
+    if (key) {
+        rliza->key = strdup(key);
+    }
+    rliza->value = value;
+    return rliza;
+}
+
+rliza_t *rliza_new_key_string(char *key, char *string) {
+    rliza_t *rliza = rliza_new_key_value(key, rliza_new_string(string));
+    return rliza;
+}
+rliza_t *rliza_new_key_bool(char *key, bool value) {
+    rliza_t *rliza = rliza_new_key_value(key, rliza_new_boolean(value));
+    return rliza;
+}
+rliza_t *rliza_new_key_number(char *key, double value) {
+    rliza_t *rliza = rliza_new_key_value(key, rliza_new_number(value));
+    return rliza;
+}
+
+void rliza_set_null(rliza_t *self, char *key) {
+    rliza_t *obj = rliza_get_object(self, key);
+    if (!obj) {
+        obj = rliza_new_null();
+        obj->key = strdup(key);
+        rliza_push_object(self, obj);
+    }
+    if (obj->type == RLIZA_OBJECT) {
+
+        rliza_free(obj->value);
+        obj->value = NULL;
+    } else if (obj->type == RLIZA_STRING) {
+        if (obj->content.string)
+            free(obj->content.string);
+        obj->content.string = NULL;
+    } else if (obj->type == RLIZA_ARRAY) {
+        for (unsigned int i = 0; i < obj->count; i++) {
+            rliza_free(obj->content.map[i]);
+        }
+    } else if (obj->type == RLIZA_NUMBER) {
+        obj->content.number = 0;
+    } else if (obj->type == RLIZA_INTEGER) {
+        obj->content.integer = 0;
+    }
+    obj->type = RLIZA_NULL;
+}
+
+rliza_t *rliza_duplicate(rliza_t *rliza) {
+    if (!rliza)
+        return NULL;
+    char *str = rliza_dumps(rliza);
+    char *strp = str;
+    rliza_t *obj = rliza_loads(&strp);
+    free(str);
+    return obj;
+}
+
+rliza_t *rliza_new_object(rliza_t *obj) {
+    rliza_t *rliza = rliza_new(RLIZA_OBJECT);
+    rliza->value = obj;
+    return rliza;
+}
+void rliza_set_object(rliza_t *self, char *key, rliza_t *value) {
+    rliza_t *obj = rliza_duplicate(value);
+    obj->key = strdup(key);
+    obj->type = RLIZA_OBJECT;
+    rliza_push(self, obj);
+}
+
+void rliza_set_string(rliza_t *self, char *key, char *string) {
+    rliza_t *obj = rliza_get_object(self, key);
+
+    if (!obj) {
+        obj = rliza_new_string(string);
+        obj->key = strdup(key);
+        obj->type = RLIZA_STRING;
+        rliza_push_object(self, obj);
+    } else {
+        obj->content.string = strdup(string);
+    }
+}
+
+void rliza_set_array(rliza_t *self, char *key, rliza_t *array) {
+    rliza_t *obj = rliza_get_object(self, key);
+    if (obj)
+        rliza_free(obj);
+    if (array->key) {
+        free(array->key);
+        array->key = strdup(key);
+    }
+    rliza_push_object(self, array);
+}
+
+void rliza_set_number(rliza_t *self, char *key, double value) {
+    rliza_t *obj = rliza_get_object(self, key);
+    if (!obj) {
+        obj = rliza_new_number(value);
+        obj->key = strdup(key);
+        obj->type = RLIZA_NUMBER;
+        rliza_push_object(self, obj);
+    } else {
+        obj->content.number = value;
+    }
+}
+
+void rliza_push_object(rliza_t *self, rliza_t *object) {
+    self->content.map = realloc(self->content.map, (sizeof(rliza_t **)) * (self->count + 1));
+    self->content.map[self->count] = object;
+    self->count++;
+}
+void rliza_set_integer(rliza_t *self, char *key, long long value) {
+    rliza_t *obj = rliza_get_object(self, key);
+    if (!obj) {
+        obj = rliza_new_integer(value);
+        obj->key = strdup(key);
+        obj->type = RLIZA_INTEGER;
+        rliza_push_object(self, obj);
+    } else {
+        obj->content.integer = value;
+    }
+}
+
+void rliza_set_boolean(rliza_t *self, char *key, bool value) {
+    rliza_t *obj = rliza_get_object(self, key);
+    if (!obj) {
+        obj = rliza_new_boolean(value);
+        obj->key = strdup(key);
+        obj->type = RLIZA_BOOLEAN;
+
+        rliza_push_object(self, obj);
+    } else {
+        obj->content.boolean = value;
+    }
+}
+
+rliza_t *rliza_new(rliza_type_t type) {
+    rliza_t *rliza = (rliza_t *)calloc(1, sizeof(rliza_t));
+    rliza->type = type;
+    rliza->get_boolean = rliza_get_boolean;
+    rliza->get_integer = rliza_get_integer;
+    rliza->get_number = rliza_get_number;
+    rliza->get_string = rliza_get_string;
+    rliza->get_array = rliza_get_array;
+    rliza->get_object = rliza_get_object;
+    rliza->set_string = rliza_set_string;
+    rliza->set_number = rliza_set_number;
+    rliza->set_boolean = rliza_set_boolean;
+    rliza->set_integer = rliza_set_integer;
+    rliza->set_array = rliza_set_array;
+    rliza->set_object = rliza_set_object;
+
+    return rliza;
+}
+
+void *rliza_coalesce(void *result, void *default_value) {
+    if (result == NULL)
+        return default_value;
+    return result;
+}
+
+char *rliza_seek_string(char **content, char **options) {
+
+    while (**content == ' ' || **content == '\n' || **content == '\t' || **content == '\r') {
+        (*content)++;
+    }
+    if (**content == 0) {
+        return NULL;
+    }
+
+    char *option = NULL;
+    unsigned int option_index = 0;
+
+    while (true) {
+        option = options[option_index];
+        if (option == NULL)
+            break;
+        option_index++;
+        if (option[0] == 'd') {
+            if (**content >= '0' && **content <= '9') {
+                return (char *)*content;
+            }
+        } else if (!strncmp(option, *content, strlen(option))) {
+            return (char *)*content;
+        }
+    }
+    return *content;
+}
+
+char *rliza_extract_quotes(char **content) {
+    rbuffer_t *buffer = rbuffer_new(NULL, 0);
+    assert(**content == '"');
+    char previous = 0;
+    while (true) {
+
+        (*content)++;
+        if (!**content) {
+            rbuffer_free(buffer);
+            return NULL;
+        }
+
+        if (**content == '"' && previous != '\\') {
+            break;
+        }
+        rbuffer_push(buffer, **content);
+        previous = **content;
+    }
+    assert(**content == '"');
+    (*content)++;
+    rbuffer_push(buffer, 0);
+    char *result = (char *)rbuffer_to_string(buffer);
+    return result;
+}
+
+rliza_t *_rliza_loads(char **content) {
+    static char *seek_for1[] = {"[", "{", "\"", "d", "true", "false", "null", NULL};
+    char *token = (char *)rliza_seek_string(content, seek_for1);
+    if (!token)
+        return NULL;
+    rliza_t *rliza = rliza_new(RLIZA_NULL);
+    if (**content == '"') {
+        char *extracted = rliza_extract_quotes(content);
+        if (!extracted) {
+            rliza_free(rliza);
+            return NULL;
+        }
+        //  char *extracted_with_slashes = (char *)malloc(strlen((char *)extracted) * 2 + 1);
+        // rstraddslashes(extracted, extracted_with_slashes);
+        rliza->type = RLIZA_STRING;
+        rliza->content.string = extracted; // extracted_with_slashes; // extracted_without_slashes;
+        // free(extracted);
+        return rliza;
+    } else if (**content == '{') {
+        rliza->type = RLIZA_OBJECT;
+        (*content)++;
+        char *result = NULL;
+        static char *seek_for2[] = {"\"", ",", "}", NULL};
+        while ((result = (char *)rliza_seek_string(content, seek_for2)) != NULL && *result) {
+
+            if (!**content) {
+                rliza_free(rliza);
+                return NULL;
+            }
+            if (**content == ',') {
+                (*content)++;
+                if (!**content) {
+                    rliza_free(rliza);
+                    return NULL;
+                }
+                continue;
+            }
+            char *key = NULL;
+            if (**content == '"') {
+                key = rliza_extract_quotes((char **)content);
+                if (!key || !*key) {
+                    rliza_free(rliza);
+                    return NULL;
+                }
+                char *escaped_key = (char *)malloc(strlen((char *)key) * 2 + 1);
+                rstrstripslashes((char *)key, escaped_key);
+                static char *seek_for3[] = {":", NULL};
+                char *devider = rliza_seek_string(content, seek_for3);
+
+                if (!devider || !*devider) {
+                    free(escaped_key);
+                    free(key);
+                    rliza_free(rliza);
+                    return NULL;
+                }
+                (*content)++;
+                if (!**content) {
+                    free(key);
+                    free(escaped_key);
+                    rliza_free(rliza);
+                    return NULL;
+                }
+                rliza_t *value = _rliza_loads(content);
+                if (!value) {
+                    free(key);
+                    free(escaped_key);
+                    rliza_free(rliza);
+                    return NULL;
+                }
+                if (value->key)
+                    free(value->key);
+                value->key = escaped_key;
+                free(key);
+                rliza_push_object(rliza, value);
+            } else if (**content == '}') {
+                break;
+            } else {
+                // Parse error
+                rliza_free(rliza);
+                return NULL;
+            }
+        };
+        if ((**content != '}')) {
+            rliza_free(rliza);
+            return NULL;
+        }
+        (*content)++;
+        return rliza;
+    } else if (**content == '[') {
+        rliza->type = RLIZA_ARRAY;
+        (*content)++;
+        char *result;
+        static char *seek_for4[] = {"[", "{", "\"", "d", ",", "]", "null", "true", "false", NULL};
+        while ((result = (char *)rliza_seek_string(content, seek_for4)) != NULL && *result) {
+            if (**content == ',') {
+                (*content)++;
+
+            } else if (**content == ']') {
+                break;
+            }
+            rliza_t *obj = _rliza_loads(content);
+            if (!obj) {
+                rliza_free(rliza);
+                return NULL;
+            }
+            rliza_push(rliza, obj);
+            if (!**content) {
+                rliza_free(rliza);
+                return NULL;
+            }
+        }
+        if (**content != ']') {
+            rliza_free(rliza);
+            return NULL;
+        }
+        (*content)++;
+        return rliza;
+    } else if (**content >= '0' && **content <= '9') {
+        char *ptr = *content;
+        bool is_decimal = false;
+
+        while (**content) {
+            if (**content == '.') {
+                is_decimal = true;
+            } else if (!isdigit(**content)) {
+                break;
+            }
+            (*content)++;
+        }
+        if (*(*content - 1) == '.') {
+            rliza_free(rliza);
+            return NULL;
+        }
+        if (!**content) {
+            rliza_free(rliza);
+            return NULL;
+        }
+        if (is_decimal) {
+            rliza->type = RLIZA_NUMBER;
+            rliza->content.number = strtod(ptr, NULL);
+        } else {
+            rliza->type = RLIZA_INTEGER;
+            rliza->content.integer = strtoll(ptr, NULL, 10);
+        }
+        return rliza;
+    } else if (!strncmp(*content, "true", 4)) {
+        rliza->type = RLIZA_BOOLEAN;
+        rliza->content.boolean = true;
+        *content += 4;
+
+        return rliza;
+    } else if (!strncmp(*content, "false", 5)) {
+        rliza->type = RLIZA_BOOLEAN;
+        rliza->content.boolean = false;
+        *content += 5;
+
+        return rliza;
+    } else if (!strncmp(*content, "null", 4)) {
+        rliza->type = RLIZA_NULL;
+        *content += 4;
+
+        return rliza;
+    }
+    // Parsing error
+    rliza_free(rliza);
+    return NULL;
+}
+rliza_t *rliza_loads(char **content) {
+    if (!content || !**content) {
+        return NULL;
+    }
+    char *original_content = *content;
+    rliza_t *result = _rliza_loads(content);
+    if (!result) {
+        *content = original_content;
+    }
+    return result;
+}
+
+char *rliza_dumps(rliza_t *rliza) {
+    size_t size = 4096;
+    char *content = (char *)calloc(size, sizeof(char));
+    content[0] = 0;
+    if (rliza->type == RLIZA_INTEGER) {
+        if (rliza->key) {
+            sprintf(content, "\"%s\":%lld", rliza->key, rliza->content.integer);
+        } else {
+            sprintf(content, "%lld", rliza->content.integer);
+        }
+    } else if (rliza->type == RLIZA_STRING) {
+
+        // char *escaped_string = (char *)calloc(strlen((char *)rliza->content.string) * 2 + 1024,sizeof(char));
+        char *escaped_string = rliza->content.string;
+        // rstrstripslashes((char *)rliza->content.string, escaped_string);
+        size_t min_size = strlen((char *)escaped_string) + (rliza->key ? strlen(rliza->key) : 0) + 1024;
+        if (size < min_size) {
+            size = min_size + 1;
+            content = realloc(content, size);
+        }
+        if (rliza->key) {
+            char *escaped_key = (char *)malloc(strlen((char *)rliza->key) * 2 + 20);
+            rstrstripslashes((char *)rliza->key, escaped_key);
+            if (strlen(content) > size) {
+                size = size + strlen(escaped_string) + 20;
+                content = realloc(content, size);
+            }
+            sprintf(content, "\"%s\":\"%s\"", escaped_key, escaped_string);
+            free(escaped_key);
+        } else {
+            size = size + strlen(escaped_string) + 20;
+            content = realloc(content, size);
+            sprintf(content, "\"%s\"", escaped_string);
+        }
+        // free(escaped_string);
+    } else if (rliza->type == RLIZA_NUMBER) {
+        if (rliza->key) {
+            sprintf(content, "\"%s\":%f", rliza->key, rliza->content.number);
+        } else {
+            sprintf(content, "%f", rliza->content.number);
+        }
+        int last_zero = 0;
+        bool beyond_dot = false;
+        for (size_t i = 0; i < strlen(content); i++) {
+            if (content[i] == '.') {
+                beyond_dot = true;
+            } else if (beyond_dot == true) {
+                if (content[i - 1] != '.') {
+                    if (content[i] == '0') {
+                        if (!last_zero)
+                            last_zero = i;
+                    } else {
+                        last_zero = 0;
+                    }
+                }
+            }
+        }
+        if (last_zero != 0) {
+            content[last_zero] = 0;
+        }
+    } else if (rliza->type == RLIZA_BOOLEAN) {
+        if (rliza->key) {
+            sprintf(content, "\"%s\":%s", rliza->key, rliza->content.boolean ? "true" : "false");
+        } else {
+            sprintf(content, "%s", rliza->content.boolean ? "true" : "false");
+        }
+    } else if (rliza->type == RLIZA_OBJECT) {
+
+        strcat(content, "{");
+        if (rliza->key) {
+            strcat(content, "\"");
+            strcat(content, rliza->key);
+            strcat(content, "\":{");
+        }
+        // bool add_braces = false;
+        for (unsigned i = 0; i < rliza->count; i++) {
+            char *content_chunk = rliza_dumps(rliza->content.map[i]);
+            char *content_chunk_stripped = content_chunk;
+            if (*content_chunk_stripped == '{') {
+                content_chunk_stripped++;
+                content_chunk_stripped[strlen(content_chunk_stripped) - 1] = 0;
+            }
+            if (strlen(content_chunk_stripped) + strlen(content) > size) {
+                size += strlen(content_chunk_stripped) + 20;
+                content = realloc(content, size);
+            }
+            strcat(content, content_chunk_stripped);
+            free(content_chunk);
+
+            strcat(content, ",");
+        }
+        if (content[strlen(content) - 1] == ',') {
+            content[strlen(content) - 1] = '\0';
+
+            if (rliza->key) {
+                strcat(content, "}");
+            }
+        }
+        strcat(content, "}");
+    } else if (rliza->type == RLIZA_ARRAY) {
+        if (rliza->key) {
+            char *escaped_key = (char *)malloc(strlen((char *)rliza->key) * 2 + 1);
+            rstraddslashes((char *)rliza->key, escaped_key);
+            if (strlen(escaped_key) > size) {
+                size = strlen(escaped_key) + 10;
+                content = realloc(content, size);
+            }
+            sprintf(content, "\"%s\":[", escaped_key);
+            free(escaped_key);
+        } else
+            strcpy(content, "[");
+        for (unsigned i = 0; i < rliza->count; i++) {
+            char *content_chunk = rliza_dumps(rliza->content.map[i]);
+            char *content_chunk_stripped = content_chunk;
+            if (*content_chunk_stripped == '{') {
+                // content_chunk_stripped++;
+                // content_chunk_stripped[strlen(content_chunk_stripped) - 1] = 0;
+            }
+            if (strlen(content_chunk_stripped) + strlen(content) > size) {
+                size += strlen(content_chunk_stripped) + 20;
+                content = realloc(content, size);
+            }
+            strcat(content, content_chunk_stripped);
+            free(content_chunk);
+            strcat(content, ",");
+        }
+        if (content[strlen(content) - 1] != '[')
+            content[strlen(content) - 1] = 0;
+        strcat(content, "]");
+    } else if (rliza->type == RLIZA_NULL) {
+
+        if (rliza->key) {
+            char *escaped_key = (char *)malloc(strlen((char *)rliza->key) * 2 + 1);
+            rstraddslashes((char *)rliza->key, escaped_key);
+            sprintf(content, "\"%s\":null", escaped_key);
+            free(escaped_key);
+        } else
+            strcpy(content, "null");
+    }
+    return content;
+}
+
+void rliza_dumpss(rliza_t *rliza) {
+    char *output = rliza_dumps(rliza);
+    printf("%s\n", output);
+    free(output);
+}
+
+void rliza_push(rliza_t *self, rliza_t *obj) { rliza_push_object(self, obj); }
+
+int rliza_validate(char *json_content) {
+    if (!json_content || !*json_content) {
+        return false;
+    }
+    char *json_contentp = json_content;
+    rliza_t *to_object = _rliza_loads(&json_contentp);
+    if (to_object) {
+        rliza_free(to_object);
+        return json_contentp - json_content;
+    }
+    return false;
+}
+
+#endif
+
+#ifndef RCOV_H
+#define RCOV_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#ifndef RBENCH_H
+#define RBENCH_H
+
+#ifndef RPRINT_H
+#define RPRINT_H
+
+#ifndef RLIB_TIME
+#define RLIB_TIME
+
+#ifndef _POSIX_C_SOURCE_199309L
+
+#define _POSIX_C_SOURCE_199309L
+#endif
+#include <sys/time.h>
+#include <time.h>
+#undef _POSIX_C_SOURCE_199309L
+#include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#ifndef CLOCK_MONOTONIC
+#define CLOCK_MONOTONIC 1
+#endif
+
+typedef uint64_t nsecs_t;
+void nsleep(nsecs_t nanoseconds);
+
+void tick() { nsleep(1); }
+
+typedef unsigned long long msecs_t;
+
+nsecs_t nsecs() {
+    unsigned int lo, hi;
+    __asm__ volatile("rdtsc" : "=a"(lo), "=d"(hi));
+    return ((uint64_t)hi << 32) | lo;
+}
+
+msecs_t rnsecs_to_msecs(nsecs_t nsecs) { return nsecs / 1000 / 1000; }
+
+nsecs_t rmsecs_to_nsecs(msecs_t msecs) { return msecs * 1000 * 1000; }
+
+msecs_t usecs() {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (long long)(tv.tv_sec) * 1000000 + (long long)(tv.tv_usec);
+}
+
+msecs_t msecs() {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (long long)(tv.tv_sec) * 1000 + (tv.tv_usec / 1000);
+}
+char *msecs_strs(msecs_t ms) {
+    static char str[22];
+    str[0] = 0;
+    sprintf(str, "%f", ms * 0.001);
+    for (int i = strlen(str); i > 0; i--) {
+        if (str[i] > '0')
+            break;
+        str[i] = 0;
+    }
+    return str;
+}
+char *msecs_strms(msecs_t ms) {
+    static char str[22];
+    str[0] = 0;
+    sprintf(str, "%lld", ms);
+    return str;
+}
+char *msecs_str(long long ms) {
+    static char result[30];
+    result[0] = 0;
+    if (ms > 999) {
+        char *s = msecs_strs(ms);
+        sprintf(result, "%ss", s);
+    } else {
+        char *s = msecs_strms(ms);
+        sprintf(result, "%sMs", s);
+    }
+    return result;
+}
+
+void nsleep(nsecs_t nanoseconds) {
+    long seconds = 0;
+    int factor = 0;
+    while (nanoseconds > 1000000000) {
+        factor++;
+        nanoseconds = nanoseconds / 10;
+    }
+    if (factor) {
+        seconds = 1;
+        factor--;
+        while (factor) {
+            seconds = seconds * 10;
+            factor--;
+        }
+    }
+
+    struct timespec req = {seconds, nanoseconds};
+    struct timespec rem;
+
+    nanosleep(&req, &rem);
+}
+
+void ssleep(double s) {
+    long nanoseconds = (long)(1000000000 * s);
+
+    // long seconds = 0;
+
+    // struct timespec req = {seconds, nanoseconds};
+    // struct timespec rem;
+
+    nsleep(nanoseconds);
+}
+void msleep(long miliseonds) {
+    long nanoseconds = miliseonds * 1000000;
+    nsleep(nanoseconds);
+}
+
+char *format_time(int64_t nanoseconds) {
+    char output[1024];
+    size_t output_size = sizeof(output);
+    output[0] = 0;
+    if (nanoseconds < 1000) {
+        // Less than 1 microsecond
+        snprintf(output, output_size, "%ldns", nanoseconds);
+    } else if (nanoseconds < 1000000) {
+        // Less than 1 millisecond
+        double us = nanoseconds / 1000.0;
+        snprintf(output, output_size, "%.2fµs", us);
+    } else if (nanoseconds < 1000000000) {
+        // Less than 1 second
+        double ms = nanoseconds / 1000000.0;
+        snprintf(output, output_size, "%.2fms", ms);
+    } else {
+        // 1 second or more
+        double s = nanoseconds / 1000000000.0;
+        if (s > 60 * 60) {
+            s = s / 60 / 60;
+            snprintf(output, output_size, "%.2fh", s);
+        } else if (s > 60) {
+            s = s / 60;
+            snprintf(output, output_size, "%.2fm", s);
+        } else {
+            snprintf(output, output_size, "%.2fs", s);
+        }
+    }
+    return sbuf(output);
+}
+
+#endif
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+long rpline_number = 0;
+nsecs_t rprtime = 0;
+
+int8_t _env_rdisable_colors = -1;
+bool _rprint_enable_colors = true;
+
+bool rprint_is_color_enabled() {
+    if (_env_rdisable_colors == -1) {
+        _env_rdisable_colors = getenv("RDISABLE_COLORS") != NULL;
+    }
+    if (_env_rdisable_colors) {
+        _rprint_enable_colors = false;
+    }
+    return _rprint_enable_colors;
+}
+
+void rprint_disable_colors() { _rprint_enable_colors = false; }
+void rprint_enable_colors() { _rprint_enable_colors = true; }
+void rprint_toggle_colors() { _rprint_enable_colors = !_rprint_enable_colors; }
+
+void rclear() { printf("\033[2J"); }
+
+void rprintpf(FILE *f, const char *prefix, const char *format, va_list args) {
+    char *pprefix = (char *)prefix;
+    char *pformat = (char *)format;
+    bool reset_color = false;
+    bool press_any_key = false;
+    char new_format[4096];
+    bool enable_color = rprint_is_color_enabled();
+    memset(new_format, 0, 4096);
+    int new_format_length = 0;
+    char temp[1000];
+    memset(temp, 0, 1000);
+    if (enable_color && pprefix[0]) {
+        strcat(new_format, pprefix);
+        new_format_length += strlen(pprefix);
+        reset_color = true;
+    }
+    while (true) {
+        if (pformat[0] == '\\' && pformat[1] == 'i') {
+            strcat(new_format, "\e[3m");
+            new_format_length += strlen("\e[3m");
+            reset_color = true;
+            pformat++;
+            pformat++;
+        } else if (pformat[0] == '\\' && pformat[1] == 'u') {
+            strcat(new_format, "\e[4m");
+            new_format_length += strlen("\e[4m");
+            reset_color = true;
+            pformat++;
+            pformat++;
+        } else if (pformat[0] == '\\' && pformat[1] == 'b') {
+            strcat(new_format, "\e[1m");
+            new_format_length += strlen("\e[1m");
+            reset_color = true;
+            pformat++;
+            pformat++;
+        } else if (pformat[0] == '\\' && pformat[1] == 'C') {
+            press_any_key = true;
+            rpline_number++;
+            pformat++;
+            pformat++;
+            reset_color = false;
+        } else if (pformat[0] == '\\' && pformat[1] == 'k') {
+            press_any_key = true;
+            rpline_number++;
+            pformat++;
+            pformat++;
+        } else if (pformat[0] == '\\' && pformat[1] == 'c') {
+            rpline_number++;
+            strcat(new_format, "\e[2J\e[H");
+            new_format_length += strlen("\e[2J\e[H");
+            pformat++;
+            pformat++;
+        } else if (pformat[0] == '\\' && pformat[1] == 'L') {
+            rpline_number++;
+            temp[0] = 0;
+            sprintf(temp, "%ld", rpline_number);
+            strcat(new_format, temp);
+            new_format_length += strlen(temp);
+            pformat++;
+            pformat++;
+        } else if (pformat[0] == '\\' && pformat[1] == 'l') {
+            rpline_number++;
+            temp[0] = 0;
+            sprintf(temp, "%.5ld", rpline_number);
+            strcat(new_format, temp);
+            new_format_length += strlen(temp);
+            pformat++;
+            pformat++;
+        } else if (pformat[0] == '\\' && pformat[1] == 'T') {
+            nsecs_t nsecs_now = nsecs();
+            nsecs_t end = rprtime ? nsecs_now - rprtime : 0;
+            temp[0] = 0;
+            sprintf(temp, "%s", format_time(end));
+            strcat(new_format, temp);
+            new_format_length += strlen(temp);
+            rprtime = nsecs_now;
+            pformat++;
+            pformat++;
+        } else if (pformat[0] == '\\' && pformat[1] == 't') {
+            rprtime = nsecs();
+            pformat++;
+            pformat++;
+        } else {
+            new_format[new_format_length] = *pformat;
+            new_format_length++;
+            if (!*pformat)
+                break;
+
+            // printf("%c",*pformat);
+            pformat++;
+        }
+    }
+    if (reset_color) {
+        strcat(new_format, "\e[0m");
+        new_format_length += strlen("\e[0m");
+    }
+
+    new_format[new_format_length] = 0;
+    vfprintf(f, new_format, args);
+
+    fflush(stdout);
+    if (press_any_key) {
+        nsecs_t s = nsecs();
+        fgetc(stdin);
+        rprtime += nsecs() - s;
+    }
+}
+
+void rprintp(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "", format, args);
+    va_end(args);
+}
+
+void rprintf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "", format, args);
+    va_end(args);
+}
+void rprint(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "", format, args);
+    va_end(args);
+}
+#define printf rprint
+
+// Print line
+void rprintlf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "\\l", format, args);
+    va_end(args);
+}
+void rprintl(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "\\l", format, args);
+    va_end(args);
+}
+
+// Black
+void rprintkf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "\e[30m", format, args);
+    va_end(args);
+}
+void rprintk(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "\e[30m", format, args);
+    va_end(args);
+}
+
+// Red
+void rprintrf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "\e[31m", format, args);
+    va_end(args);
+}
+void rprintr(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "\e[31m", format, args);
+    va_end(args);
+}
+
+// Green
+void rprintgf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "\e[32m", format, args);
+    va_end(args);
+}
+void rprintg(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "\e[32m", format, args);
+    va_end(args);
+}
+
+// Yellow
+void rprintyf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "\e[33m", format, args);
+    va_end(args);
+}
+void rprinty(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "\e[33m", format, args);
+    va_end(args);
+}
+
+// Blue
+void rprintbf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "\e[34m", format, args);
+    va_end(args);
+}
+
+void rprintb(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "\e[34m", format, args);
+    va_end(args);
+}
+
+// Magenta
+void rprintmf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "\e[35m", format, args);
+    va_end(args);
+}
+void rprintm(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "\e[35m", format, args);
+    va_end(args);
+}
+
+// Cyan
+void rprintcf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "\e[36m", format, args);
+    va_end(args);
+}
+void rprintc(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "\e[36m", format, args);
+    va_end(args);
+}
+
+// White
+void rprintwf(FILE *f, const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(f, "\e[37m", format, args);
+    va_end(args);
+}
+void rprintw(const char *format, ...) {
+    va_list args;
+    va_start(args, format);
+    rprintpf(stdout, "\e[37m", format, args);
+    va_end(args);
+}
+#endif
+#include <errno.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <time.h>
+
+#ifndef RLIB_TERMINAL_H
+#define RLIB_TERMINAL_H
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef RTEST_H
+#define RTEST_H
+#ifndef REMO_H
+#define REMO_H
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+    const char *str;
+    const char *description;
+} remo_t;
+
+remo_t remo[] = {
+    {"\U0001F600", "Grinning Face"},                   // 😀
+    {"\U0001F601", "Beaming Face with Smiling Eyes"},  // 😁
+    {"\U0001F602", "Face with Tears of Joy"},          // 😂
+    {"\U0001F923", "Rolling on the Floor Laughing"},   // 🤣
+    {"\U0001F603", "Grinning Face with Big Eyes"},     // 😃
+    {"\U0001F604", "Grinning Face with Smiling Eyes"}, // 😄
+    {"\U0001F609", "Winking Face"},                    // 😉
+    {"\U0001F60A", "Smiling Face with Smiling Eyes"},  // 😊
+    {"\U0001F60D", "Smiling Face with Heart-Eyes"},    // 😍
+    {"\U0001F618", "Face Blowing a Kiss"},             // 😘
+    {"\U0001F617", "Kissing Face"},                    // 😗
+    {"\U0001F61A", "Kissing Face with Closed Eyes"},   // 😚
+    {"\U0001F642", "Slightly Smiling Face"},           // 🙂
+    {"\U0001F643", "Upside-Down Face"},                // 🙃
+    {"\U0001F970", "Smiling Face with Hearts"},        // 🥰
+    {"\U0001F60B", "Face Savoring Food"},              // 😋
+    {"\U0001F61B", "Face with Tongue"},                // 😛
+    {"\U0001F61C", "Winking Face with Tongue"},        // 😜
+    {"\U0001F92A", "Zany Face"},                       // 🤪
+    {"\U0001F929", "Star-Struck"},                     // 🤩
+    {"\U0001F631", "Face Screaming in Fear"},          // 😱
+    {"\U0001F62D", "Loudly Crying Face"},              // 😭
+    {"\U0001F624", "Face with Steam From Nose"},       // 😤
+    {"\U0001F620", "Angry Face"},                      // 😠
+    {"\U0001F621", "Pouting Face"},                    // 😡
+    {"\U0001F47B", "Ghost"},                           // 👻
+    {"\U0001F480", "Skull"},                           // 💀
+    {"\U0001F4A9", "Pile of Poo"},                     // 💩
+    {"\U0001F47D", "Alien"},                           // 👽
+                                                       // Geometric Shapes
+    {"\U000025A0", "Black Square"},                    // ■
+    {"\U000025B2", "Upward Triangle"},                 // ▲
+    {"\U000025CF", "Black Circle"},                    // ●
+    {"\U000025CB", "White Circle"},                    // ○
+    {"\U00002B1B", "Large Black Square"},              // ⬛
+    {"\U00002B1C", "Large White Square"},              // ⬜
+
+    // Mathematical Symbols
+    {"\U00002200", "For All"},       // ∀
+    {"\U00002203", "Exists"},        // ∃
+    {"\U00002205", "Empty Set"},     // ∅
+    {"\U00002207", "Nabla"},         // ∇
+    {"\U0000220F", "N-Ary Product"}, // ∏
+    {"\U00002212", "Minus Sign"},    // −
+    {"\U0000221E", "Infinity"},      // ∞
+
+    // Arrows
+    {"\U00002190", "Left Arrow"},        // ←
+    {"\U00002191", "Up Arrow"},          // ↑
+    {"\U00002192", "Right Arrow"},       // →
+    {"\U00002193", "Down Arrow"},        // ↓
+    {"\U00002195", "Up Down Arrow"},     // ↕
+    {"\U00002197", "Up Right Arrow"},    // ↗
+    {"\U00002198", "Down Right Arrow"},  // ↘
+    {"\U000027A1", "Black Right Arrow"}, // ➡️
+
+    // Dingbats
+    {"\U00002714", "Check Mark"},             // ✔️
+    {"\U00002716", "Heavy Multiplication X"}, // ✖️
+    {"\U00002728", "Sparkles"},               // ✨
+    {"\U00002757", "Exclamation Mark"},       // ❗
+    {"\U0000274C", "Cross Mark"},             // ❌
+    {"\U00002795", "Heavy Plus Sign"},        // ➕
+
+    // Miscellaneous Symbols
+    {"\U00002600", "Sun"},                      // ☀️
+    {"\U00002614", "Umbrella with Rain Drops"}, // ☔
+    {"\U00002620", "Skull and Crossbones"},     // ☠️
+    {"\U000026A0", "Warning Sign"},             // ⚠️
+    {"\U000026BD", "Soccer Ball"},              // ⚽
+    {"\U000026C4", "Snowman"},                  // ⛄
+
+    // Stars and Asterisks
+    {"\U00002733", "Eight Pointed Black Star"}, // ✳️
+    {"\U00002734", "Eight Spoked Asterisk"},    // ✴️
+    {"\U00002B50", "White Star"},               // ⭐
+    {"\U0001F31F", "Glowing Star"},             // 🌟
+    {"\U00002728", "Sparkles"},                 // ✨
+                                                // Animals and Nature
+    {"\U0001F98A", "Fox"},                      // 🦊
+    {"\U0001F415", "Dog"},                      // 🐕
+    {"\U0001F431", "Cat Face"},                 // 🐱
+    {"\U0001F435", "Monkey Face"},              // 🐵
+    {"\U0001F408", "Black Cat"},                // 🐈
+    {"\U0001F98C", "Deer"},                     // 🦌
+    {"\U0001F344", "Mushroom"},                 // 🍄
+    {"\U0001F333", "Tree"},                     // 🌳
+
+    // Weather and Space Symbols
+    {"\U0001F308", "Rainbow"},       // 🌈
+    {"\U0001F320", "Shooting Star"}, // 🌠
+    {"\U00002600", "Sun"},           // ☀️
+    {"\U00002601", "Cloud"},         // ☁️
+    {"\U000026A1", "High Voltage"},  // ⚡
+    {"\U0001F525", "Fire"},          // 🔥
+    {"\U000026C4", "Snowman"},       // ⛄
+    {"\U0001F30A", "Water Wave"},    // 🌊
+
+    // Transport and Map Symbols
+    {"\U0001F68C", "Bus"},        // 🚌
+    {"\U0001F697", "Car"},        // 🚗
+    {"\U0001F6B2", "Bicycle"},    // 🚲
+    {"\U0001F6A2", "Ship"},       // 🚢
+    {"\U0001F681", "Helicopter"}, // 🚁
+    {"\U0001F680", "Rocket"},     // 🚀
+    {"\U0001F6EB", "Airplane"},   // 🛫
+
+    // Currency Symbols
+    {"\U00000024", "Dollar Sign"},     // $
+    {"\U000000A3", "Pound Sign"},      // £
+    {"\U000000A5", "Yen Sign"},        // ¥
+    {"\U000020AC", "Euro Sign"},       // €
+    {"\U0001F4B5", "Dollar Banknote"}, // 💵
+    {"\U0001F4B4", "Yen Banknote"},    // 💴
+
+    // Card Suits
+    {"\U00002660", "Black Spade Suit"},   // ♠️
+    {"\U00002663", "Black Club Suit"},    // ♣️
+    {"\U00002665", "Black Heart Suit"},   // ♥️
+    {"\U00002666", "Black Diamond Suit"}, // ♦️
+    {"\U0001F0CF", "Joker Card"},         // 🃏
+
+    // Office Supplies and Objects
+    {"\U0001F4DA", "Books"},                      // 📚
+    {"\U0001F4D7", "Green Book"},                 // 📗
+    {"\U0001F4C8", "Chart with Upwards Trend"},   // 📈
+    {"\U0001F4C9", "Chart with Downwards Trend"}, // 📉
+    {"\U0001F4B0", "Money Bag"},                  // 💰
+    {"\U0001F4B8", "Money with Wings"},           // 💸
+    {"\U0001F4E6", "Package"},                    // 📦
+
+    // Miscellaneous Symbols
+    {"\U00002757", "Exclamation Mark"},       // ❗
+    {"\U00002714", "Check Mark"},             // ✔️
+    {"\U0000274C", "Cross Mark"},             // ❌
+    {"\U00002705", "Check Mark Button"},      // ✅
+    {"\U00002B50", "White Star"},             // ⭐
+    {"\U0001F31F", "Glowing Star"},           // 🌟
+    {"\U0001F4A1", "Light Bulb"},             // 💡
+    {"\U0001F4A3", "Bomb"},                   // 💣
+    {"\U0001F4A9", "Pile of Poo"},            // 💩
+                                              // Musical Symbols
+    {"\U0001F3B5", "Musical Note"},           // 🎵
+    {"\U0001F3B6", "Multiple Musical Notes"}, // 🎶
+    {"\U0001F3BC", "Musical Score"},          // 🎼
+    {"\U0001F399", "Studio Microphone"},      // 🎙️
+    {"\U0001F3A4", "Microphone"},             // 🎤
+
+    // Food and Drink
+    {"\U0001F35F", "Cheese Wedge"},   // 🧀
+    {"\U0001F355", "Slice of Pizza"}, // 🍕
+    {"\U0001F32D", "Taco"},           // 🌮
+    {"\U0001F37D", "Beer Mug"},       // 🍻
+    {"\U0001F96B", "Cup with Straw"}, // 🥤
+    {"\U0001F32E", "Hot Pepper"},     // 🌶️
+    {"\U0001F95A", "Potato"},         // 🥔
+
+    // Zodiac Signs
+    {"\U00002600", "Aries"},       // ♈
+    {"\U00002601", "Taurus"},      // ♉
+    {"\U00002602", "Gemini"},      // ♊
+    {"\U00002603", "Cancer"},      // ♋
+    {"\U00002604", "Leo"},         // ♌
+    {"\U00002605", "Virgo"},       // ♍
+    {"\U00002606", "Libra"},       // ♎
+    {"\U00002607", "Scorpio"},     // ♏
+    {"\U00002608", "Sagittarius"}, // ♐
+    {"\U00002609", "Capricorn"},   // ♑
+    {"\U0000260A", "Aquarius"},    // ♒
+    {"\U0000260B", "Pisces"},      // ♓
+
+    // Miscellaneous Shapes
+    {"\U0001F4C8", "Chart Increasing"}, // 📈
+    {"\U0001F4C9", "Chart Decreasing"}, // 📉
+    {"\U0001F4CA", "Bar Chart"},        // 📊
+    {"\U0001F7E6", "Orange Circle"},    // 🟠
+    {"\U0001F7E7", "Yellow Circle"},    // 🟡
+    {"\U0001F7E8", "Green Circle"},     // 🟢
+    {"\U0001F7E9", "Blue Circle"},      // 🔵
+    {"\U0001F7EA", "Purple Circle"},    // 🟣
+
+    // Flags
+    {"\U0001F1E6\U0001F1E9", "Flag of France"},        // 🇫🇷
+    {"\U0001F1E8\U0001F1E6", "Flag of Germany"},       // 🇩🇪
+    {"\U0001F1FA\U0001F1F8", "Flag of United States"}, // 🇺🇸
+    {"\U0001F1E7\U0001F1F7", "Flag of Canada"},        // 🇨🇦
+    {"\U0001F1EE\U0001F1F2", "Flag of Italy"},         // 🇮🇹
+    {"\U0001F1F8\U0001F1EC", "Flag of Australia"},     // 🇦🇺
+    {"\U0001F1F3\U0001F1F4", "Flag of Spain"},         // 🇪🇸
+
+    // Additional Miscellaneous Symbols
+    {"\U0001F4A5", "Collision"},         // 💥
+    {"\U0001F4A6", "Sweat Droplets"},    // 💦
+    {"\U0001F4A8", "Dashing Away"},      // 💨
+    {"\U0001F50B", "Battery"},           // 🔋
+    {"\U0001F4BB", "Laptop Computer"},   // 💻
+    {"\U0001F4DE", "Telephone"},         // 📞
+    {"\U0001F4E7", "Incoming Envelope"}, // 📧
+};
+size_t remo_count = sizeof(remo) / sizeof(remo[0]);
+
+void rstrtolower(const char *input, char *output) {
+    while (*input) {
+        *output = tolower(*input);
+        input++;
+        output++;
+    }
+    *output = 0;
+}
+bool rstrinstr(const char *haystack, const char *needle) {
+    char lower1[strlen(haystack) + 1];
+    char lower2[strlen(needle) + 1];
+    rstrtolower(haystack, lower1);
+    rstrtolower(needle, lower2);
+    return strstr(lower1, lower2) ? true : false;
+}
+
+void remo_print() {
+
+    for (size_t i = 0; i < remo_count; i++) {
+        printf("%s - %s\n", remo[i].str, remo[i].description);
+    }
+}
+
+const char *remo_get(char *name) {
+    for (size_t i = 0; i < remo_count; i++) {
+        if (rstrinstr(remo[i].description, name)) {
+            return remo[i].str;
+        }
+    }
+    return NULL;
+}
+
+#endif
+#include <stdbool.h>
+#include <stdio.h>
+#include <unistd.h>
+#define debug(fmt, ...) printf("%s:%d: " fmt, __FILE__, __LINE__, __VA_ARGS__);
+
+char *rcurrent_banner;
+int rassert_count = 0;
+unsigned short rtest_is_first = 1;
+unsigned int rtest_fail_count = 0;
+
+int rtest_end(char *content) {
+    // Returns application exit code. 0 == success
+    printf("%s", content);
+    printf("\n@assertions: %d\n", rassert_count);
+    printf("@memory: %s%s\n", rmalloc_stats(), rmalloc_count == 0 ? remo_get("rainbow") : "fire");
+
+    if (rmalloc_count != 0) {
+        printf("MEMORY ERROR %s\n", remo_get("cross mark"));
+        return rtest_fail_count > 0;
+    }
+    return rtest_fail_count > 0;
+}
+
+void rtest_test_banner(char *content, char *file) {
+    if (rtest_is_first == 1) {
+        char delimiter[] = ".";
+        char *d = delimiter;
+        char f[2048];
+        strcpy(f, file);
+        printf("%s tests", strtok(f, d));
+        rtest_is_first = 0;
+        setvbuf(stdout, NULL, _IONBF, 0);
+    }
+    printf("\n - %s ", content);
+}
+
+bool rtest_test_true_silent(char *expr, int res, int line) {
+    rassert_count++;
+    if (res) {
+        return true;
+    }
+    rprintrf(stderr, "\nERROR on line %d: %s", line, expr);
+    rtest_fail_count++;
+    return false;
+}
+
+bool rtest_test_true(char *expr, int res, int line) {
+    rassert_count++;
+    if (res) {
+        fprintf(stdout, "%s", remo_get("Slightly Smiling Face"));
+        return true;
+    }
+    rprintrf(stderr, "\nERROR %s on line %d: %s\n", remo_get("skull"), line, expr);
+    rtest_fail_count++;
+    return false;
+}
+bool rtest_test_false_silent(char *expr, int res, int line) { return rtest_test_true_silent(expr, !res, line); }
+bool rtest_test_false(char *expr, int res, int line) { return rtest_test_true(expr, !res, line); }
+void rtest_test_skip(char *expr, int line) { rprintgf(stderr, "\n @skip(%s) on line %d\n", expr, line); }
+void rtest_test_assert(char *expr, int res, int line) {
+    if (rtest_test_true(expr, res, line)) {
+        return;
+    }
+    rtest_end("");
+    exit(40);
+}
+
+#define rtest_banner(content)                                                                                                              \
+    rcurrent_banner = content;                                                                                                             \
+    rtest_test_banner(content, __FILE__);
+#define rtest_true(expr) rtest_test_true(#expr, expr, __LINE__);
+#define rtest_assert(expr)                                                                                                                 \
+    {                                                                                                                                      \
+        int __valid = expr ? 1 : 0;                                                                                                        \
+        rtest_test_true(#expr, __valid, __LINE__);                                                                                         \
+    };                                                                                                                                     \
+    ;
+
+#define rassert(expr)                                                                                                                      \
+    {                                                                                                                                      \
+        int __valid = expr ? 1 : 0;                                                                                                        \
+        rtest_test_true(#expr, __valid, __LINE__);                                                                                         \
+    };                                                                                                                                     \
+    ;
+#define rtest_asserts(expr)                                                                                                                \
+    {                                                                                                                                      \
+        int __valid = expr ? 1 : 0;                                                                                                        \
+        rtest_test_true_silent(#expr, __valid, __LINE__);                                                                                  \
+    };
+#define rasserts(expr)                                                                                                                     \
+    {                                                                                                                                      \
+        int __valid = expr ? 1 : 0;                                                                                                        \
+        rtest_test_true_silent(#expr, __valid, __LINE__);                                                                                  \
+    };
+#define rtest_false(expr)                                                                                                                  \
+    rprintf(" [%s]\t%s\t\n", expr == 0 ? "OK" : "NOK", #expr);                                                                             \
+    assert_count++;                                                                                                                        \
+    assert(#expr);
+#define rtest_skip(expr) rtest_test_skip(#expr, __LINE__);
+
+FILE *rtest_create_file(char *path, char *content) {
+    FILE *fd = fopen(path, "wb");
+
+    char c;
+    int index = 0;
+
+    while ((c = content[index]) != 0) {
+        fputc(c, fd);
+        index++;
+    }
+    fclose(fd);
+    fd = fopen(path, "rb");
+    return fd;
+}
+
+void rtest_delete_file(char *path) { unlink(path); }
+#endif
+
+char *rfcaptured = NULL;
+
+void rfcapture(FILE *f, char *buff, size_t size) {
+    rfcaptured = buff;
+    setvbuf(f, rfcaptured, _IOFBF, size);
+}
+void rfstopcapture(FILE *f) { setvbuf(f, 0, _IOFBF, 0); }
+
+bool _r_disable_stdout_toggle = false;
+
+FILE *_r_original_stdout = NULL;
+
+bool rr_enable_stdout() {
+    if (_r_disable_stdout_toggle)
+        return false;
+    if (!_r_original_stdout) {
+        stdout = fopen("/dev/null", "rb");
+        return false;
+    }
+    if (_r_original_stdout && _r_original_stdout != stdout) {
+        fclose(stdout);
+    }
+    stdout = _r_original_stdout;
+    return true;
+}
+bool rr_disable_stdout() {
+    if (_r_disable_stdout_toggle) {
+        return false;
+    }
+    if (_r_original_stdout == NULL) {
+        _r_original_stdout = stdout;
+    }
+    if (stdout == _r_original_stdout) {
+        stdout = fopen("/dev/null", "rb");
+        return true;
+    }
+    return false;
+}
+bool rr_toggle_stdout() {
+    if (!_r_original_stdout) {
+        rr_disable_stdout();
+        return true;
+    } else if (stdout != _r_original_stdout) {
+        rr_enable_stdout();
+        return true;
+    } else {
+        rr_disable_stdout();
+        return true;
+    }
+}
+
+typedef struct rprogressbar_t {
+    unsigned long current_value;
+    unsigned long min_value;
+    unsigned long max_value;
+    unsigned int length;
+    bool changed;
+    double percentage;
+    unsigned int width;
+    unsigned long draws;
+    FILE *fout;
+} rprogressbar_t;
+
+rprogressbar_t *rprogressbar_new(long min_value, long max_value, unsigned int width, FILE *fout) {
+    rprogressbar_t *pbar = (rprogressbar_t *)malloc(sizeof(rprogressbar_t));
+    pbar->min_value = min_value;
+    pbar->max_value = max_value;
+    pbar->current_value = min_value;
+    pbar->width = width;
+    pbar->draws = 0;
+    pbar->length = 0;
+    pbar->changed = false;
+    pbar->fout = fout ? fout : stdout;
+    return pbar;
+}
+
+void rprogressbar_free(rprogressbar_t *pbar) { free(pbar); }
+
+void rprogressbar_draw(rprogressbar_t *pbar) {
+    if (!pbar->changed) {
+        return;
+    } else {
+        pbar->changed = false;
+    }
+    pbar->draws++;
+    char draws_text[22];
+    draws_text[0] = 0;
+    sprintf(draws_text, "%ld", pbar->draws);
+    char *draws_textp = draws_text;
+    // bool draws_text_len = strlen(draws_text);
+    char bar_begin_char = ' ';
+    char bar_progress_char = ' ';
+    char bar_empty_char = ' ';
+    char bar_end_char = ' ';
+    char content[4096] = {0};
+    char bar_content[1024];
+    char buff[2048] = {0};
+    bar_content[0] = '\r';
+    bar_content[1] = bar_begin_char;
+    unsigned int index = 2;
+    for (unsigned long i = 0; i < pbar->length; i++) {
+        if (*draws_textp) {
+            bar_content[index] = *draws_textp;
+            draws_textp++;
+        } else {
+            bar_content[index] = bar_progress_char;
+        }
+        index++;
+    }
+    char infix[] = "\033[0m";
+    for (unsigned long i = 0; i < strlen(infix); i++) {
+        bar_content[index] = infix[i];
+        index++;
+    }
+    for (unsigned long i = 0; i < pbar->width - pbar->length; i++) {
+        bar_content[index] = bar_empty_char;
+        index++;
+    }
+    bar_content[index] = bar_end_char;
+    bar_content[index + 1] = '\0';
+    sprintf(buff, "\033[43m%s\033[0m \033[33m%.2f%%\033[0m ", bar_content, pbar->percentage * 100);
+    strcat(content, buff);
+    if (pbar->width == pbar->length) {
+        strcat(content, "\r");
+        for (unsigned long i = 0; i < pbar->width + 10; i++) {
+            strcat(content, " ");
+        }
+        strcat(content, "\r");
+    }
+    fprintf(pbar->fout, "%s", content);
+    fflush(pbar->fout);
+}
+
+bool rprogressbar_update(rprogressbar_t *pbar, unsigned long value) {
+    if (value == pbar->current_value) {
+        return false;
+    }
+    pbar->current_value = value;
+    pbar->percentage = (double)pbar->current_value / (double)(pbar->max_value - pbar->min_value);
+    unsigned long new_length = (unsigned long)(pbar->percentage * pbar->width);
+    pbar->changed = new_length != pbar->length;
+    if (pbar->changed) {
+        pbar->length = new_length;
+        rprogressbar_draw(pbar);
+        return true;
+    }
+    return false;
+}
+
+size_t rreadline(char *data, size_t len, bool strip_ln) {
+    __attribute__((unused)) char *unused = fgets(data, len, stdin);
+    size_t length = strlen(data);
+    if (length && strip_ln)
+        data[length - 1] = 0;
+    return length;
+}
+
+void rlib_test_progressbar() {
+    rtest_banner("Progress bar");
+    rprogressbar_t *pbar = rprogressbar_new(0, 1000, 10, stderr);
+    rprogressbar_draw(pbar);
+    // No draws executed, nothing to show
+    rassert(pbar->draws == 0);
+    rprogressbar_update(pbar, 500);
+    rassert(pbar->percentage == 0.5);
+    rprogressbar_update(pbar, 500);
+    rprogressbar_update(pbar, 501);
+    rprogressbar_update(pbar, 502);
+    // Should only have drawn one time since value did change, but percentage
+    // did not
+    rassert(pbar->draws == 1);
+    // Changed is false because update function calls draw
+    rassert(pbar->changed == false);
+    rprogressbar_update(pbar, 777);
+    rassert(pbar->percentage == 0.777);
+    rprogressbar_update(pbar, 1000);
+    rassert(pbar->percentage == 1);
+}
+
+#endif
+
+#define RBENCH(times, action)                                                                                                              \
+    {                                                                                                                                      \
+        unsigned long utimes = (unsigned long)times;                                                                                       \
+        nsecs_t start = nsecs();                                                                                                           \
+        for (unsigned long i = 0; i < utimes; i++) {                                                                                       \
+            {                                                                                                                              \
+                action;                                                                                                                    \
+            }                                                                                                                              \
+        }                                                                                                                                  \
+        nsecs_t end = nsecs();                                                                                                             \
+        printf("%s\n", format_time(end - start));                                                                                          \
+    }
+
+#define RBENCHP(times, action)                                                                                                             \
+    {                                                                                                                                      \
+        printf("\n");                                                                                                                      \
+        nsecs_t start = nsecs();                                                                                                           \
+        unsigned int prev_percentage = 0;                                                                                                  \
+        unsigned long utimes = (unsigned long)times;                                                                                       \
+        for (unsigned long i = 0; i < utimes; i++) {                                                                                       \
+            unsigned int percentage = ((long double)i / (long double)times) * 100;                                                         \
+            int percentage_changed = percentage != prev_percentage;                                                                        \
+            __attribute__((unused)) int first = i == 0;                                                                                    \
+            __attribute__((unused)) int last = i == utimes - 1;                                                                            \
+            { action; };                                                                                                                   \
+            if (percentage_changed) {                                                                                                      \
+                printf("\r%d%%", percentage);                                                                                              \
+                fflush(stdout);                                                                                                            \
+                                                                                                                                           \
+                prev_percentage = percentage;                                                                                              \
+            }                                                                                                                              \
+        }                                                                                                                                  \
+        nsecs_t end = nsecs();                                                                                                             \
+        printf("\r%s\n", format_time(end - start));                                                                                        \
+    }
+
+struct rbench_t;
+
+typedef struct rbench_function_t {
+#ifdef __cplusplus
+    void (*call)();
+#else
+    void(*call);
+#endif
+    char name[256];
+    char group[256];
+    void *arg;
+    void *data;
+    bool first;
+    bool last;
+    int argc;
+    unsigned long times_executed;
+
+    nsecs_t average_execution_time;
+    nsecs_t total_execution_time;
+} rbench_function_t;
+
+typedef struct rbench_t {
+    unsigned int function_count;
+    rbench_function_t functions[100];
+    rbench_function_t *current;
+    rprogressbar_t *progress_bar;
+    bool show_progress;
+    int winner;
+    bool stdout;
+    unsigned long times;
+    bool silent;
+    nsecs_t execution_time;
+#ifdef __cplusplus
+    void (*add_function)(struct rbench_t *r, const char *name, const char *group, void (*)());
+#else
+    void (*add_function)(struct rbench_t *r, const char *name, const char *group, void *);
+#endif
+    void (*rbench_reset)(struct rbench_t *r);
+    struct rbench_t *(*execute)(struct rbench_t *r, long times);
+    struct rbench_t *(*execute1)(struct rbench_t *r, long times, void *arg1);
+    struct rbench_t *(*execute2)(struct rbench_t *r, long times, void *arg1, void *arg2);
+    struct rbench_t *(*execute3)(struct rbench_t *r, long times, void *arg1, void *arg2, void *arg3);
+
+} rbench_t;
+
+FILE *_rbench_stdout = NULL;
+FILE *_rbench_stdnull = NULL;
+
+void rbench_toggle_stdout(rbench_t *r) {
+    if (!r->stdout) {
+        if (_rbench_stdout == NULL) {
+            _rbench_stdout = stdout;
+        }
+        if (_rbench_stdnull == NULL) {
+            _rbench_stdnull = fopen("/dev/null", "wb");
+        }
+        if (stdout == _rbench_stdout) {
+            stdout = _rbench_stdnull;
+        } else {
+            stdout = _rbench_stdout;
+        }
+    }
+}
+void rbench_restore_stdout(rbench_t *r) {
+    if (r->stdout)
+        return;
+    if (_rbench_stdout) {
+        stdout = _rbench_stdout;
+    }
+    if (_rbench_stdnull) {
+        fclose(_rbench_stdnull);
+        _rbench_stdnull = NULL;
+    }
+}
+
+rbench_t *rbench_new();
+
+rbench_t *_rbench = NULL;
+rbench_function_t *rbf;
+rbench_t *rbench() {
+    if (_rbench == NULL) {
+        _rbench = rbench_new();
+    }
+    return _rbench;
+}
+
+typedef void *(*rbench_call)();
+typedef void *(*rbench_call1)(void *);
+typedef void *(*rbench_call2)(void *, void *);
+typedef void *(*rbench_call3)(void *, void *, void *);
+
+#ifdef __cplusplus
+void rbench_add_function(rbench_t *rp, const char *name, const char *group, void (*call)()) {
+#else
+void rbench_add_function(rbench_t *rp, const char *name, const char *group, void *call) {
+#endif
+    rbench_function_t *f = &rp->functions[rp->function_count];
+    rp->function_count++;
+    f->average_execution_time = 0;
+    f->total_execution_time = 0;
+    f->times_executed = 0;
+    f->call = call;
+    strcpy(f->name, name);
+    strcpy(f->group, group);
+}
+
+void rbench_reset_function(rbench_function_t *f) {
+    f->average_execution_time = 0;
+    f->times_executed = 0;
+    f->total_execution_time = 0;
+}
+
+void rbench_reset(rbench_t *rp) {
+    for (unsigned int i = 0; i < rp->function_count; i++) {
+        rbench_reset_function(&rp->functions[i]);
+    }
+}
+int rbench_get_winner_index(rbench_t *r) {
+    int winner = 0;
+    nsecs_t time = 0;
+    for (unsigned int i = 0; i < r->function_count; i++) {
+        if (time == 0 || r->functions[i].total_execution_time < time) {
+            winner = i;
+            time = r->functions[i].total_execution_time;
+        }
+    }
+    return winner;
+}
+bool rbench_was_last_function(rbench_t *r) {
+    for (unsigned int i = 0; i < r->function_count; i++) {
+        if (i == r->function_count - 1 && r->current == &r->functions[i])
+            return true;
+    }
+    return false;
+}
+
+rbench_function_t *rbench_execute_prepare(rbench_t *r, int findex, long times, int argc) {
+    rbench_toggle_stdout(r);
+    if (findex == 0) {
+        r->execution_time = 0;
+    }
+    rbench_function_t *rf = &r->functions[findex];
+    rf->argc = argc;
+    rbf = rf;
+    r->current = rf;
+    if (r->show_progress)
+        r->progress_bar = rprogressbar_new(0, times, 20, stderr);
+    r->times = times;
+    // printf("   %s:%s gets executed for %ld times with %d
+    // arguments.\n",rf->group, rf->name, times,argc);
+    rbench_reset_function(rf);
+
+    return rf;
+}
+void rbench_execute_finish(rbench_t *r) {
+    rbench_toggle_stdout(r);
+    if (r->progress_bar) {
+        free(r->progress_bar);
+        r->progress_bar = NULL;
+    }
+    r->current->average_execution_time = r->current->total_execution_time / r->current->times_executed;
+    ;
+    // printf("   %s:%s finished executing in
+    // %s\n",r->current->group,r->current->name,
+    // format_time(r->current->total_execution_time));
+    // rbench_show_results_function(r->current);
+    if (rbench_was_last_function(r)) {
+        rbench_restore_stdout(r);
+        unsigned int winner_index = rbench_get_winner_index(r);
+        r->winner = winner_index + 1;
+        if (!r->silent)
+            rprintgf(stderr, "Benchmark results:\n");
+        nsecs_t total_time = 0;
+
+        for (unsigned int i = 0; i < r->function_count; i++) {
+            rbf = &r->functions[i];
+            total_time += rbf->total_execution_time;
+            bool is_winner = winner_index == i;
+            if (is_winner) {
+                if (!r->silent)
+                    rprintyf(stderr, " > %s:%s:%s\n", format_time(rbf->total_execution_time), rbf->group, rbf->name);
+            } else {
+                if (!r->silent)
+                    rprintbf(stderr, "   %s:%s:%s\n", format_time(rbf->total_execution_time), rbf->group, rbf->name);
+            }
+        }
+        if (!r->silent)
+            rprintgf(stderr, "Total execution time: %s\n", format_time(total_time));
+    }
+    rbench_restore_stdout(r);
+    rbf = NULL;
+    r->current = NULL;
+}
+struct rbench_t *rbench_execute(rbench_t *r, long times) {
+
+    for (unsigned int i = 0; i < r->function_count; i++) {
+
+        rbench_function_t *f = rbench_execute_prepare(r, i, times, 0);
+        rbench_call c = (rbench_call)f->call;
+        nsecs_t start = nsecs();
+        f->first = true;
+        c();
+        f->first = false;
+        f->last = false;
+        f->times_executed++;
+        for (int j = 1; j < times; j++) {
+            c();
+            f->times_executed++;
+            f->last = f->times_executed == r->times - 1;
+            if (r->progress_bar) {
+                rprogressbar_update(r->progress_bar, f->times_executed);
+            }
+        }
+        f->total_execution_time = nsecs() - start;
+        r->execution_time += f->total_execution_time;
+        rbench_execute_finish(r);
+    }
+    return r;
+}
+
+struct rbench_t *rbench_execute1(rbench_t *r, long times, void *arg1) {
+
+    for (unsigned int i = 0; i < r->function_count; i++) {
+        rbench_function_t *f = rbench_execute_prepare(r, i, times, 1);
+        rbench_call1 c = (rbench_call1)f->call;
+        nsecs_t start = nsecs();
+        f->first = true;
+        c(arg1);
+        f->first = false;
+        f->last = false;
+        f->times_executed++;
+        for (int j = 1; j < times; j++) {
+            c(arg1);
+            f->times_executed++;
+            f->last = f->times_executed == r->times - 1;
+            if (r->progress_bar) {
+                rprogressbar_update(r->progress_bar, f->times_executed);
+            }
+        }
+        f->total_execution_time = nsecs() - start;
+        r->execution_time += f->total_execution_time;
+        rbench_execute_finish(r);
+    }
+    return r;
+}
+
+struct rbench_t *rbench_execute2(rbench_t *r, long times, void *arg1, void *arg2) {
+
+    for (unsigned int i = 0; i < r->function_count; i++) {
+        rbench_function_t *f = rbench_execute_prepare(r, i, times, 2);
+        rbench_call2 c = (rbench_call2)f->call;
+        nsecs_t start = nsecs();
+        f->first = true;
+        c(arg1, arg2);
+        f->first = false;
+        f->last = false;
+        f->times_executed++;
+        for (int j = 1; j < times; j++) {
+            c(arg1, arg2);
+            f->times_executed++;
+            f->last = f->times_executed == r->times - 1;
+            if (r->progress_bar) {
+                rprogressbar_update(r->progress_bar, f->times_executed);
+            }
+        }
+        f->total_execution_time = nsecs() - start;
+        r->execution_time += f->total_execution_time;
+        rbench_execute_finish(r);
+    }
+    return r;
+}
+
+struct rbench_t *rbench_execute3(rbench_t *r, long times, void *arg1, void *arg2, void *arg3) {
+
+    for (unsigned int i = 0; i < r->function_count; i++) {
+        rbench_function_t *f = rbench_execute_prepare(r, i, times, 3);
+
+        rbench_call3 c = (rbench_call3)f->call;
+        nsecs_t start = nsecs();
+        f->first = true;
+        c(arg1, arg2, arg3);
+        f->first = false;
+        f->last = false;
+        f->times_executed++;
+        for (int j = 1; j < times; j++) {
+            c(arg1, arg2, arg3);
+            f->times_executed++;
+            f->last = f->times_executed == r->times - 1;
+            if (r->progress_bar) {
+                rprogressbar_update(r->progress_bar, f->times_executed);
+            }
+        }
+        f->total_execution_time = nsecs() - start;
+        rbench_execute_finish(r);
+    }
+    return r;
+}
+
+rbench_t *rbench_new() {
+
+    rbench_t *r = (rbench_t *)malloc(sizeof(rbench_t));
+    memset(r, 0, sizeof(rbench_t));
+    r->add_function = rbench_add_function;
+    r->rbench_reset = rbench_reset;
+    r->execute1 = rbench_execute1;
+    r->execute2 = rbench_execute2;
+    r->execute3 = rbench_execute3;
+    r->execute = rbench_execute;
+    r->stdout = true;
+    r->silent = false;
+    r->winner = 0;
+    r->show_progress = true;
+    return r;
+}
+void rbench_free(rbench_t *r) { free(r); }
+
+#endif
+bool check_lcov() {
+    char buffer[1024 * 64];
+    FILE *fp;
+    fp = popen("lcov --help", "r");
+    if (fp == NULL) {
+        return false;
+    }
+    if (fgets(buffer, sizeof(buffer), fp) == NULL) {
+        return false;
+    }
+    pclose(fp);
+    return strstr(buffer, "lcov: not found") ? false : true;
+}
+
+int rcov_main(int argc, char *argv[]) {
+    if (argc < 2) {
+        printf("Usage: [source.c]\n");
+        return 1;
+    }
+    char argstr[4096] = {0};
+    for (int i = 2; i < argc; i++) {
+        strcat(argstr, argv[i]);
+        strcat(argstr, " ");
+    }
+    if (!check_lcov()) {
+
+        printf("lcov is not installed. Please execute `sudo apt install lcov`.\n");
+        return 1;
+    }
+    char *source_file = argv[1];
+    char *commands[] = {"rm -f *.gcda   2>/dev/null",
+                        "rm -f *.gcno   2>/dev/null",
+                        "rm -f %s.coverage.info   2>/dev/null",
+                        "gcc -pg -fprofile-arcs -ftest-coverage -g -o %s_coverage.o %s",
+                        "./%s_coverage.o",
+                        "lcov --capture --directory . --output-file %s.coverage.info",
+                        "genhtml %s.coverage.info --output-directory /tmp/%s.coverage",
+                        "rm -f *.gcda   2>/dev/null",
+                        "rm -f *.gcno   2>/dev/null",
+                        "rm -f %s.coverage.info   2>/dev/null", //"cat gmon.out",
+
+                        "gprof %s_coverage.o gmon.out > output.rcov_analysis",
+
+                        "rm -f gmon.out",
+                        "cat output.rcov_analysis",
+                        "rm output.rcov_analysis",
+                        "rm -f %s_coverage.o",
+
+                        "google-chrome /tmp/%s.coverage/index.html"};
+    uint command_count = sizeof(commands) / sizeof(commands[0]);
+    RBENCH(1,{
+        for (uint i = 0; i < command_count; i++) {
+            char *formatted_command = sbuf("");
+            sprintf(formatted_command, commands[i], source_file, source_file);
+            // printf("%s\n", formatted_command);
+            if (formatted_command[0] == '.' && formatted_command[1] == '/') {
+                strcat(formatted_command, " ");
+                strcat(formatted_command, argstr);
+            }
+
+            if (system(formatted_command)) {
+                printf("`%s` returned non-zero code.\n", formatted_command);
+            }
+        });
+    }
+    return 0;
+}
+#endif
+
+#ifndef RHTTP_H
+#define RHTTP_H
+#include <arpa/inet.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#define BUFF_SIZE 8096
+#define RHTTP_MAX_CONNECTIONS 100
+
+int rhttp_opt_error = 1;
+int rhttp_opt_warn = 1;
+int rhttp_opt_info = 1;
+int rhttp_opt_port = 8080;
+int rhttp_opt_debug = 0;
+int rhttp_opt_request_logging = 0;
+int rhttp_sock = 0;
+int rhttp_opt_buffered = 0;
+int rhttp_c = 0;
+int rhttp_c_mutex_initialized = 0;
+pthread_mutex_t rhttp_c_mutex;
+char rhttp_opt_host[1024] = "0.0.0.0";
+unsigned int rhttp_connections_handled = 0;
+
+typedef struct rhttp_header_t {
+    char *name;
+    char *value;
+    struct rhttp_header_t *next;
+} rhttp_header_t;
+
+typedef struct rhttp_request_t {
+    int c;
+    int closed;
+    bool keep_alive;
+    nsecs_t start;
+    char *raw;
+    char *line;
+    char *body;
+    char *method;
+    char *path;
+    char *version;
+    void *context;
+    unsigned int bytes_received;
+    rhttp_header_t *headers;
+} rhttp_request_t;
+
+char *rhttp_current_timestamp() {
+    time_t current_time;
+    time(&current_time);
+    struct tm *local_time = localtime(&current_time);
+    static char time_string[100];
+    time_string[0] = 0;
+    strftime(time_string, sizeof(time_string), "%Y-%m-%d %H:%M:%S", local_time);
+
+    return time_string;
+}
+
+void rhttp_logs(const char *prefix, const char *level, const char *format, va_list args) {
+    char buf[strlen(format) + BUFSIZ + 1];
+    buf[0] = 0;
+    sprintf(buf, "%s%s %s %s\e[0m", prefix, rhttp_current_timestamp(), level, format);
+    vfprintf(stdout, buf, args);
+}
+void rhttp_log_info(const char *format, ...) {
+    if (!rhttp_opt_info)
+        return;
+    va_list args;
+    va_start(args, format);
+    rhttp_logs("\e[32m", "INFO ", format, args);
+    va_end(args);
+}
+void rhttp_log_debug(const char *format, ...) {
+    if (!rhttp_opt_debug)
+        return;
+    va_list args;
+    va_start(args, format);
+    if (rhttp_opt_debug)
+        rhttp_logs("\e[33m", "DEBUG", format, args);
+
+    va_end(args);
+}
+void rhttp_log_warn(const char *format, ...) {
+    if (!rhttp_opt_warn)
+        return;
+    va_list args;
+    va_start(args, format);
+    rhttp_logs("\e[34m", "WARN ", format, args);
+
+    va_end(args);
+}
+void rhttp_log_error(const char *format, ...) {
+    if (!rhttp_opt_error)
+        return;
+    va_list args;
+    va_start(args, format);
+    rhttp_logs("\e[35m", "ERROR", format, args);
+
+    va_end(args);
+}
+
+void http_request_init(rhttp_request_t *r) {
+    r->raw = NULL;
+    r->line = NULL;
+    r->body = NULL;
+    r->method = NULL;
+    r->path = NULL;
+    r->version = NULL;
+    r->start = 0;
+    r->headers = NULL;
+    r->bytes_received = 0;
+    r->closed = 0;
+}
+
+void rhttp_free_header(rhttp_header_t *h) {
+    if (!h)
+        return;
+    rhttp_header_t *next = h->next;
+    free(h->name);
+    free(h->value);
+    free(h);
+    if (next)
+        rhttp_free_header(next);
+}
+void rhttp_rhttp_free_headers(rhttp_request_t *r) {
+    if (!r->headers)
+        return;
+    rhttp_free_header(r->headers);
+    r->headers = NULL;
+}
+
+rhttp_header_t *rhttp_parse_headers(rhttp_request_t *s) {
+    int first = 1;
+    char *body = strdup(s->body);
+    char *body_original = body;
+    while (body && *body) {
+        char *line = __strtok_r(first ? body : NULL, "\r\n", &body);
+        if (!line)
+            break;
+        rhttp_header_t *h = (rhttp_header_t *)malloc(sizeof(rhttp_header_t));
+        h->name = NULL;
+        h->value = NULL;
+        h->next = NULL;
+        char *name = __strtok_r(line, ": ", &line);
+        first = 0;
+        if (!name) {
+            rhttp_free_header(h);
+            break;
+        }
+        h->name = strdup(name);
+        char *value = __strtok_r(NULL, "\r\n", &line);
+        if (!value) {
+            rhttp_free_header(h);
+            break;
+        }
+        h->value = value ? strdup(value + 1) : strdup("");
+        h->next = s->headers;
+        s->headers = h;
+    }
+    free(body_original);
+    return s->headers;
+}
+
+void rhttp_free_request(rhttp_request_t *r) {
+    if (r->raw) {
+        free(r->raw);
+        free(r->body);
+        free(r->method);
+        free(r->path);
+        free(r->version);
+        rhttp_rhttp_free_headers(r);
+    }
+    free(r);
+}
+
+long rhttp_header_get_long(rhttp_request_t *r, const char *name) {
+    rhttp_header_t *h = r->headers;
+    while (h) {
+        if (!strcmp(h->name, name))
+            return strtol(h->value, NULL, 10);
+        h = h->next;
+    }
+    return -1;
+}
+char *rhttp_header_get_string(rhttp_request_t *r, const char *name) {
+    rhttp_header_t *h = r->headers;
+    while (h) {
+        if (!strcmp(h->name, name))
+            return h->value && *h->value ? h->value : NULL;
+        h = h->next;
+    }
+    return NULL;
+}
+
+void rhttp_print_header(rhttp_header_t *h) { rhttp_log_debug("Header: <%s> \"%s\"\n", h->name, h->value); }
+void rhttp_print_headers(rhttp_header_t *h) {
+    while (h) {
+        rhttp_print_header(h);
+        h = h->next;
+    }
+}
+void rhttp_print_request_line(rhttp_request_t *r) { rhttp_log_info("%s %s %s\n", r->method, r->path, r->version); }
+void rhttp_print_request(rhttp_request_t *r) {
+    rhttp_print_request_line(r);
+    if (rhttp_opt_debug)
+        rhttp_print_headers(r->headers);
+}
+void rhttp_close(rhttp_request_t *r) {
+    if (!r)
+        return;
+    if (!r->closed)
+        close(r->c);
+    rhttp_free_request(r);
+}
+rhttp_request_t *rhttp_parse_request(int s) {
+    rhttp_request_t *request = (rhttp_request_t *)malloc(sizeof(rhttp_request_t));
+    http_request_init(request);
+    char buf[BUFF_SIZE] = {0};
+    request->c = s;
+    int breceived = 0;
+    while (!rstrendswith(buf, "\r\n\r\n")) {
+        int chunk_size = read(s, buf + breceived, 1);
+        if (chunk_size <= 0) {
+            close(request->c);
+            request->closed = 1;
+            return request;
+        }
+        breceived += chunk_size;
+    }
+    if (breceived <= 0) {
+        close(request->c);
+        request->closed = 1;
+        return request;
+    }
+    buf[breceived] = '\0';
+    char *original_buf = buf;
+
+    char *b = original_buf;
+    request->raw = strdup(b);
+    b = original_buf;
+    char *line = strtok(b, "\r\n");
+    b = original_buf;
+    char *body = b + strlen(line) + 2;
+    request->body = strdup(body);
+    b = original_buf;
+    char *method = strtok(b, " ");
+    char *path = strtok(NULL, " ");
+    char *version = strtok(NULL, " ");
+    request->bytes_received = breceived;
+    request->line = line;
+    request->start = nsecs();
+    request->method = strdup(method);
+    request->path = strdup(path);
+    request->version = strdup(version);
+    request->headers = NULL;
+    request->keep_alive = false;
+    if (rhttp_parse_headers(request)) {
+        char *keep_alive_string = rhttp_header_get_string(request, "Connection");
+        if (keep_alive_string && !strcmp(keep_alive_string, "keep-alive")) {
+            request->keep_alive = 1;
+        }
+    }
+    return request;
+}
+
+void rhttp_close_server() {
+    close(rhttp_sock);
+    close(rhttp_c);
+    printf("Connections handled: %d\n", rhttp_connections_handled);
+    printf("Gracefully closed\n");
+    exit(0);
+}
+
+size_t rhttp_send_drain(int s, void *tsend, size_t to_send_len) {
+    if (to_send_len == 0 && *(unsigned char *)tsend) {
+        to_send_len = strlen(tsend);
+    }
+    unsigned char *to_send = (unsigned char *)malloc(to_send_len);
+    unsigned char *to_send_original = to_send;
+
+    memcpy(to_send, tsend, to_send_len);
+    // to_send[to_send_len] = '\0';
+    long bytes_sent = 0;
+    long bytes_sent_total = 0;
+    while (1) {
+        bytes_sent = send(s, to_send + bytes_sent_total, to_send_len - bytes_sent_total, 0);
+        if (bytes_sent <= 0) {
+            bytes_sent_total = 0;
+            break;
+        }
+        bytes_sent_total += bytes_sent;
+
+        if (bytes_sent_total == (long)to_send_len) {
+            break;
+        } else if (!bytes_sent) {
+            bytes_sent_total = 0;
+            // error
+            break;
+        } else {
+            rhttp_log_info("Extra send of %d/%d bytes.\n", bytes_sent_total, to_send_len);
+        }
+    }
+
+    free(to_send_original);
+    return bytes_sent_total;
+}
+
+typedef int (*rhttp_request_handler_t)(rhttp_request_t *r);
+
+void rhttp_serve(const char *host, int port, int backlog, int request_logging, int request_debug, rhttp_request_handler_t handler,
+                 void *context) {
+    signal(SIGPIPE, SIG_IGN);
+    rhttp_sock = socket(AF_INET, SOCK_STREAM, 0);
+    struct sockaddr_in addr;
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = inet_addr(host ? host : "0.0.0.0");
+    rhttp_opt_debug = request_debug;
+    rhttp_opt_request_logging = request_logging;
+    int opt = 1;
+    setsockopt(rhttp_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+    if (bind(rhttp_sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        printf("Binding error\n");
+        exit(1);
+    }
+    listen(rhttp_sock, backlog);
+    while (1) {
+        struct sockaddr_in client_addr;
+        int addrlen = sizeof(client_addr);
+
+        rhttp_c = accept(rhttp_sock, (struct sockaddr *)&client_addr, (socklen_t *)&addrlen);
+
+        rhttp_connections_handled++;
+        while (true) {
+            rhttp_request_t *r = rhttp_parse_request(rhttp_c);
+            r->context = context;
+            if (!r->closed) {
+                if (!handler(r) && !r->closed) {
+                    rhttp_close(r);
+                }
+            }
+            if (!r->keep_alive && !r->closed) {
+                rhttp_close(r);
+            } else if (r->keep_alive && !r->closed) {
+            }
+            if (r->closed) {
+                break;
+            }
+            rhttp_free_request(r);
+        }
+    }
+}
+
+unsigned int rhttp_calculate_number_char_count(unsigned int number) {
+    unsigned int width = 1;
+    unsigned int tcounter = number;
+    while (tcounter / 10 >= 1) {
+        tcounter = tcounter / 10;
+        width++;
+    }
+    return width;
+}
+
+int rhttp_file_response(rhttp_request_t *r, char *path) {
+    if (!*path)
+        return 0;
+    FILE *f = fopen(path, "rb");
+    if (f == NULL)
+        return 0;
+    size_t file_size = rfile_size(path);
+    char response[1024] = {0};
+    char content_type_header[100] = {0};
+    char *ext = strstr(path, ".");
+    char *text_extensions = ".h,.c,.html";
+    if (strstr(text_extensions, ext)) {
+        sprintf(content_type_header, "Content-Type: %s\r\n", "text/html");
+    }
+    sprintf(response, "HTTP/1.1 200 OK\r\n%sContent-Length:%ld\r\n\r\n", content_type_header, file_size);
+    if (!rhttp_send_drain(r->c, response, 0)) {
+        rhttp_log_error("Error sending file: %s\n", path);
+    }
+    size_t bytes = 0;
+    size_t bytes_sent = 0;
+    unsigned char file_buff[1024];
+    while ((bytes = fread(file_buff, sizeof(char), sizeof(file_buff), f))) {
+        if (!rhttp_send_drain(r->c, file_buff, bytes)) {
+            rhttp_log_error("Error sending file during chunking: %s\n", path);
+        }
+        bytes_sent += bytes;
+    }
+    if (bytes_sent != file_size) {
+        rhttp_send_drain(r->c, file_buff, file_size - bytes_sent);
+    }
+    close(r->c);
+    fclose(f);
+    return 1;
+};
+
+int rhttp_file_request_handler(rhttp_request_t *r) {
+    char *path = r->path;
+    while (*path == '/' || *path == '.')
+        path++;
+    if (strstr(path, "..")) {
+        return 0;
+    }
+    return rhttp_file_response(r, path);
+};
+
+unsigned int counter = 100000000;
+int rhttp_counter_request_handler(rhttp_request_t *r) {
+    if (!strncmp(r->path, "/counter", strlen("/counter"))) {
+        counter++;
+        unsigned int width = rhttp_calculate_number_char_count(counter);
+        char to_send2[1024] = {0};
+        sprintf(to_send2,
+                "HTTP/1.1 200 OK\r\nContent-Length: %d\r\nConnection: "
+                "close\r\n\r\n%d",
+                width, counter);
+        rhttp_send_drain(r->c, to_send2, 0);
+        close(r->c);
+        return 1;
+    }
+    return 0;
+}
+int rhttp_root_request_handler(rhttp_request_t *r) {
+    if (!strcmp(r->path, "/")) {
+        char to_send[1024] = {0};
+        sprintf(to_send, "HTTP/1.1 200 OK\r\nContent-Length: 3\r\nConnection: "
+                         "close\r\n\r\nOk!");
+        rhttp_send_drain(r->c, to_send, 0);
+        close(r->c);
+        return 1;
+    }
+    return 0;
+}
+int rhttp_error_404_handler(rhttp_request_t *r) {
+    char to_send[1024] = {0};
+    sprintf(to_send, "HTTP/1.1 404 Document not found\r\nContent-Length: "
+                     "0\r\nConnection: close\r\n\r\n");
+    rhttp_send_drain(r->c, to_send, 0);
+    close(r->c);
+    return 1;
+}
+
+int rhttp_default_request_handler(rhttp_request_t *r) {
+    if (rhttp_opt_debug || rhttp_opt_request_logging)
+        rhttp_print_request(r);
+    if (rhttp_counter_request_handler(r)) {
+        // Counter handler
+        rhttp_log_info("Counter handler found for: %s\n", r->path);
+
+    } else if (rhttp_root_request_handler(r)) {
+        // Root handler
+        rhttp_log_info("Root handler found for: %s\n", r->path);
+    } else if (rhttp_file_request_handler(r)) {
+        rhttp_log_info("File %s sent\n", r->path);
+    } else if (rhttp_error_404_handler(r)) {
+        rhttp_log_warn("Error 404 for: %s\n", r->path);
+        // Error handler
+    } else {
+        rhttp_log_warn("No handler found for: %s\n", r->path);
+        close(rhttp_c);
+    }
+    return 0;
+}
+
+int rhttp_main(int argc, char *argv[]) {
+    setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
+    int opt;
+    while ((opt = getopt(argc, argv, "p:drh:bewi")) != -1) {
+        switch (opt) {
+        case 'i':
+            rhttp_opt_info = 1;
+            rhttp_opt_warn = 1;
+            rhttp_opt_error = 1;
+            break;
+        case 'e':
+            rhttp_opt_error = 1;
+            rhttp_opt_warn = 0;
+            rhttp_opt_info = 0;
+            break;
+        case 'w':
+            rhttp_opt_warn = 1;
+            rhttp_opt_error = 1;
+            rhttp_opt_info = 0;
+            break;
+        case 'p':
+            rhttp_opt_port = atoi(optarg);
+            break;
+        case 'b':
+            rhttp_opt_buffered = 1;
+            printf("Logging is buffered. Output may be incomplete.\n");
+            break;
+        case 'h':
+            strcpy(rhttp_opt_host, optarg);
+            break;
+        case 'd':
+            printf("Debug enabled\n");
+            rhttp_opt_debug = 1;
+            rhttp_opt_warn = 1;
+            rhttp_opt_info = 1;
+            rhttp_opt_error = 1;
+            break;
+        case 'r':
+            printf("Request logging enabled\n");
+            rhttp_opt_request_logging = 1;
+            break;
+        default:
+            printf("Usage: %s [-p port] [-h host] [-b]\n", argv[0]);
+            return 1;
+        }
+    }
+
+    printf("Starting server on: %s:%d\n", rhttp_opt_host, rhttp_opt_port);
+    if (rhttp_opt_buffered)
+        setvbuf(stdout, NULL, _IOFBF, BUFSIZ);
+
+    rhttp_serve(rhttp_opt_host, rhttp_opt_port, 1024, rhttp_opt_request_logging, rhttp_opt_debug, rhttp_default_request_handler, NULL);
+
+    return 0;
+}
+
+/* CLIENT CODE */
+
+typedef struct rhttp_client_request_t {
+    char *host;
+    int port;
+    char *path;
+    bool is_done;
+    char *request;
+    char *response;
+    pthread_t thread;
+    int bytes_received;
+} rhttp_client_request_t;
+
+rhttp_client_request_t *rhttp_create_request(const char *host, int port, const char *path) {
+    rhttp_client_request_t *r = (rhttp_client_request_t *)malloc(sizeof(rhttp_client_request_t));
+    char request_line[4096] = {0};
+    sprintf(request_line,
+            "GET %s HTTP/1.1\r\n"
+            "Host: localhost:8000\r\n"
+            "Connection: close\r\n"
+            "Accept: */*\r\n"
+            "User-Agent: mhttpc\r\n"
+            "Accept-Language: en-US,en;q=0.5\r\n"
+            "Accept-Encoding: gzip, deflate\r\n"
+            "\r\n",
+            path);
+    r->request = strdup(request_line);
+    r->host = strdup(host);
+    r->port = port;
+    r->path = strdup(path);
+    r->is_done = false;
+    r->response = NULL;
+    r->bytes_received = 0;
+    return r;
+}
+
+int rhttp_execute_request(rhttp_client_request_t *r) {
+    int s = socket(AF_INET, SOCK_STREAM, 0);
+    struct sockaddr_in addr;
+
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(r->port);
+    addr.sin_addr.s_addr = inet_addr(r->host);
+
+    if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+        return 0;
+    }
+
+    send(s, r->request, strlen(r->request), 0);
+    char buf[1024 * 1024] = {0};
+    int ret = recv(s, buf, 1024 * 1024, 0);
+    if (ret > 0) {
+        r->response = strdup(buf);
+    }
+
+    close(s);
+    return ret;
+}
+void rhttp_reset_request(rhttp_client_request_t *r) {
+    free(r->response);
+    r->is_done = false;
+    r->response = NULL;
+    r->bytes_received = 0;
+}
+void rhttp_free_client_request(rhttp_client_request_t *r) {
+    if (r->request)
+        free(r->request);
+    if (r->response)
+        free(r->response);
+    if (r->host)
+        free(r->host);
+    if (r->path)
+        free(r->path);
+    free(r);
+}
+
+void rhttp_client_bench(int workers, int times, const char *host, int port, const char *path) {
+    rhttp_client_request_t *requests[workers];
+    while (times > 0) {
+
+        for (int i = 0; i < workers && times; i++) {
+            requests[i] = rhttp_create_request(host, port, path);
+            rhttp_execute_request(requests[i]);
+            times--;
+        }
+    }
+}
+char *rhttp_client_get(const char *host, int port, const char *path) {
+    if (!rhttp_c_mutex_initialized) {
+        rhttp_c_mutex_initialized = 1;
+        pthread_mutex_init(&rhttp_c_mutex, NULL);
+    }
+    char http_response[1024 * 1024];
+    http_response[0] = 0;
+    rhttp_client_request_t *r = rhttp_create_request(host, port, path);
+    unsigned int reconnects = 0;
+    unsigned int reconnects_max = 100000;
+    while (!rhttp_execute_request(r)) {
+        reconnects++;
+        tick();
+        if (reconnects == reconnects_max) {
+            fprintf(stderr, "Maxium reconnects exceeded for %s:%d\n", host, port);
+            rhttp_free_client_request(r);
+            return NULL;
+        }
+    }
+    r->is_done = true;
+    char *body = r->response ? strstr(r->response, "\r\n\r\n") : NULL;
+    pthread_mutex_lock(&rhttp_c_mutex);
+    if (body) {
+        strcpy(http_response, body + 4);
+    } else {
+        strcpy(http_response, r->response);
+    }
+    rhttp_free_client_request(r);
+    char *result = sbuf(http_response);
+    pthread_mutex_unlock(&rhttp_c_mutex);
+    return result;
+}
+/*END CLIENT CODE */
+#endif
+
+#ifndef RJSON_H
+#define RJSON_H
+
+typedef struct rjson_t {
+    char *content;
+    size_t length;
+    size_t size;
+} rjson_t;
+
+rjson_t *rjson() {
+    rjson_t *json = rmalloc(sizeof(rjson_t));
+    json->size = 1024;
+    json->length = 0;
+    json->content = (char *)rmalloc(json->size);
+    json->content[0] = 0;
+    return json;
+}
+
+void rjson_write(rjson_t *rjs, char *content) {
+    size_t len = strlen(content);
+    while (rjs->size < rjs->length + len + 1) {
+        rjs->content = realloc(rjs->content, rjs->size + 1024);
+        rjs->size += 1024;
+    }
+    strcat(rjs->content, content);
+    rjs->length += len;
+}
+
+void rjson_object_start(rjson_t *rjs) {
+    if (rstrendswith(rjs->content, "}"))
+        rjson_write(rjs, ",");
+    rjson_write(rjs, "{");
+}
+void rjson_object_close(rjson_t *rjs) {
+    if (rstrendswith(rjs->content, ",")) {
+        rjs->content[rjs->length - 1] = 0;
+        rjs->length--;
+    }
+    rjson_write(rjs, "}");
+}
+void rjson_array_start(rjson_t *rjs) {
+    if (rjs->length && (rstrendswith(rjs->content, "}") || rstrendswith(rjs->content, "]")))
+        rjson_write(rjs, ",");
+    rjson_write(rjs, "[");
+}
+void rjson_array_close(rjson_t *rjs) {
+    if (rstrendswith(rjs->content, ",")) {
+        rjs->content[rjs->length - 1] = 0;
+        rjs->length--;
+    }
+    rjson_write(rjs, "]");
+}
+
+void rjson_kv_string(rjson_t *rjs, char *key, char *value) {
+    if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
+        rjson_write(rjs, ",");
+    }
+    rjson_write(rjs, "\"");
+    rjson_write(rjs, key);
+    rjson_write(rjs, "\":\"");
+    char *value_str = (char *)rmalloc(strlen(value) + 4096);
+    rstraddslashes(value, value_str);
+    rjson_write(rjs, value_str);
+    free(value_str);
+    rjson_write(rjs, "\"");
+}
+
+void rjson_kv_int(rjson_t *rjs, char *key, ulonglong value) {
+    if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
+        rjson_write(rjs, ",");
+    }
+    rjson_write(rjs, "\"");
+    rjson_write(rjs, key);
+    rjson_write(rjs, "\":");
+    char value_str[100] = {0};
+    sprintf(value_str, "%lld", value);
+    rjson_write(rjs, value_str);
+}
+void rjson_kv_number(rjson_t *rjs, char *key, ulonglong value) {
+    if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
+        rjson_write(rjs, ",");
+    }
+    rjson_write(rjs, "\"");
+    rjson_write(rjs, key);
+    rjson_write(rjs, "\":");
+    rjson_write(rjs, "\"");
+
+    rjson_write(rjs, sbuf(rformat_number(value)));
+    rjson_write(rjs, "\"");
+}
+
+void rjson_kv_bool(rjson_t *rjs, char *key, int value) {
+    if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
+        rjson_write(rjs, ",");
+    }
+    rjson_write(rjs, "\"");
+    rjson_write(rjs, key);
+    rjson_write(rjs, "\":");
+    rjson_write(rjs, value > 0 ? "true" : "false");
+}
+
+void rjson_kv_duration(rjson_t *rjs, char *key, nsecs_t value) {
+    if (rjs->length && !rstrendswith(rjs->content, "{") && !rstrendswith(rjs->content, "[")) {
+        rjson_write(rjs, ",");
+    }
+    rjson_write(rjs, "\"");
+    rjson_write(rjs, key);
+    rjson_write(rjs, "\":");
+    rjson_write(rjs, "\"");
+
+    rjson_write(rjs, sbuf(format_time(value)));
+    rjson_write(rjs, "\"");
+}
+void rjson_free(rjson_t *rsj) {
+    free(rsj->content);
+    free(rsj);
+}
+
+void rjson_key(rjson_t *rsj, char *key) {
+    rjson_write(rsj, "\"");
+    rjson_write(rsj, key);
+    rjson_write(rsj, "\":");
+}
+#endif
+#ifndef RAUTOCOMPLETE_H
+#define RAUTOCOMPLETE_H
+#define R4_DEBUG
+#ifndef RREX4_H
+#define RREX4_H
+#include <assert.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define R4_DEBUG_a
+
+#ifdef R4_DEBUG
+static int _r4_debug = 1;
+#else
+static int _r4_debug = 0;
+#endif
+
+static char *_format_function_name(const char *name) {
+    static char result[100];
+    result[0] = 0;
+
+    char *new_name = (char *)name;
+    new_name += 11;
+    if (new_name[0] == '_')
+        new_name += 1;
+    if (strlen(new_name) == 0) {
+        return " -";
+    }
+    strcpy(result, new_name);
+    return result;
+}
+
+#define DEBUG_VALIDATE_FUNCTION                                                                                                            \
+    if (_r4_debug || r4->debug)                                                                                                            \
+        printf("DEBUG: %s %s <%s> \"%s\"\n", _format_function_name(__func__), r4->valid ? "valid" : "INVALID", r4->expr, r4->str);
+
+struct r4_t;
+
+void r4_enable_debug() { _r4_debug = true; }
+void r4_disable_debug() { _r4_debug = false; }
+
+typedef bool (*r4_function)(struct r4_t *);
+
+typedef struct r4_t {
+    bool debug;
+    bool valid;
+    bool in_block;
+    bool is_greedy;
+    bool in_range;
+    unsigned int backtracking;
+    unsigned int loop_count;
+    unsigned int in_group;
+    unsigned int match_count;
+    unsigned int validation_count;
+    unsigned int start;
+    unsigned int end;
+    unsigned int length;
+    bool (*functions[254])(struct r4_t *);
+    bool (*slash_functions[254])(struct r4_t *);
+    char *_str;
+    char *_expr;
+    char *match;
+    char *str;
+    char *expr;
+    char *str_previous;
+    char *expr_previous;
+    char **matches;
+} r4_t;
+
+static bool v4_initiated = false;
+typedef bool (*v4_function_map)(r4_t *);
+v4_function_map v4_function_map_global[256];
+v4_function_map v4_function_map_slash[256];
+v4_function_map v4_function_map_block[256];
+
+void r4_free_matches(r4_t *r) {
+    if (!r)
+        return;
+    if (r->match) {
+        free(r->match);
+        r->match = NULL;
+    }
+    if (!r->match_count) {
+        return;
+    }
+    for (unsigned i = 0; i < r->match_count; i++) {
+        free(r->matches[i]);
+    }
+    free(r->matches);
+    r->match_count = 0;
+    r->matches = NULL;
+}
+
+void r4_free(r4_t *r) {
+    if (!r)
+        return;
+    r4_free_matches(r);
+    free(r);
+}
+
+static bool r4_backtrack(r4_t *r4);
+static bool r4_validate(r4_t *r4);
+static void r4_match_add(r4_t *r4, char *extracted);
+
+static bool r4_validate_literal(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    if (!r4->valid)
+        return false;
+    if (*r4->str != *r4->expr) {
+        r4->valid = false;
+    } else {
+        r4->str++;
+    }
+    r4->expr++;
+    if (r4->in_block || r4->in_range || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+static bool r4_validate_question_mark(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->valid = true;
+    r4->expr++;
+    return r4_validate(r4);
+}
+
+static bool r4_validate_plus(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->expr++;
+    if (r4->valid == false) {
+        return r4_validate(r4);
+    }
+    char *expr_left = r4->expr_previous;
+    char *expr_right = r4->expr;
+    char *str = r4->str;
+    char *return_expr = NULL;
+    if (*expr_right == ')') {
+        return_expr = expr_right;
+        expr_right++;
+    }
+    r4->is_greedy = false;
+    r4->expr = expr_left;
+    while (r4->valid) {
+        if (*expr_right) {
+            r4->expr = expr_right;
+            r4->is_greedy = true;
+            if (r4_backtrack(r4)) {
+
+                if (return_expr) {
+                    r4->str = str;
+                    r4->expr = return_expr;
+                }
+                return r4_validate(r4);
+            } else {
+                r4->is_greedy = false;
+            }
+        }
+        r4->valid = true;
+        r4->expr = expr_left;
+        r4->str = str;
+        r4_validate(r4);
+        str = r4->str;
+    }
+    r4->is_greedy = true;
+    r4->valid = true;
+    r4->expr = return_expr ? return_expr : expr_right;
+    return r4_validate(r4);
+}
+
+static bool r4_validate_dollar(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->expr++;
+    r4->valid = *r4->str == 0;
+    return r4_validate(r4);
+}
+
+static bool r4_validate_roof(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    if (r4->str != r4->_str) {
+        return false;
+    }
+    r4->expr++;
+    return r4_validate(r4);
+}
+
+static bool r4_validate_dot(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    if (*r4->str == 0) {
+        return false;
+    }
+    r4->expr++;
+    r4->valid = *r4->str != '\n';
+    r4->str++;
+
+    if (r4->in_block || r4->in_range || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+
+static bool r4_validate_asterisk(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->expr++;
+    if (r4->valid == false) {
+        r4->valid = true;
+        return r4->valid;
+        // return r4_validate(r4);
+    }
+    char *expr_left = r4->expr_previous;
+    char *expr_right = r4->expr;
+    char *str = r4->str;
+    char *return_expr = NULL;
+    if (*expr_right == ')') {
+        return_expr = expr_right;
+        expr_right++;
+    }
+    r4->is_greedy = false;
+    r4->expr = expr_left;
+    while (r4->valid) {
+        if (*expr_right) {
+            r4->expr = expr_right;
+            r4->is_greedy = true;
+            if (r4_backtrack(r4)) {
+
+                if (return_expr) {
+                    r4->str = str;
+                    r4->expr = return_expr;
+                }
+                return r4_validate(r4);
+            } else {
+                r4->is_greedy = false;
+            }
+        }
+        r4->valid = true;
+        r4->expr = expr_left;
+        r4->str = str;
+        r4_validate(r4);
+        str = r4->str;
+    }
+    r4->is_greedy = true;
+    r4->valid = true;
+    r4->expr = return_expr ? return_expr : expr_right;
+    return r4_validate(r4);
+}
+
+static bool r4_validate_pipe(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->expr++;
+    if (r4->valid == true) {
+        return true;
+    } else {
+        r4->valid = true;
+    }
+    return r4_validate(r4);
+}
+
+static bool r4_validate_digit(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    if (!isdigit(*r4->str)) {
+        r4->valid = false;
+    } else {
+        r4->str++;
+    }
+    r4->expr++;
+    if (r4->in_block || r4->in_range || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+static bool r4_validate_not_digit(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    if (isdigit(*r4->str)) {
+        r4->valid = false;
+    } else {
+        r4->str++;
+    }
+    r4->expr++;
+
+    if (r4->in_block || r4->in_range || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+static bool r4_validate_word(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    if (!isalpha(*r4->str)) {
+        r4->valid = false;
+    } else {
+        r4->str++;
+    }
+    r4->expr++;
+
+    if (r4->in_block || r4->in_range || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+static bool r4_validate_not_word(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    if (isalpha(*r4->str)) {
+        r4->valid = false;
+    } else {
+        r4->str++;
+    }
+    r4->expr++;
+
+    if (r4->in_block || r4->in_range || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+
+static bool r4_isrange(char *s) {
+    if (!isalnum(*s)) {
+        return false;
+    }
+    if (*(s + 1) != '-') {
+        return false;
+    }
+    return isalnum(*(s + 2));
+}
+
+static bool r4_validate_block_open(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    if (r4->valid == false) {
+        return false;
+    }
+    char *expr_self = r4->expr;
+    r4->expr++;
+    bool reversed = *r4->expr == '^';
+    if (reversed) {
+        r4->expr++;
+    }
+
+    bool valid_once = false;
+    r4->in_block = true;
+    while (*r4->expr != ']') {
+        r4->valid = true;
+        if (r4_isrange(r4->expr)) {
+            char s = *r4->expr;
+            char e = *(r4->expr + 2);
+            r4->expr += 2;
+            if (s > e) {
+                char tempc = s;
+                s = e;
+                e = tempc;
+            }
+            if (*r4->str >= s && *r4->str <= e) {
+                if (!reversed) {
+                    r4->str++;
+                }
+                valid_once = true;
+                break;
+            } else {
+                r4->expr++;
+            }
+        } else if (r4_validate(r4)) {
+            valid_once = true;
+            if (reversed)
+                r4->str--;
+            break;
+        }
+    }
+    char *expr_end = strchr(r4->expr, ']');
+
+    r4->expr = expr_end ? expr_end : r4->expr;
+    r4->in_block = false;
+    r4->valid = expr_end && (!reversed ? valid_once : !valid_once);
+    r4->expr++;
+    r4->expr_previous = expr_self;
+
+    if (r4->in_range || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+
+static bool r4_validate_whitespace(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->valid = strchr("\r\t \n", *r4->str) != NULL;
+    r4->expr++;
+    if (r4->valid) {
+        r4->str++;
+    }
+    if (r4->in_range || r4->in_block || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+static bool r4_validate_not_whitespace(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->valid = strchr("\r\t \n", *r4->str) == NULL;
+    r4->expr++;
+    if (r4->valid) {
+        r4->str++;
+    }
+    if (r4->in_range || r4->in_block || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+
+static bool r4_validate_range(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION;
+    if (r4->valid == false) {
+        r4->expr++;
+        return false;
+    }
+    char *previous = r4->expr_previous;
+    r4->in_range = true;
+    r4->expr++;
+    unsigned int start = 0;
+    while (isdigit(*r4->expr)) {
+        start = 10 * start;
+        start += *r4->expr - '0';
+        r4->expr++;
+    }
+    if (start != 0)
+        start--;
+
+    unsigned int end = 0;
+    bool variable_end_range = false;
+    if (*r4->expr == ',') {
+        r4->expr++;
+        if (!isdigit(*r4->expr)) {
+            variable_end_range = true;
+        }
+    }
+    while (isdigit(*r4->expr)) {
+        end = end * 10;
+        end += *r4->expr - '0';
+        r4->expr++;
+    }
+    r4->expr++;
+
+    bool valid = true;
+    char *expr_right = r4->expr;
+    for (unsigned int i = 0; i < start; i++) {
+        r4->expr = previous;
+        valid = r4_validate(r4);
+        if (!*r4->str)
+            break;
+        if (!valid) {
+            break;
+        }
+    }
+    r4->expr = expr_right;
+    r4->in_range = false;
+    if (!r4->valid)
+        return false;
+    return r4_validate(r4);
+
+    for (unsigned int i = start; i < end; i++) {
+        r4->expr = previous;
+        valid = r4_validate(r4);
+        if (!valid) {
+            break;
+        }
+    }
+
+    while (variable_end_range) {
+        r4->in_range = false;
+        valid = r4_validate(r4);
+        r4->in_range = true;
+        if (valid) {
+            break;
+        }
+        r4->in_range = true;
+        valid = r4_validate(r4);
+        r4->in_range = false;
+        if (!valid) {
+            break;
+        }
+    }
+    r4->valid = valid;
+
+    return r4_validate(r4);
+}
+
+static bool r4_validate_group_close(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    return r4->valid;
+}
+
+static bool r4_validate_group_open(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    char *expr_previous = r4->expr_previous;
+    r4->expr++;
+    bool save_match = r4->in_group == 0;
+    r4->in_group++;
+    char *str_extract_start = r4->str;
+    bool valid = r4_validate(r4);
+
+    if (!valid || *r4->expr != ')') {
+        // this is a valid case if not everything between () matches
+        r4->in_group--;
+        if (save_match == false) {
+            r4->valid = true;
+        }
+
+        // Not direct return? Not sure
+        return r4_validate(r4);
+    }
+    // if(save_match){
+    //     r4->match_count++;
+    // }
+    if (save_match) {
+        char *str_extract_end = r4->str;
+        unsigned int extracted_length = str_extract_end - str_extract_start;
+        // strlen(str_extract_start) - strlen(str_extract_end);
+        char *str_extracted = (char *)calloc(sizeof(char), extracted_length + 1);
+        strncpy(str_extracted, str_extract_start, extracted_length);
+        r4_match_add(r4, str_extracted);
+    }
+    assert(*r4->expr == ')');
+    r4->expr++;
+    r4->in_group--;
+    r4->expr_previous = expr_previous;
+    return r4_validate(r4);
+}
+
+static bool r4_validate_slash(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    // The handling code for handling slashes is implemented in r4_validate
+    char *expr_previous = r4->expr_previous;
+    r4->expr++;
+    r4_function f = v4_function_map_slash[(int)*r4->expr];
+    r4->expr_previous = expr_previous;
+    return f(r4);
+}
+
+static void r4_match_add(r4_t *r4, char *extracted) {
+    r4->matches = (char **)realloc(r4->matches, (r4->match_count + 1) * sizeof(char *));
+    r4->matches[r4->match_count] = extracted;
+    r4->match_count++;
+}
+
+static bool r4_validate_word_boundary_start(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->expr++;
+    if (!r4->valid) {
+        return r4->valid;
+    }
+    r4->valid = isalpha(*r4->str) && (r4->str == r4->_str || !isalpha(*(r4->str - 1)));
+    if (r4->in_range || r4->in_block || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+static bool r4_validate_word_boundary_end(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->expr++;
+    if (!r4->valid) {
+        return r4->valid;
+    }
+    r4->valid = isalpha(*r4->str) && (*(r4->str + 1) == 0 || !isalpha(*(r4->str + 1)));
+    if (r4->in_range || r4->in_block || !r4->is_greedy) {
+        return r4->valid;
+    }
+    return r4_validate(r4);
+}
+
+static void v4_init_function_maps() {
+    if (v4_initiated)
+        return;
+    v4_initiated = true;
+    for (__uint8_t i = 0; i < 255; i++) {
+        v4_function_map_global[i] = r4_validate_literal;
+        v4_function_map_slash[i] = r4_validate_literal;
+        v4_function_map_block[i] = r4_validate_literal;
+    }
+    v4_function_map_global['*'] = r4_validate_asterisk;
+    v4_function_map_global['?'] = r4_validate_question_mark;
+    v4_function_map_global['+'] = r4_validate_plus;
+    v4_function_map_global['$'] = r4_validate_dollar;
+    v4_function_map_global['^'] = r4_validate_roof;
+    v4_function_map_global['.'] = r4_validate_dot;
+    v4_function_map_global['|'] = r4_validate_pipe;
+    v4_function_map_global['\\'] = r4_validate_slash;
+    v4_function_map_global['['] = r4_validate_block_open;
+    v4_function_map_global['{'] = r4_validate_range;
+    v4_function_map_global['('] = r4_validate_group_open;
+    v4_function_map_global[')'] = r4_validate_group_close;
+    v4_function_map_slash['b'] = r4_validate_word_boundary_start;
+    v4_function_map_slash['B'] = r4_validate_word_boundary_end;
+    v4_function_map_slash['d'] = r4_validate_digit;
+    v4_function_map_slash['w'] = r4_validate_word;
+    v4_function_map_slash['D'] = r4_validate_not_digit;
+    v4_function_map_slash['W'] = r4_validate_not_word;
+    v4_function_map_slash['s'] = r4_validate_whitespace;
+    v4_function_map_slash['S'] = r4_validate_not_whitespace;
+    v4_function_map_block['\\'] = r4_validate_slash;
+
+    v4_function_map_block['{'] = r4_validate_range;
+}
+
+void r4_init(r4_t *r4) {
+    v4_init_function_maps();
+    if (r4 == NULL)
+        return;
+    r4->debug = _r4_debug;
+    r4->valid = true;
+    r4->validation_count = 0;
+    r4->match_count = 0;
+    r4->start = 0;
+    r4->end = 0;
+    r4->length = 0;
+    r4->matches = NULL;
+}
+
+static bool r4_looks_behind(char c) { return strchr("?*+{", c) != NULL; }
+
+r4_t *r4_new() {
+    r4_t *r4 = (r4_t *)malloc(sizeof(r4_t));
+
+    r4_init(r4);
+
+    return r4;
+}
+
+static bool r4_pipe_next(r4_t *r4) {
+    char *expr = r4->expr;
+    while (*expr) {
+        if (*expr == '|') {
+            r4->expr = expr + 1;
+            r4->valid = true;
+            return true;
+        }
+        expr++;
+    }
+    return false;
+}
+
+static bool r4_backtrack(r4_t *r4) {
+    if (_r4_debug)
+        printf("\033[36mDEBUG: backtrack start (%d)\n", r4->backtracking);
+    r4->backtracking++;
+    char *str = r4->str;
+    char *expr = r4->expr;
+    bool result = r4_validate(r4);
+    r4->backtracking--;
+    if (result == false) {
+        r4->expr = expr;
+        r4->str = str;
+    }
+    if (_r4_debug)
+        printf("DEBUG: backtrack end (%d) result: %d %s\n", r4->backtracking, result, r4->backtracking == 0 ? "\033[0m" : "");
+    return result;
+}
+
+static bool r4_validate(r4_t *r4) {
+    DEBUG_VALIDATE_FUNCTION
+    r4->validation_count++;
+    char c_val = *r4->expr;
+    if (c_val == 0) {
+        return r4->valid;
+    }
+    if (!r4_looks_behind(c_val)) {
+        r4->expr_previous = r4->expr;
+    } else if (r4->expr == r4->_expr) {
+        // Regex may not start with a look behind ufnction
+        return false;
+    }
+
+    if (!r4->valid && !r4_looks_behind(*r4->expr)) {
+        if (!r4_pipe_next(r4)) {
+            return false;
+        }
+    }
+    r4_function f;
+    if (r4->in_block) {
+        f = v4_function_map_block[(int)c_val];
+    } else {
+        f = v4_function_map_global[(int)c_val];
+    }
+
+    r4->valid = f(r4);
+    return r4->valid;
+}
+
+char *r4_get_match(r4_t *r) {
+    char *match = (char *)malloc(r->length + 1);
+    strncpy(match, r->_str + r->start, r->length);
+    match[r->length] = 0;
+    return match;
+}
+
+static bool r4_search(r4_t *r) {
+    bool valid = true;
+    char *str_next = r->str;
+    while (*r->str) {
+        if (!(valid = r4_validate(r))) {
+            // Move next until we find a match
+            if (!r->backtracking) {
+                r->start++;
+            }
+            str_next++;
+            r->str = str_next;
+            r->expr = r->_expr;
+            r->valid = true;
+        } else {
+            /// HIGH DOUBT
+            if (!r->backtracking) {
+                // r->start = 0;
+            }
+            break;
+        }
+    }
+    r->valid = valid;
+    if (r->valid) {
+        r->end = strlen(r->_str) - strlen(r->str);
+        r->length = r->end - r->start;
+        r->match = r4_get_match(r);
+    }
+    return r->valid;
+}
+
+r4_t *r4(const char *str, const char *expr) {
+    r4_t *r = r4_new();
+    r->_str = (char *)str;
+    r->_expr = (char *)expr;
+    r->match = NULL;
+    r->str = r->_str;
+    r->expr = r->_expr;
+    r->str_previous = r->_str;
+    r->expr_previous = r->expr;
+    r->in_block = false;
+    r->is_greedy = true;
+    r->in_group = 0;
+    r->loop_count = 0;
+    r->backtracking = 0;
+    r->in_range = false;
+    r4_search(r);
+    return r;
+}
+
+r4_t *r4_next(r4_t *r, char *expr) {
+    if (expr) {
+        r->_expr = expr;
+    }
+    r->backtracking = 0;
+    r->expr = r->_expr;
+    r->is_greedy = true;
+    r->in_block = false;
+    r->in_range = false;
+    r->in_group = false;
+    r4_free_matches(r);
+    r4_search(r);
+    return r;
+}
+
+bool r4_match(char *str, char *expr) {
+    r4_t *r = r4(str, expr);
+    bool result = r->valid;
+    r4_free(r);
+    return result;
+}
+#endif
+#define rautocomplete_new rstring_list_new
+#define rautocomplete_free rstring_list_free
+#define rautocomplete_add rstring_list_add
+#define rautocomplete_find rstring_list_find
+#define rautocomplete_t rstring_list_t
+#define rautocomplete_contains rstring_list_contains
+
+char *r4_escape(char *content) {
+    size_t size = strlen(content) * 2 + 1;
+    char *escaped = (char *)calloc(size, sizeof(char));
+    char *espr = escaped;
+    char *to_escape = "?*+()[]{}^$\\";
+    *espr = '(';
+    espr++;
+    while (*content) {
+        if (strchr(to_escape, *content)) {
+            *espr = '\\';
+            espr++;
+        }
+        *espr = *content;
+        espr++;
+        content++;
+    }
+    *espr = '.';
+    espr++;
+    *espr = '+';
+    espr++;
+    *espr = ')';
+    espr++;
+    *espr = 0;
+    return escaped;
+}
+
+char *rautocomplete_find(rstring_list_t *list, char *expr) {
+    if (!list->count)
+        return NULL;
+    if (!expr || !strlen(expr))
+        return NULL;
+
+    char *escaped = r4_escape(expr);
+
+    for (unsigned int i = list->count - 1; i == 0; i--) {
+        char *match;
+        r4_t *r = r4(list->strings[i], escaped);
+        if (r->valid && r->match_count == 1) {
+            match = strdup(r->matches[0]);
+        }
+        r4_free(r);
+        if (match) {
+
+            free(escaped);
+            return match;
+        }
+    }
+    free(escaped);
+    return NULL;
+}
+#endif
+#ifndef RKEYTABLE_H
+#define RKEYTABLE_H
+/*
+    DERIVED FROM HASH TABLE K&R
+ */
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct rnklist {
+    struct rnklist *next;
+    struct rnklist *last;
+    char *name;
+    char *defn;
+} rnklist;
+
+static rnklist *rkeytab = NULL;
+
+rnklist *rlkget(char *s) {
+    rnklist *np;
+    for (np = rkeytab; np != NULL; np = np->next)
+        if (strcmp(s, np->name) == 0)
+            return np; // Found
+    return NULL;       // Not found
+}
+
+char *rkget(char *s) {
+    rnklist *np = rlkget(s);
+    return np ? np->defn : NULL;
+}
+
+rnklist *rkset(char *name, char *defn) {
+    rnklist *np;
+    if ((np = (rlkget(name))) == NULL) { // Not found
+        np = (rnklist *)malloc(sizeof(rnklist));
+        np->name = strdup(name);
+        np->next = NULL;
+        np->last = NULL;
+
+        if (defn) {
+            np->defn = strdup(defn);
+        } else {
+            np->defn = NULL;
+        }
+
+        if (rkeytab == NULL) {
+            rkeytab = np;
+            rkeytab->last = np;
+        } else {
+            if (rkeytab->last)
+                rkeytab->last->next = np;
+
+            rkeytab->last = np;
+        }
+    } else {
+        if (np->defn)
+            free((void *)np->defn);
+        if (defn) {
+            np->defn = strdup(defn);
+        } else {
+            np->defn = NULL;
+        }
+    }
+    return np;
+}
+#endif
+
+#ifndef RHASHTABLE_H
+#define RHASHTABLE_H
+/*
+    ORIGINAL SOURCE IS FROM K&R
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define HASHSIZE 101
+
+// Structure for the table entries
+typedef struct rnlist {
+    struct rnlist *next;
+    char *name;
+    char *defn;
+} rnlist;
+
+// Hash table array
+static rnlist *rhashtab[HASHSIZE];
+
+// Hash function
+unsigned rhash(char *s) {
+    unsigned hashval;
+    for (hashval = 0; *s != '\0'; s++)
+        hashval = *s + 31 * hashval;
+    return hashval % HASHSIZE;
+}
+
+rnlist *rlget(char *s) {
+    rnlist *np;
+    for (np = rhashtab[rhash(s)]; np != NULL; np = np->next)
+        if (strcmp(s, np->name) == 0)
+            return np; // Found
+    return NULL;       // Not found
+}
+
+// Lookup function
+char *rget(char *s) {
+    rnlist *np = rlget(s);
+    return np ? np->defn : NULL;
+}
+
+// Install function (adds a name and definition to the table)
+struct rnlist *rset(char *name, char *defn) {
+    struct rnlist *np = NULL;
+    unsigned hashval;
+
+    if ((rlget(name)) == NULL) { // Not found
+        np = (struct rnlist *)malloc(sizeof(*np));
+        if (np == NULL || (np->name = strdup(name)) == NULL)
+            return NULL;
+        hashval = rhash(name);
+        np->next = rhashtab[hashval];
+        rhashtab[hashval] = np;
+    } else {
+        if (np->defn)
+            free((void *)np->defn);
+        np->defn = NULL;
+    }
+    if ((np->defn = strdup(defn)) == NULL)
+        return NULL;
+    return np;
+}
+#endif
+
+#ifndef RREX3_H
+#define RREX3_H
+#include <assert.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#ifndef RREX3_DEBUG
+#define RREX3_DEBUG 0
+#endif
+
+struct rrex3_t;
+
+typedef void (*rrex3_function)(struct rrex3_t *);
+
+typedef struct rrex3_t {
+    void (*functions[254])(struct rrex3_t *);
+    void (*slash_functions[254])(struct rrex3_t *);
+    bool valid;
+    int match_count;
+    int match_capacity;
+    char **matches;
+    bool exit;
+    char *__expr;
+    char *__str;
+    char *_expr;
+    char *_str;
+    char *expr;
+    char *str;
+    char *compiled;
+    bool inside_brackets;
+    bool inside_parentheses;
+    bool pattern_error;
+    bool match_from_start;
+    char bytecode;
+    rrex3_function function;
+    struct {
+        void (*function)(struct rrex3_t *);
+        char *expr;
+        char *str;
+        char bytecode;
+    } previous;
+    struct {
+        void (*function)(struct rrex3_t *);
+        char *expr;
+        char *str;
+        char bytecode;
+    } failed;
+} rrex3_t;
+
+static bool isdigitrange(char *s) {
+    if (!isdigit(*s)) {
+        return false;
+    }
+    if (*(s + 1) != '-') {
+        return false;
+    }
+    return isdigit(*(s + 2));
+}
+
+static bool isalpharange(char *s) {
+    if (!isalpha(*s)) {
+        return false;
+    }
+    if (*(s + 1) != '-') {
+        return false;
+    }
+    return isalpha(*(s + 2));
+}
+
+void rrex3_free_matches(rrex3_t *rrex3) {
+    if (!rrex3->matches)
+        return;
+    for (int i = 0; i < rrex3->match_count; i++) {
+        free(rrex3->matches[i]);
+    }
+    free(rrex3->matches);
+    rrex3->matches = NULL;
+    rrex3->match_count = 0;
+    rrex3->match_capacity = 0;
+}
+
+void rrex3_free(rrex3_t *rrex3) {
+    if (!rrex3)
+        return;
+    if (rrex3->compiled) {
+        free(rrex3->compiled);
+        rrex3->compiled = NULL;
+    }
+    rrex3_free_matches(rrex3);
+    free(rrex3);
+    rrex3 = NULL;
+}
+static bool rrex3_move(rrex3_t *, bool);
+static void rrex3_set_previous(rrex3_t *);
+inline static void rrex3_cmp_asterisk(rrex3_t *);
+void rrex3_cmp_literal_range(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    printf("Range check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    rrex3_set_previous(rrex3);
+
+    char start = *rrex3->expr;
+    rrex3->expr++;
+    rrex3->expr++;
+    char end = *rrex3->expr;
+    if (*rrex3->str >= start && *rrex3->str <= end) {
+        rrex3->str++;
+        rrex3->valid = true;
+    } else {
+        rrex3->valid = false;
+    }
+    rrex3->expr++;
+}
+
+bool rrex3_is_function(char chr) {
+    if (chr == ']' || chr == ')' || chr == '\\' || chr == '?' || chr == '+' || chr == '*')
+        return true;
+    return false;
+}
+
+inline static void rrex3_cmp_literal(rrex3_t *rrex3) {
+    rrex3_set_previous(rrex3);
+
+    if (rrex3->inside_brackets) {
+        if (isalpharange(rrex3->expr) || isdigitrange(rrex3->expr)) {
+            rrex3_cmp_literal_range(rrex3);
+            return;
+        }
+    }
+#if RREX3_DEBUG == 1
+    printf("Literal check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+
+#endif
+    if (*rrex3->expr == 0 && !*rrex3->str) {
+        printf("ERROR, EMPTY CHECK\n");
+        // exit(1);
+    }
+    if (rrex3->valid == false) {
+        rrex3->expr++;
+        return;
+    }
+
+    if (*rrex3->expr == *rrex3->str) {
+        rrex3->expr++;
+        rrex3->str++;
+        rrex3->valid = true;
+        // if(*rrex3->expr &&rrex3->functions[(int)*rrex3->expr] ==
+        // rrex3_cmp_literal && !rrex3->inside_brackets &&
+        //! rrex3_is_function(*rrex3->expr)){ rrex3_cmp_literal(rrex3);
+        //   if(rrex3->valid == false){
+        //  rrex3->expr--;
+        // rrex3->valid = true;
+        // }
+        // }
+        return;
+    }
+    rrex3->expr++;
+    rrex3->valid = false;
+}
+
+inline static void rrex3_cmp_dot(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    printf("Dot check (any char): %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    rrex3_set_previous(rrex3);
+    rrex3->expr++;
+    if (!rrex3->valid) {
+        return;
+    }
+    if (*rrex3->str && *rrex3->str != '\n') {
+        rrex3->str++;
+        if (*rrex3->expr && *rrex3->expr == '.') {
+            rrex3_cmp_dot(rrex3);
+            return;
+        } /*else if(*rrex3->expr && (*rrex3->expr == '*' || *rrex3->expr ==
+         '+')){ char * next = strchr(rrex3->str,*(rrex3->expr + 1)); char *
+         space = strchr(rrex3->str,'\n'); if(next && (!space || space > next)){
+                 rrex3->str = next;
+             }
+         }*/
+    } else {
+        rrex3->valid = false;
+    }
+}
+
+inline static void rrex3_cmp_question_mark(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    printf("Question mark check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    rrex3_set_previous(rrex3);
+
+    if (rrex3->valid == false)
+        rrex3->valid = true;
+    rrex3->expr++;
+}
+
+inline static void rrex3_cmp_whitespace(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    printf("Whitespace check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    rrex3_set_previous(rrex3);
+
+    char c = *rrex3->expr;
+    rrex3->valid = c == ' ' || c == '\n' || c == '\t';
+    if (rrex3->valid) {
+        rrex3->str++;
+    }
+    rrex3->expr++;
+}
+
+inline static void rrex3_cmp_whitespace_upper(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    printf("Non whitespace check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    rrex3_set_previous(rrex3);
+
+    char c = *rrex3->expr;
+    rrex3->valid = !(c == ' ' || c == '\n' || c == '\t');
+    if (rrex3->valid) {
+        rrex3->str++;
+    }
+    rrex3->expr++;
+}
+
+inline static void rrex3_cmp_plus2(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    printf("Plus check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    rrex3_set_previous(rrex3);
+
+    if (rrex3->valid) {
+        rrex3->str--;
+    } else {
+        return;
+    }
+    char *original_expr = rrex3->expr;
+    char *next = original_expr + 1;
+    char *loop_expr = rrex3->previous.expr - 1;
+    if (*loop_expr == '+') {
+        rrex3->valid = false;
+        rrex3->pattern_error = true;
+        rrex3->expr++;
+        return;
+    }
+    bool success_next = false;
+    bool success_next_once = false;
+    bool success_current = false;
+    char *next_next = NULL;
+    char *next_str = rrex3->str;
+    while (*rrex3->str) {
+        // Check if next matches
+        char *original_str = rrex3->str;
+        rrex3->expr = next;
+        rrex3->valid = true;
+        if (rrex3_move(rrex3, false)) {
+            success_next = true;
+            next_next = rrex3->expr;
+            next_str = rrex3->str;
+            success_next_once = true;
+        } else {
+            success_next = false;
+        }
+        if (success_next_once && !success_next) {
+            break;
+        }
+        // Check if current matches
+        rrex3->str = original_str;
+        rrex3->expr = loop_expr;
+        rrex3->valid = true;
+        if (!*rrex3->str || !rrex3_move(rrex3, false)) {
+            success_current = false;
+        } else {
+            success_current = true;
+            if (!success_next) {
+                next_next = rrex3->expr + 1; // +1 is the * itself
+                next_str = rrex3->str;
+            }
+        }
+        if (success_next && !success_current) {
+            break;
+        }
+    }
+    if (!next_next)
+        rrex3->expr = next;
+    else {
+        rrex3->expr = next_next;
+    }
+    rrex3->str = next_str;
+    rrex3->valid = true;
+}
+
+inline static void rrex3_cmp_plus(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    rprintg("Asterisk start check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    if (!rrex3->valid) {
+        rrex3->expr++;
+        return;
+    }
+
+    char *left = rrex3->previous.expr;
+    // printf("%s\n",rrex3->str);
+    char *right = rrex3->expr + 1;
+    if (*right == ')') {
+        right++;
+    }
+    int right_valid = 0;
+    bool right_valid_once = false;
+    char *expr = right;
+    char *right_str = rrex3->str;
+    ;
+    char *right_expr = NULL;
+    char *str = rrex3->str;
+    bool first_time = true;
+    bool left_valid = true;
+    char *str_prev = NULL;
+    bool valid_from_start = true;
+    ;
+    while (*rrex3->str) {
+        if (!left_valid && !right_valid) {
+            break;
+        }
+        if (right_valid && !left_valid) {
+            str = right_str;
+            break;
+        }
+
+        rrex3->expr = right;
+        rrex3->str = str;
+#if RREX3_DEBUG == 1
+        printf("r");
+#endif
+        if (*rrex3->str && rrex3_move(rrex3, false)) {
+            right_valid++;
+            right_str = rrex3->str;
+            expr = rrex3->expr;
+            if (!right_valid_once) {
+                right_expr = rrex3->expr;
+                right_valid_once = true;
+            }
+        } else {
+            right_valid = 0;
+        }
+        if (first_time) {
+            first_time = false;
+            valid_from_start = right_valid;
+        }
+
+        if (right_valid && !valid_from_start && right_valid > 0) {
+            expr = right_expr - 1;
+            ;
+            if (*(right - 1) == ')') {
+                expr = right - 1;
+            }
+            break;
+        }
+
+        if ((!right_valid && right_valid_once)) {
+            expr = right_expr;
+            if (*(right - 1) == ')') {
+                str = str_prev;
+                expr = right - 1;
+            }
+            break;
+        }
+
+        str_prev = str;
+        rrex3->valid = true;
+        rrex3->str = str;
+        rrex3->expr = left;
+#if RREX3_DEBUG == 1
+        printf("l");
+#endif
+        if (rrex3_move(rrex3, false)) {
+            left_valid = true;
+
+            str = rrex3->str;
+        } else {
+            left_valid = false;
+        }
+    }
+
+    rrex3->expr = expr;
+    rrex3->str = str;
+    rrex3->valid = true;
+
+#if RREX3_DEBUG == 1
+    rprintg("Asterisk end check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+}
+
+inline static void rrex3_cmp_asterisk(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    rprintg("Asterisk start check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    if (!rrex3->valid) {
+        rrex3->valid = true;
+        rrex3->expr++;
+        return;
+    }
+
+    rrex3->str = rrex3->previous.str;
+    char *left = rrex3->previous.expr;
+    // printf("%s\n",rrex3->str);
+    char *right = rrex3->expr + 1;
+    if (*right == ')') {
+        right++;
+    }
+    int right_valid = 0;
+    bool right_valid_once = false;
+    char *expr = right;
+    char *right_str = rrex3->str;
+    ;
+    char *right_expr = NULL;
+    char *str = rrex3->str;
+    bool first_time = true;
+    bool left_valid = true;
+    char *str_prev = NULL;
+    bool valid_from_start = true;
+    ;
+    while (*rrex3->str) {
+        if (!left_valid && !right_valid) {
+            break;
+        }
+        if (right_valid && !left_valid) {
+            str = right_str;
+            break;
+        }
+
+        rrex3->expr = right;
+        rrex3->str = str;
+#if RREX3_DEBUG == 1
+        printf("r");
+#endif
+        if (*rrex3->str && rrex3_move(rrex3, false)) {
+            right_valid++;
+            right_str = rrex3->str;
+            expr = rrex3->expr;
+            if (!right_valid_once) {
+                right_expr = rrex3->expr;
+                right_valid_once = true;
+            }
+        } else {
+            right_valid = 0;
+        }
+        if (first_time) {
+            first_time = false;
+            valid_from_start = right_valid;
+        }
+
+        if (right_valid && !valid_from_start && right_valid > 0) {
+            expr = right_expr - 1;
+            if (*(right - 1) == ')') {
+                expr = right - 1;
+            }
+            break;
+        }
+
+        if ((!right_valid && right_valid_once)) {
+            expr = right_expr;
+            if (*(right - 1) == ')') {
+                str = str_prev;
+                expr = right - 1;
+            }
+            break;
+        }
+
+        str_prev = str;
+        rrex3->valid = true;
+        rrex3->str = str;
+        rrex3->expr = left;
+#if RREX3_DEBUG == 1
+        printf("l");
+#endif
+        if (rrex3_move(rrex3, false)) {
+            left_valid = true;
+            str = rrex3->str;
+        } else {
+            left_valid = false;
+        }
+    }
+
+    rrex3->expr = expr;
+    rrex3->str = str;
+    rrex3->valid = true;
+
+#if RREX3_DEBUG == 1
+    rprintg("Asterisk end check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+}
+
+inline static void rrex3_cmp_asterisk2(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    rprintg("Asterisk start check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    if (!rrex3->valid) {
+        rrex3->valid = true;
+        rrex3->expr++;
+        return;
+    }
+    if (*rrex3->previous.expr == '*') {
+        // Support for **
+        rrex3->valid = false;
+        // rrex3->pattern_error = true;
+        rrex3->expr++;
+        return;
+    }
+    rrex3->str = rrex3->previous.str;
+    ;
+    char *next = rrex3->expr + 1;
+    char *next_original = NULL;
+    if (*next == '*') {
+        next++;
+    }
+    if (*next == ')' && *(next + 1)) {
+        next_original = next;
+        next++;
+    }
+    char *loop_expr = rrex3->previous.expr;
+    bool success_next = false;
+    bool success_next_once = false;
+    bool success_current = false;
+    char *right_next = NULL;
+    char *right_str = rrex3->str;
+    while (*rrex3->str && *rrex3->expr && *rrex3->expr != ')') {
+        // Remember original_str because it's modified
+        // by checking right and should be restored
+        // for checking left so they're matching the
+        // same value.
+        char *original_str = rrex3->str;
+        // Check if right matches.
+        // if(*next != ')'){
+        rrex3->expr = next;
+        rrex3->valid = true;
+        if (rrex3_move(rrex3, false)) {
+            // Match rright.
+            success_next = true;
+            if (!next_original) {
+                if (!success_next_once) {
+                    right_next = rrex3->expr;
+                }
+
+            } else {
+                right_next = next_original;
+                break;
+            }
+            right_str = rrex3->str;
+            success_next_once = true;
+        } else {
+            // No match Right.
+            success_next = false;
+        }
+        //}
+        if (success_next_once && !success_next) {
+            // Matched previous time but now doesn't.
+            break;
+        }
+        // Check if left matches.
+        rrex3->str = original_str;
+        rrex3->expr = loop_expr;
+        rrex3->valid = true;
+        if (!rrex3_move(rrex3, false)) {
+            // No match left.
+            success_current = false;
+        } else {
+            // Match left.
+            success_current = true;
+            // NOT SURE< WITHOUT DOET HETZELFDE:
+            // original_str = rrex3->str;
+            if (!success_next) {
+                right_str = rrex3->str;
+                if (*rrex3->expr != ')') {
+                    right_next = rrex3->expr + 1; // +1 is the * itself
+
+                } else {
+
+                    // break;
+                }
+            }
+        }
+
+        if ((success_next && !success_current) || (!success_next && !success_current)) {
+            break;
+        }
+    }
+    rrex3->expr = right_next;
+    rrex3->str = right_str;
+    rrex3->valid = true;
+#if RREX3_DEBUG == 1
+    rprintg("Asterisk end check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+}
+
+inline static void rrex3_cmp_roof(rrex3_t *rrex3) {
+    rrex3_set_previous(rrex3);
+#if RREX3_DEBUG == 1
+    printf("<Roof check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    rrex3->valid = rrex3->str == rrex3->_str;
+    rrex3->match_from_start = true;
+    rrex3->expr++;
+}
+inline static void rrex3_cmp_dollar(rrex3_t *rrex3) {
+    rrex3_set_previous(rrex3);
+
+#if RREX3_DEBUG == 1
+    printf("Dollar check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    if (*rrex3->str || !rrex3->valid) {
+        rrex3->valid = false;
+    }
+    rrex3->expr++;
+}
+
+inline static void rrex3_cmp_w(rrex3_t *rrex3) {
+    rrex3_set_previous(rrex3);
+
+    rrex3->expr++;
+#if RREX3_DEBUG == 1
+    printf("Word check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    if (isalpha(*rrex3->str)) {
+        rrex3->str++;
+    } else {
+        rrex3->valid = false;
+    }
+}
+inline static void rrex3_cmp_w_upper(rrex3_t *rrex3) {
+    rrex3_set_previous(rrex3);
+
+    rrex3->expr++;
+#if RREX3_DEBUG == 1
+    printf("!Word check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    if (!isalpha(*rrex3->str)) {
+        rrex3->str++;
+    } else {
+        rrex3->valid = false;
+    }
+}
+
+inline static void rrex3_cmp_d(rrex3_t *rrex3) {
+
+    rrex3_set_previous(rrex3);
+
+    rrex3->expr++;
+#if RREX3_DEBUG == 1
+    printf("Digit check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    if (isdigit(*rrex3->str)) {
+        rrex3->str++;
+    } else {
+        rrex3->valid = false;
+    }
+}
+inline static void rrex3_cmp_d_upper(rrex3_t *rrex3) {
+    rrex3_set_previous(rrex3);
+
+    rrex3->expr++;
+#if RREX3_DEBUG == 1
+    printf("!Digit check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    if (!isdigit(*rrex3->str)) {
+        rrex3->str++;
+    } else {
+        rrex3->valid = false;
+    }
+}
+
+inline static void rrex3_cmp_slash(rrex3_t *rrex3) {
+    rrex3_set_previous(rrex3);
+
+    rrex3->expr++;
+
+    rrex3->bytecode = *rrex3->expr;
+    rrex3->function = rrex3->slash_functions[(int)rrex3->bytecode];
+    rrex3->function(rrex3);
+}
+
+inline static int collect_digits(rrex3_t *rrex3) {
+    char output[20];
+    unsigned int digit_count = 0;
+    while (isdigit(*rrex3->expr)) {
+
+        output[digit_count] = *rrex3->expr;
+        rrex3->expr++;
+        digit_count++;
+    }
+    output[digit_count] = 0;
+    return atoi(output);
+}
+
+inline static void rrex3_cmp_range(rrex3_t *rrex3) {
+    char *loop_code = rrex3->previous.expr;
+    char *expr_original = rrex3->expr;
+    rrex3->expr++;
+    int range_start = collect_digits(rrex3) - 1;
+    int range_end = 0;
+    if (*rrex3->expr == ',') {
+        rrex3->expr++;
+        range_end = collect_digits(rrex3);
+    }
+    rrex3->expr++;
+    int times_valid = 0;
+    while (*rrex3->str) {
+        rrex3->expr = loop_code;
+        rrex3_move(rrex3, false);
+        if (rrex3->valid == false) {
+            break;
+        } else {
+            times_valid++;
+        }
+        if (range_end) {
+            if (times_valid >= range_start && times_valid == range_end - 1) {
+                rrex3->valid = true;
+            } else {
+                rrex3->valid = false;
+            }
+            break;
+        } else if (range_start) {
+            if (times_valid == range_start) {
+                rrex3->valid = true;
+                break;
+            }
+        }
+    }
+    rrex3->valid = times_valid >= range_start;
+    if (rrex3->valid && range_end) {
+        rrex3->valid = times_valid <= range_end;
+    }
+    rrex3->expr = strchr(expr_original, '}') + 1;
+}
+
+inline static void rrex3_cmp_word_start_or_end(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    if (*rrex3->expr != 'B') {
+        printf("Check word start or end: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+    }
+
+#endif
+    rrex3_set_previous(rrex3);
+    bool valid = false;
+    if (isalpha(*rrex3->str)) {
+        if (rrex3->_str != rrex3->str) {
+            if (!isalpha(*(rrex3->str - 1))) {
+                valid = true;
+            }
+        } else {
+            valid = true;
+        }
+    } else if (isalpha(isalpha(*rrex3->str) && !isalpha(*rrex3->str + 1))) {
+        valid = true;
+    }
+    rrex3->expr++;
+    rrex3->valid = valid;
+}
+inline static void rrex3_cmp_word_not_start_or_end(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    printf("Check word NOT start or end: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+
+#endif
+    rrex3_set_previous(rrex3);
+
+    rrex3_cmp_word_start_or_end(rrex3);
+    rrex3->valid = !rrex3->valid;
+}
+
+inline static void rrex3_cmp_brackets(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    rprintb("\\l Brackets start: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    rrex3_set_previous(rrex3);
+    char *original_expr = rrex3->expr;
+    rrex3->expr++;
+    rrex3->inside_brackets = true;
+    bool valid_once = false;
+    bool reversed = false;
+    if (*rrex3->expr == '^') {
+        reversed = true;
+        rrex3->expr++;
+    }
+    bool valid = false;
+    while (*rrex3->expr != ']' && *rrex3->expr != 0) {
+        rrex3->valid = true;
+        valid = rrex3_move(rrex3, false);
+        if (reversed) {
+            valid = !valid;
+        }
+        if (valid) {
+            valid_once = true;
+            if (!reversed) {
+                valid_once = true;
+                break;
+            }
+        } else {
+            if (reversed) {
+                valid_once = false;
+                break;
+            }
+        }
+    }
+    if (valid_once && reversed) {
+        rrex3->str++;
+    }
+    while (*rrex3->expr != ']' && *rrex3->expr != 0)
+        rrex3->expr++;
+    if (*rrex3->expr != 0)
+        rrex3->expr++;
+
+    rrex3->valid = valid_once;
+    rrex3->inside_brackets = false;
+    char *previous_expr = rrex3->expr;
+    rrex3->expr = original_expr;
+    rrex3_set_previous(rrex3);
+    rrex3->expr = previous_expr;
+#if RREX3_DEBUG == 1
+    rprintb("\\l Brackets end: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+}
+
+inline static void rrex3_cmp_pipe(rrex3_t *rrex3) {
+    rrex3_set_previous(rrex3);
+
+#if RREX3_DEBUG == 1
+    printf("Pipe check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+    if (rrex3->valid == true) {
+        rrex3->exit = true;
+    } else {
+        rrex3->valid = true;
+    }
+    rrex3->expr++;
+}
+inline static void rrex3_cmp_parentheses(rrex3_t *rrex3) {
+#if RREX3_DEBUG == 1
+    rprinty("\\l Parentheses start check: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+
+    rrex3_set_previous(rrex3);
+    if (!rrex3->valid) {
+        rrex3->expr++;
+        return;
+    }
+    if (rrex3->match_count == rrex3->match_capacity) {
+
+        rrex3->match_capacity++;
+        rrex3->matches = (char **)realloc(rrex3->matches, rrex3->match_capacity * sizeof(char *));
+    }
+    rrex3->matches[rrex3->match_count] = (char *)malloc(strlen(rrex3->str) + 1);
+    strcpy(rrex3->matches[rrex3->match_count], rrex3->str);
+    char *original_expr = rrex3->expr;
+    char *original_str = rrex3->str;
+    rrex3->expr++;
+    rrex3->inside_parentheses = true;
+    while (*rrex3->expr != ')' && !rrex3->exit) {
+        rrex3_move(rrex3, false);
+    }
+    while (*rrex3->expr != ')') {
+        rrex3->expr++;
+    }
+    rrex3->expr++;
+    rrex3->inside_parentheses = false;
+
+    char *previous_expr = rrex3->expr;
+    rrex3->expr = original_expr;
+    rrex3_set_previous(rrex3);
+    rrex3->expr = previous_expr;
+    if (rrex3->valid == false) {
+        rrex3->str = original_str;
+        free(rrex3->matches[rrex3->match_count]);
+    } else {
+        rrex3->matches[rrex3->match_count][strlen(rrex3->matches[rrex3->match_count]) - strlen(rrex3->str)] = 0;
+        rrex3->match_count++;
+    }
+#if RREX3_DEBUG == 1
+    rprinty("\\l Parentheses end: %c:%c:%d\n", *rrex3->expr, *rrex3->str, rrex3->valid);
+#endif
+}
+
+inline static void rrex3_reset(rrex3_t *rrex3) {
+    rrex3_free_matches(rrex3);
+    rrex3->valid = true;
+    rrex3->pattern_error = false;
+    rrex3->inside_brackets = false;
+    rrex3->inside_parentheses = false;
+    rrex3->exit = false;
+    rrex3->previous.expr = NULL;
+    rrex3->previous.str = NULL;
+    rrex3->previous.bytecode = 0;
+    rrex3->failed.expr = NULL;
+    rrex3->failed.str = NULL;
+    rrex3->failed.bytecode = 0;
+    rrex3->match_from_start = false;
+}
+
+void rrex3_init(rrex3_t *rrex3) {
+    for (__uint8_t i = 0; i < 254; i++) {
+        rrex3->functions[i] = rrex3_cmp_literal;
+        rrex3->slash_functions[i] = rrex3_cmp_literal;
+    }
+    rrex3->functions['?'] = rrex3_cmp_question_mark;
+    rrex3->functions['^'] = rrex3_cmp_roof;
+    rrex3->functions['$'] = rrex3_cmp_dollar;
+    rrex3->functions['.'] = rrex3_cmp_dot;
+    rrex3->functions['*'] = rrex3_cmp_asterisk;
+    rrex3->functions['+'] = rrex3_cmp_plus;
+    rrex3->functions['|'] = rrex3_cmp_pipe;
+    rrex3->functions['\\'] = rrex3_cmp_slash;
+    rrex3->functions['{'] = rrex3_cmp_range;
+    rrex3->functions['['] = rrex3_cmp_brackets;
+    rrex3->functions['('] = rrex3_cmp_parentheses;
+    rrex3->slash_functions['w'] = rrex3_cmp_w;
+    rrex3->slash_functions['W'] = rrex3_cmp_w_upper;
+    rrex3->slash_functions['d'] = rrex3_cmp_d;
+    rrex3->slash_functions['D'] = rrex3_cmp_d_upper;
+    rrex3->slash_functions['s'] = rrex3_cmp_whitespace;
+    rrex3->slash_functions['S'] = rrex3_cmp_whitespace_upper;
+    rrex3->slash_functions['b'] = rrex3_cmp_word_start_or_end;
+    rrex3->slash_functions['B'] = rrex3_cmp_word_not_start_or_end;
+    rrex3->match_count = 0;
+    rrex3->match_capacity = 0;
+    rrex3->matches = NULL;
+    rrex3->compiled = NULL;
+
+    rrex3_reset(rrex3);
+}
+
+rrex3_t *rrex3_new() {
+    rrex3_t *rrex3 = (rrex3_t *)malloc(sizeof(rrex3_t));
+
+    rrex3_init(rrex3);
+
+    return rrex3;
+}
+
+rrex3_t *rrex3_compile(rrex3_t *rrex, char *expr) {
+
+    rrex3_t *rrex3 = rrex ? rrex : rrex3_new();
+
+    char *compiled = (char *)malloc(strlen(expr) + 1);
+    unsigned int count = 0;
+    while (*expr) {
+        if (*expr == '[' && *(expr + 2) == ']') {
+            *compiled = *(expr + 1);
+            expr++;
+            expr++;
+        } else if (*expr == '[' && *(expr + 1) == '0' && *(expr + 2) == '-' && *(expr + 3) == '9' && *(expr + 4) == ']') {
+            *compiled = '\\';
+            compiled++;
+            *compiled = 'd';
+            count++;
+            expr++;
+            expr++;
+            expr++;
+            expr++;
+        } else {
+            *compiled = *expr;
+        }
+        if (*compiled == '[') {
+            // in_brackets = true;
+
+        } else if (*compiled == ']') {
+            // in_brackets = false;
+        }
+        expr++;
+        compiled++;
+        count++;
+    }
+    *compiled = 0;
+    compiled -= count;
+    rrex3->compiled = compiled;
+    return rrex3;
+}
+
+inline static void rrex3_set_previous(rrex3_t *rrex3) {
+    rrex3->previous.function = rrex3->function;
+    rrex3->previous.expr = rrex3->expr;
+    rrex3->previous.str = rrex3->str;
+    rrex3->previous.bytecode = *rrex3->expr;
+}
+
+static bool rrex3_move(rrex3_t *rrex3, bool resume_on_fail) {
+    char *original_expr = rrex3->expr;
+    char *original_str = rrex3->str;
+    rrex3->bytecode = *rrex3->expr;
+    rrex3->function = rrex3->functions[(int)rrex3->bytecode];
+    rrex3->function(rrex3);
+    if (!*rrex3->expr && !*rrex3->str) {
+        rrex3->exit = true;
+        return rrex3->valid;
+    } else if (!*rrex3->expr) {
+        // rrex3->valid = true;
+        return rrex3->valid;
+    }
+    if (rrex3->pattern_error) {
+        rrex3->valid = false;
+        return rrex3->valid;
+    }
+    if (resume_on_fail && !rrex3->valid && *rrex3->expr) {
+
+        // rrex3_set_previous(rrex3);
+        rrex3->failed.bytecode = rrex3->bytecode;
+        rrex3->failed.function = rrex3->function;
+        rrex3->failed.expr = original_expr;
+        rrex3->failed.str = original_str;
+        rrex3->bytecode = *rrex3->expr;
+        rrex3->function = rrex3->functions[(int)rrex3->bytecode];
+        rrex3->function(rrex3);
+
+        if (!rrex3->valid && !rrex3->pattern_error) {
+
+            if (*rrex3->str) {
+                char *pipe_position = strstr(rrex3->expr, "|");
+                if (pipe_position != NULL) {
+                    rrex3->expr = pipe_position + 1;
+                    rrex3->str = rrex3->_str;
+                    rrex3->valid = true;
+                    return true;
+                }
+            }
+            if (rrex3->match_from_start) {
+                rrex3->valid = false;
+                return rrex3->valid;
+            }
+            if (!*rrex3->str++) {
+                rrex3->valid = false;
+                return rrex3->valid;
+            }
+            rrex3->expr = rrex3->_expr;
+            if (*rrex3->str)
+                rrex3->valid = true;
+        }
+    } else {
+    }
+    return rrex3->valid;
+}
+
+rrex3_t *rrex3(rrex3_t *rrex3, char *str, char *expr) {
+#if RREX3_DEBUG == 1
+    printf("Regex check: %s:%s:%d\n", expr, str, 1);
+#endif
+    bool self_initialized = false;
+    if (rrex3 == NULL) {
+        self_initialized = true;
+        rrex3 = rrex3_new();
+    } else {
+        rrex3_reset(rrex3);
+    }
+
+    rrex3->_str = str;
+    rrex3->_expr = rrex3->compiled ? rrex3->compiled : expr;
+    rrex3->str = rrex3->_str;
+    rrex3->expr = rrex3->_expr;
+    while (*rrex3->expr && !rrex3->exit) {
+        if (!rrex3_move(rrex3, true))
+            return NULL;
+    }
+    rrex3->expr = rrex3->_expr;
+    if (rrex3->valid) {
+
+        return rrex3;
+    } else {
+        if (self_initialized) {
+            rrex3_free(rrex3);
+        }
+        return NULL;
+    }
+}
+
+void rrex3_test() {
+    rrex3_t *rrex = rrex3_new();
+
+    assert(rrex3(rrex, "\"stdio.h\"\"string.h\"\"sys/time.h\"", "\"(.*)\"\"(.*)\"\"(.*)\""));
+
+    assert(rrex3(rrex, "aaaaaaa", "a*a$"));
+
+    // assert(rrex3("ababa", "a*b*a*b*a$"));
+    assert(rrex3(rrex, "#include\"test.h\"a", "#include.*\".*\"a$"));
+    assert(rrex3(rrex, "#include \"test.h\"a", "#include.*\".*\"a$"));
+    assert(rrex3(rrex, "aaaaaad", "a*d$"));
+    assert(rrex3(rrex, "abcdef", "abd?cdef"));
+    assert(!rrex3(rrex, "abcdef", "abd?def"));
+    assert(rrex3(rrex, "abcdef", "def"));
+    assert(!rrex3(rrex, "abcdef", "^def"));
+    assert(rrex3(rrex, "abcdef", "def$"));
+    assert(!rrex3(rrex, "abcdef", "^abc$"));
+    assert(rrex3(rrex, "aB!.#1", "......"));
+    assert(!rrex3(rrex, "aB!.#\n", "      ......"));
+    assert(!rrex3(rrex, "aaaaaad", "q+d$"));
+    assert(rrex3(rrex, "aaaaaaa", "a+a$"));
+    assert(rrex3(rrex, "aaaaaad", "q*d$"));
+    assert(!rrex3(rrex, "aaaaaad", "^q*d$"));
+
+    // Asterisk function
+    assert(rrex3(rrex, "123321", "123*321"));
+    assert(rrex3(rrex, "pony", "p*ony"));
+    assert(rrex3(rrex, "pppony", "p*ony"));
+    assert(rrex3(rrex, "ppony", "p*pony"));
+    assert(rrex3(rrex, "pppony", "pp*pony"));
+    assert(rrex3(rrex, "pppony", ".*pony"));
+    assert(rrex3(rrex, "pony", ".*ony"));
+    assert(rrex3(rrex, "pony", "po*ny"));
+    // assert(rrex3(rrex,"ppppony", "p*pppony"));
+
+    // Plus function
+    assert(rrex3(rrex, "pony", "p+ony"));
+    assert(!rrex3(rrex, "ony", "p+ony"));
+    assert(rrex3(rrex, "ppony", "p+pony"));
+    assert(rrex3(rrex, "pppony", "pp+pony"));
+    assert(rrex3(rrex, "pppony", ".+pony"));
+    assert(rrex3(rrex, "pony", ".+ony"));
+    assert(rrex3(rrex, "pony", "po+ny"));
+
+    // Slash functions
+    assert(rrex3(rrex, "a", "\\w"));
+    assert(!rrex3(rrex, "1", "\\w"));
+    assert(rrex3(rrex, "1", "\\W"));
+    assert(!rrex3(rrex, "a", "\\W"));
+    assert(rrex3(rrex, "a", "\\S"));
+    assert(!rrex3(rrex, " ", "\\s"));
+    assert(!rrex3(rrex, "\t", "\\s"));
+    assert(!rrex3(rrex, "\n", "\\s"));
+    assert(rrex3(rrex, "1", "\\d"));
+    assert(!rrex3(rrex, "a", "\\d"));
+    assert(rrex3(rrex, "a", "\\D"));
+    assert(!rrex3(rrex, "1", "\\D"));
+    assert(rrex3(rrex, "abc", "\\b"));
+
+    assert(rrex3(rrex, "abc", "\\babc"));
+    assert(!rrex3(rrex, "abc", "a\\b"));
+    assert(!rrex3(rrex, "abc", "ab\\b"));
+    assert(!rrex3(rrex, "abc", "abc\\b"));
+    assert(rrex3(rrex, "abc", "a\\Bbc"));
+    assert(rrex3(rrex, "abc", "ab\\B"));
+    assert(!rrex3(rrex, "1ab", "1\\Bab"));
+    assert(rrex3(rrex, "abc", "a\\Bbc"));
+
+    // Escaping of special chars
+    assert(rrex3(rrex, "()+*.\\", "\\(\\)\\+\\*\\.\\\\"));
+
+    // Pipe
+    // assert(rrex3(rrex,"abc","abc|def"));
+    assert(rrex3(rrex, "abc", "def|jkl|abc"));
+    assert(rrex3(rrex, "abc", "abc|def"));
+
+    assert(rrex3(rrex, "rhq", "def|rhq|rha"));
+    assert(rrex3(rrex, "abc", "abc|def"));
+
+    // Repeat
+    assert(rrex3(rrex, "aaaaa", "a{4}"));
+
+    assert(rrex3(rrex, "aaaa", "a{1,3}a"));
+
+    // Range
+    assert(rrex3(rrex, "abc", "[abc][abc][abc]$"));
+    assert(rrex3(rrex, "def", "[^abc][^abc][^abc]$"));
+    assert(rrex3(rrex, "defabc", "[^abc][^abc][^abc]abc"));
+    assert(rrex3(rrex, "0-9", "0-9"));
+    assert(rrex3(rrex, "55-9", "[^6-9]5-9$"));
+    assert(rrex3(rrex, "a", "[a-z]$"));
+    assert(rrex3(rrex, "A", "[A-Z]$"));
+    assert(rrex3(rrex, "5", "[0-9]$"));
+    assert(!rrex3(rrex, "a", "[^a-z]$"));
+    assert(!rrex3(rrex, "A", "[^A-Z]$"));
+    assert(!rrex3(rrex, "5", "[^0-9]$"));
+    assert(rrex3(rrex, "123abc", "[0-9]*abc$"));
+    assert(rrex3(rrex, "123123", "[0-9]*$"));
+
+    // Parentheses
+
+    assert(rrex3(rrex, "datadata", "(data)*"));
+
+    assert(rrex3(rrex, "datadatapony", "(data)*pony$"));
+
+    assert(!rrex3(rrex, "datadatapony", "(d*p*ata)*pond$"));
+    assert(rrex3(rrex, "datadatadato", "(d*p*ata)*dato"));
+    assert(rrex3(rrex, "datadatadato", "(d*p*ata)*dato$"));
+    assert(!rrex3(rrex, "datadatadato", "(d*p*a*ta)*gato$"));
+
+    // Matches
+    assert(rrex3(rrex, "123", "(123)"));
+    assert(!strcmp(rrex->matches[0], "123"));
+
+    assert(rrex3(rrex, "123321a", "(123)([0-4][2]1)a$"));
+    assert(!strcmp(rrex->matches[1], "321"));
+
+    assert(rrex3(rrex, "123321a", "(123)([0-4][2]1)a$"));
+    assert(!strcmp(rrex->matches[1], "321"));
+
+    assert(rrex3(rrex, "aaaabc", "(.*)c"));
+
+    assert(rrex3(rrex, "abcde", ".....$"));
+
+    assert(rrex3(rrex, "abcdefghijklmnopqrstuvwxyz", "..........................$"));
+    // printf("(%d)\n", rrex->valid);
+
+    assert(rrex3(rrex, "#include <stdio.h>", "#include.*<(.*)>"));
+    assert(!strcmp(rrex->matches[0], "stdio.h"));
+    assert(rrex3(rrex, "#include \"stdlib.h\"", "#include.\"(.*)\""));
+    assert(!strcmp(rrex->matches[0], "stdlib.h"));
+    assert(rrex3(rrex, "\"stdio.h\"\"string.h\"\"sys/time.h\"", "\"(.*)\"\"(.*)\"\"(.*)\""));
+    assert(!strcmp(rrex->matches[0], "stdio.h"));
+    assert(!strcmp(rrex->matches[1], "string.h"));
+    assert(!strcmp(rrex->matches[2], "sys/time.h"));
+
+    assert(rrex3(rrex, "    #include <stdio.h>", "#include.+<(.+)>"));
+    assert(!strcmp(rrex->matches[0], "stdio.h"));
+    assert(rrex3(rrex, "    #include \"stdlib.h\"", "#include.+\"(.+)\""));
+    assert(!strcmp(rrex->matches[0], "stdlib.h"));
+
+    assert(rrex3(rrex, "    \"stdio.h\"\"string.h\"\"sys/time.h\"", "\"(.+)\"\"(.+)\"\"(.+)\""));
+    assert(!strcmp(rrex->matches[0], "stdio.h"));
+    assert(!strcmp(rrex->matches[1], "string.h"));
+    assert(!strcmp(rrex->matches[2], "sys/time.h"));
+
+    assert(rrex3(rrex, "int abc ", "int (.*)[; ]?$"));
+    assert(!strcmp(rrex->matches[0], "abc"));
+    assert(rrex3(rrex, "int abc;", "int (.*)[; ]?$"));
+    assert(!strcmp(rrex->matches[0], "abc"));
+    assert(rrex3(rrex, "int abc", "int (.*)[; ]?$"));
+    assert(!strcmp(rrex->matches[0], "abc"));
+
+    rrex3_free(rrex);
+}
+#endif
+#ifndef RARENA_H
+#define RARENA_H
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct arena_t {
+    unsigned char *memory;
+    unsigned int pointer;
+    unsigned int size;
+} arena_t;
+
+arena_t *arena_construct() {
+    arena_t *arena = (arena_t *)rmalloc(sizeof(arena_t));
+    arena->memory = NULL;
+    arena->pointer = 0;
+    arena->size = 0;
+    return arena;
+}
+
+arena_t *arena_new(size_t size) {
+    arena_t *arena = arena_construct();
+    arena->memory = (unsigned char *)rmalloc(size);
+    arena->size = size;
+    return arena;
+}
+
+void *arena_alloc(arena_t *arena, size_t size) {
+    if (arena->pointer + size > arena->size) {
+        return NULL;
+    }
+    void *p = arena->memory + arena->pointer;
+    arena->pointer += size;
+    return p;
+}
+
+void arena_free(arena_t *arena) {
+    // Just constructed and unused arena memory is NULL so no free needed
+    if (arena->memory) {
+        rfree(arena->memory);
+    }
+    rfree(arena);
+}
+
+void arena_reset(arena_t *arena) { arena->pointer = 0; }
+#endif
+#ifndef RCASE_H
+#define RCASE_H
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+#define RCAMEL_CASE 1
+#define RSNAKE_CASE 2
+#define RINVALID_CASE 0
+#define RCONST_TEST_T 4;
+
+int rdetermine_case(const char *str) {
+    int length = strlen(str);
+
+    char p = 0;
+    while (*str) {
+        if (p == '_' && islower(*str))
+            return RSNAKE_CASE;
+        if (p != '_' && !isupper(p) && isupper(*str))
+            return RCAMEL_CASE;
+        p = *str;
+        str++;
+    }
+    return RINVALID_CASE;
+
+    if (length == 0) {
+        return RINVALID_CASE;
+    }
+    if (strchr(str, '_')) {
+        if (str[0] == '_' || str[length - 1] == '_' || strstr(str, "__")) {
+            return RINVALID_CASE;
+        }
+        for (int i = 0; i < length; i++) {
+            if (!islower(str[i]) && str[i] != '_') {
+                return RINVALID_CASE;
+            }
+        }
+        return RSNAKE_CASE;
+    } else {
+
+        if (!islower(str[0])) {
+            return RINVALID_CASE;
+        }
+        for (int i = 1; i < length; i++) {
+            if (str[i] == '_') {
+                return RINVALID_CASE;
+            }
+            if (isupper(str[i]) && isupper(str[i - 1])) {
+                return RINVALID_CASE;
+            }
+        }
+        return RCAMEL_CASE;
+    }
+}
+
+char *rsnake_to_camel(const char *snake_case) {
+    int length = strlen(snake_case);
+    char *camel_case = (char *)malloc(length + 1);
+    int j = 0;
+    int toUpper = 0;
+
+    for (int i = 0; i < length; i++) {
+        if (i > 0 && snake_case[i] == '_' && snake_case[i + 1] == 'T') {
+            toUpper = 1;
+            if (snake_case[i + 1] == 'T' && (snake_case[i + 2] != '\n' || snake_case[i + 2] != '\0' || snake_case[i + 2] != ' ')) {
+
+                toUpper = 0;
+            }
+        }
+        if (snake_case[i] == '_' && snake_case[i + 1] != 't') {
+            toUpper = 1;
+            if (snake_case[i + 1] == 't' && (snake_case[i + 2] != '\n' || snake_case[i + 2] != '\0' || snake_case[i + 2] != ' ')) {
+                toUpper = 0;
+            }
+        } else if (snake_case[i] == '_' && snake_case[i + 1] == 't' && !isspace(snake_case[i + 2])) {
+            toUpper = 1;
+        } else if (snake_case[i] == '_' && snake_case[i + 1] == 'T' && !isspace(snake_case[i + 2])) {
+            toUpper = 1;
+            camel_case[j++] = '_';
+            j++;
+        } else {
+            if (toUpper) {
+                camel_case[j++] = toupper(snake_case[i]);
+                toUpper = 0;
+            } else {
+                camel_case[j++] = snake_case[i];
+            }
+        }
+    }
+
+    camel_case[j] = '\0';
+    return camel_case;
+}
+char *rcamel_to_snake(const char *camelCase) {
+    int length = strlen(camelCase);
+    char *snake_case = (char *)malloc(2 * length + 1);
+    int j = 0;
+
+    for (int i = 0; i < length; i++) {
+        if (isupper(camelCase[i])) {
+            if (i != 0) {
+                snake_case[j++] = '_';
+            }
+            snake_case[j++] = tolower(camelCase[i]);
+        } else {
+            snake_case[j++] = camelCase[i];
+        }
+    }
+
+    snake_case[j] = '\0';
+    return snake_case;
+}
+
+char *rflip_case(char *content) {
+    if (rdetermine_case(content) == RSNAKE_CASE) {
+        return rcamel_to_snake(content);
+    } else if (rdetermine_case(content) == RCAMEL_CASE) {
+        return rsnake_to_camel(content);
+    } else {
+        rprintr("Could not determine case\n");
+        return NULL;
+    }
+}
+
+char *rflip_case_file(char *filepath) {
+    size_t file_size = rfile_size(filepath);
+    if (file_size == 0) {
+        return NULL;
+    }
+    char *content = (char *)malloc(file_size);
+    char *result = NULL;
+    if (rfile_readb(filepath, content, file_size)) {
+        result = rflip_case(content);
+        if (result) {
+            free(content);
+            return result;
+        } else {
+            return content;
+        }
+    }
+    return result;
+}
+
+int rcase_main(int argc, char *argv[]) {
+    if (argc < 2) {
+        printf("usage: rcase <file>\n");
+        return 1;
+    }
+    for (int i = 1; i < argc; i++) {
+        char *result = rflip_case_file(argv[i]);
+        if (result) {
+            printf("%s\n", result);
+            free(result);
+        }
+    }
+    return 0;
+}
+#endif
+
+#ifndef RTERM_H
+#define RTERM_H
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <termios.h>
+#include <unistd.h>
+typedef struct winsize winsize_t;
+
+typedef struct rshell_keypress_t {
+    bool pressed;
+    bool ctrl;
+    bool shift;
+    bool escape;
+    char c;
+    int ms;
+    int fd;
+} rshell_keypress_t;
+
+typedef struct rterm_t {
+    bool show_cursor;
+    bool show_footer;
+    int ms_tick;
+    rshell_keypress_t key;
+    void (*before_cursor_move)(struct rterm_t *);
+    void (*after_cursor_move)(struct rterm_t *);
+    void (*after_key_press)(struct rterm_t *);
+    void (*before_key_press)(struct rterm_t *);
+    void (*before_draw)(struct rterm_t *);
+    void (*after_draw)(struct rterm_t *);
+    void *session;
+    unsigned long iterations;
+    void (*tick)(struct rterm_t *);
+    char *status_text;
+    char *_status_text_previous;
+    winsize_t size;
+    struct {
+        int x;
+        int y;
+        int pos;
+        int available;
+    } cursor;
+} rterm_t;
+
+typedef void (*rterm_event)(rterm_t *);
+
+void rterm_init(rterm_t *rterm) {
+    memset(rterm, 0, sizeof(rterm_t));
+    rterm->show_cursor = true;
+    rterm->cursor.x = 0;
+    rterm->cursor.y = 0;
+    rterm->ms_tick = 100;
+    rterm->_status_text_previous = NULL;
+}
+
+void rterm_getwinsize(winsize_t *w) {
+    // Get the terminal size
+    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, w) == -1) {
+        perror("ioctl");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void rrawfd(int fd) {
+    struct termios orig_termios;
+    tcgetattr(fd, &orig_termios); // Get current terminal attributes
+
+    struct termios raw = orig_termios;
+    raw.c_lflag &= ~(ICANON | ISIG | ECHO); // ECHO // Disable canonical mode and echoing
+    raw.c_cc[VMIN] = 1;
+    raw.c_cc[VTIME] = 240; // Set timeout for read input
+
+    tcsetattr(fd, TCSAFLUSH, &raw);
+}
+
+// Terminal setup functions
+void enableRawMode(struct termios *orig_termios) {
+
+    struct termios raw = *orig_termios;
+    raw.c_lflag &= ~(ICANON | ECHO); // Disable canonical mode and echoing
+    raw.c_cc[VMIN] = 1;
+    raw.c_cc[VTIME] = 240; // Set timeout for read input
+
+    tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
+}
+
+void disableRawMode(struct termios *orig_termios) {
+    tcsetattr(STDIN_FILENO, TCSAFLUSH,
+              orig_termios); // Restore original terminal settings
+}
+
+void rterm_clear_screen() {
+    printf("\x1b[2J"); // Clear the entire screen
+    printf("\x1b[H");  // Move cursor to the home position (0,0)
+}
+
+void setBackgroundColor() {
+    printf("\x1b[34m"); // Set background color to blue
+}
+
+void rterm_move_cursor(int x, int y) {
+
+    printf("\x1b[%d;%dH", y + 1, x + 1); // Move cursor to (x, y)
+}
+
+void cursor_set(rterm_t *rt, int x, int y) {
+    rt->cursor.x = x;
+    rt->cursor.y = y;
+    rt->cursor.pos = y * rt->size.ws_col + x;
+    rterm_move_cursor(rt->cursor.x, rt->cursor.y);
+}
+void cursor_restore(rterm_t *rt) { rterm_move_cursor(rt->cursor.x, rt->cursor.y); }
+
+void rterm_print_status_bar(rterm_t *rt, char c, unsigned long i) {
+    if (rt->_status_text_previous && !strcmp(rt->_status_text_previous, rt->status_text)) {
+        return;
+    }
+    if (rt->_status_text_previous) {
+        free(rt->_status_text_previous);
+    }
+    rt->_status_text_previous = strdup(rt->status_text);
+    winsize_t ws = rt->size;
+    cursor_set(rt, rt->cursor.x, rt->cursor.y);
+    rterm_move_cursor(0, ws.ws_row - 1);
+
+    char output_str[1024];
+    output_str[0] = 0;
+
+    // strcat(output_str, "\x1b[48;5;240m");
+
+    for (int i = 0; i < ws.ws_col; i++) {
+        strcat(output_str, " ");
+    }
+    char content[500];
+    content[0] = 0;
+    if (!rt->status_text) {
+        sprintf(content, "\rp:%d:%d | k:%c:%d | i:%ld ", rt->cursor.x + 1, rt->cursor.y + 1, c == 0 ? '0' : c, c, i);
+    } else {
+        sprintf(content, "\r%s", rt->status_text);
+    }
+    strcat(output_str, content);
+    // strcat(output_str, "\x1b[0m");
+    printf("%s", output_str);
+    cursor_restore(rt);
+}
+
+void rterm_show_cursor() {
+    printf("\x1b[?25h"); // Show the cursor
+}
+
+void rterm_hide_cursor() {
+    printf("\x1b[?25l"); // Hide the cursor
+}
+
+rshell_keypress_t rshell_getkey(rterm_t *rt) {
+    static rshell_keypress_t press;
+    press.c = 0;
+    press.ctrl = false;
+    press.shift = false;
+    press.escape = false;
+    press.pressed = rfd_wait(0, rt->ms_tick);
+    if (!press.pressed) {
+        return press;
+    }
+    press.c = getchar();
+    char ch = press.c;
+    if (ch == '\x1b') {
+        // Get detail
+        ch = getchar();
+
+        if (ch == '[') {
+            // non char key:
+            press.escape = true;
+
+            ch = getchar(); // is a number. 1 if shift + arrow
+            press.c = ch;
+            if (ch >= '0' && ch <= '9')
+                ch = getchar();
+            press.c = ch;
+            if (ch == ';') {
+                ch = getchar();
+                press.c = ch;
+                if (ch == '5') {
+                    press.ctrl = true;
+                    press.c = getchar(); // De arrow
+                }
+            }
+        } else if (ch == 27) {
+            press.escape = true;
+            press.c = ch;
+        } else {
+            press.c = ch;
+        }
+    }
+    return press;
+}
+
+// Main function
+void rterm_loop(rterm_t *rt) {
+    struct termios orig_termios;
+    tcgetattr(STDIN_FILENO, &orig_termios); // Get current terminal attributes
+    enableRawMode(&orig_termios);
+
+    int x = 0, y = 0; // Initial cursor position
+    char ch = 0;
+
+    ;
+    while (1) {
+        rterm_getwinsize(&rt->size);
+        rt->cursor.available = rt->size.ws_col * rt->size.ws_row;
+        if (rt->tick) {
+            rt->tick(rt);
+        }
+
+        rterm_hide_cursor();
+        setBackgroundColor();
+        rterm_clear_screen();
+        if (rt->before_draw) {
+            rt->before_draw(rt);
+        }
+        rterm_print_status_bar(rt, ch, rt->iterations);
+        if (rt->after_draw) {
+            rt->after_draw(rt);
+        }
+        if (!rt->iterations || (x != rt->cursor.x || y != rt->cursor.y)) {
+            if (rt->cursor.y == rt->size.ws_row) {
+                rt->cursor.y--;
+            }
+            if (rt->cursor.y < 0) {
+                rt->cursor.y = 0;
+            }
+            x = rt->cursor.x;
+            y = rt->cursor.y;
+            if (rt->before_cursor_move)
+                rt->before_cursor_move(rt);
+            cursor_set(rt, rt->cursor.x, rt->cursor.y);
+            if (rt->after_cursor_move)
+                rt->after_cursor_move(rt);
+            // x = rt->cursor.x;
+            // y = rt->cursor.y;
+        }
+        if (rt->show_cursor)
+            rterm_show_cursor();
+
+        fflush(stdout);
+
+        rt->key = rshell_getkey(rt);
+        if (rt->key.pressed && rt->before_key_press) {
+            rt->before_key_press(rt);
+        }
+        rshell_keypress_t key = rt->key;
+        ch = key.c;
+        if (ch == 'q')
+            break; // Press 'q' to quit
+        if (key.c == -1) {
+            nsleep(1000 * 1000);
+        }
+        // Escape
+        if (key.escape) {
+            switch (key.c) {
+            case 65: // Move up
+                if (rt->cursor.y > -1)
+                    rt->cursor.y--;
+                break;
+            case 66: // Move down
+                if (rt->cursor.y < rt->size.ws_row)
+                    rt->cursor.y++;
+                break;
+            case 68: // Move left
+                if (rt->cursor.x > 0)
+                    rt->cursor.x--;
+                if (key.ctrl)
+                    rt->cursor.x -= 4;
+                break;
+            case 67: // Move right
+                if (rt->cursor.x < rt->size.ws_col) {
+                    rt->cursor.x++;
+                }
+                if (key.ctrl) {
+                    rt->cursor.x += 4;
+                }
+                break;
+            }
+        }
+
+        if (rt->key.pressed && rt->after_key_press) {
+            rt->after_key_press(rt);
+        }
+        rt->iterations++;
+
+        //  usleep (1000);
+    }
+
+    // Cleanup
+    printf("\x1b[0m"); // Reset colors
+    rterm_clear_screen();
+    disableRawMode(&orig_termios);
+}
+#endif
+
+#ifndef RTREE_H
+#define RTREE_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct rtree_t {
+    struct rtree_t *next;
+    struct rtree_t *children;
+    char c;
+    void *data;
+} rtree_t;
+
+rtree_t *rtree_new() {
+    rtree_t *b = (rtree_t *)rmalloc(sizeof(rtree_t));
+    b->next = NULL;
+    b->children = NULL;
+    b->c = 0;
+    b->data = NULL;
+    return b;
+}
+
+rtree_t *rtree_set(rtree_t *b, char *c, void *data) {
+    while (b) {
+        if (b->c == 0) {
+            b->c = *c;
+            c++;
+            if (*c == 0) {
+                b->data = data;
+                // printf("SET1 %c\n", b->c);
+                return b;
+            }
+        } else if (b->c == *c) {
+            c++;
+            if (*c == 0) {
+                b->data = data;
+                return b;
+            }
+            if (b->children) {
+                b = b->children;
+            } else {
+                b->children = rtree_new();
+                b = b->children;
+            }
+        } else if (b->next) {
+            b = b->next;
+        } else {
+            b->next = rtree_new();
+            b = b->next;
+            b->c = *c;
+            c++;
+            if (*c == 0) {
+                b->data = data;
+                return b;
+            } else {
+                b->children = rtree_new();
+                b = b->children;
+            }
+        }
+    }
+    return NULL;
+}
+
+rtree_t *rtree_find(rtree_t *b, char *c) {
+    while (b) {
+        if (b->c == *c) {
+            c++;
+            if (*c == 0) {
+                return b;
+            }
+            b = b->children;
+            continue;
+        }
+        b = b->next;
+    }
+    return NULL;
+}
+
+void rtree_free(rtree_t *b) {
+    if (!b)
+        return;
+    rtree_free(b->children);
+    rtree_free(b->next);
+    rfree(b);
+}
+
+void *rtree_get(rtree_t *b, char *c) {
+    rtree_t *t = rtree_find(b, c);
+    if (t) {
+        return t->data;
+    }
+    return NULL;
+}
+#endif
+#ifndef RLEXER_H
+#define RLEXER_H
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+
+#define RTOKEN_VALUE_SIZE 1024
+
+typedef enum rtoken_type_t {
+    RT_UNKNOWN = 0,
+    RT_SYMBOL,
+    RT_NUMBER,
+    RT_STRING,
+    RT_PUNCT,
+    RT_OPERATOR,
+    RT_EOF = 10,
+    RT_BRACE_OPEN,
+    RT_CURLY_BRACE_OPEN,
+    RT_BRACKET_OPEN,
+    RT_BRACE_CLOSE,
+    RT_CURLY_BRACE_CLOSE,
+    RT_BRACKET_CLOSE
+} rtoken_type_t;
+
+typedef struct rtoken_t {
+    rtoken_type_t type;
+    char value[RTOKEN_VALUE_SIZE];
+    unsigned int line;
+    unsigned int col;
+} rtoken_t;
+
+static char *_content;
+static unsigned int _content_ptr;
+static unsigned int _content_line;
+static unsigned int _content_col;
+
+static int isgroupingchar(char c) {
+    return (c == '{' || c == '}' || c == '(' || c == ')' || c == '[' || c == ']' || c == '"' || c == '\'');
+}
+
+static int isoperator(char c) {
+    return (c == '+' || c == '-' || c == '/' || c == '*' || c == '=' || c == '>' || c == '<' || c == '|' || c == '&');
+}
+
+static rtoken_t rtoken_new() {
+    rtoken_t token;
+    memset(&token, 0, sizeof(token));
+    token.type = RT_UNKNOWN;
+    return token;
+}
+
+rtoken_t rlex_number() {
+    rtoken_t token = rtoken_new();
+    token.col = _content_col;
+    token.line = _content_line;
+    bool first_char = true;
+    int dot_count = 0;
+    char c;
+    while (isdigit(c = _content[_content_ptr]) || (first_char && _content[_content_ptr] == '-') ||
+           (dot_count == 0 && _content[_content_ptr] == '.')) {
+        if (c == '.')
+            dot_count++;
+        first_char = false;
+        char chars[] = {c, 0};
+        strcat(token.value, chars);
+        _content_ptr++;
+        _content_col++;
+    }
+    token.type = RT_NUMBER;
+    return token;
+}
+
+static rtoken_t rlex_symbol() {
+    rtoken_t token = rtoken_new();
+
+    token.col = _content_col;
+    token.line = _content_line;
+    char c;
+    while (isalpha(_content[_content_ptr]) || _content[_content_ptr] == '_') {
+        c = _content[_content_ptr];
+        char chars[] = {c, 0};
+        strcat(token.value, chars);
+        _content_ptr++;
+        _content_col++;
+    }
+    token.type = RT_SYMBOL;
+    return token;
+}
+
+static rtoken_t rlex_operator() {
+
+    rtoken_t token = rtoken_new();
+
+    token.col = _content_col;
+    token.line = _content_line;
+    char c;
+    bool is_first = true;
+    while (isoperator(_content[_content_ptr])) {
+        if (!is_first) {
+            if (_content[_content_ptr - 1] == '=' && _content[_content_ptr] == '-') {
+                break;
+            }
+        }
+        c = _content[_content_ptr];
+        char chars[] = {c, 0};
+        strcat(token.value, chars);
+        _content_ptr++;
+        _content_col++;
+        is_first = false;
+    }
+    token.type = RT_OPERATOR;
+    return token;
+}
+
+static rtoken_t rlex_punct() {
+
+    rtoken_t token = rtoken_new();
+
+    token.col = _content_col;
+    token.line = _content_line;
+    char c;
+    bool is_first = true;
+    while (ispunct(_content[_content_ptr])) {
+        if (!is_first) {
+            if (_content[_content_ptr] == '"') {
+                break;
+            }
+            if (_content[_content_ptr] == '\'') {
+                break;
+            }
+            if (isgroupingchar(_content[_content_ptr])) {
+                break;
+            }
+            if (isoperator(_content[_content_ptr])) {
+                break;
+            }
+        }
+        c = _content[_content_ptr];
+        char chars[] = {c, 0};
+        strcat(token.value, chars);
+        _content_ptr++;
+        _content_col++;
+        is_first = false;
+    }
+    token.type = RT_PUNCT;
+    return token;
+}
+
+static rtoken_t rlex_string() {
+    rtoken_t token = rtoken_new();
+    char c;
+    token.col = _content_col;
+    token.line = _content_line;
+    char str_chr = _content[_content_ptr];
+    _content_ptr++;
+    while (_content[_content_ptr] != str_chr) {
+        c = _content[_content_ptr];
+        if (c == '\\') {
+            _content_ptr++;
+            c = _content[_content_ptr];
+            if (c == 'n') {
+                c = '\n';
+            } else if (c == 'r') {
+                c = '\r';
+            } else if (c == 't') {
+                c = '\t';
+            } else if (c == str_chr) {
+                c = str_chr;
+            }
+
+            _content_col++;
+        }
+        char chars[] = {c, 0};
+        strcat(token.value, chars);
+        _content_ptr++;
+        _content_col++;
+    }
+    _content_ptr++;
+    token.type = RT_STRING;
+    return token;
+}
+
+void rlex(char *content) {
+    _content = content;
+    _content_ptr = 0;
+    _content_col = 1;
+    _content_line = 1;
+}
+
+static void rlex_repeat_str(char *dest, char *src, unsigned int times) {
+    for (size_t i = 0; i < times; i++) {
+        strcat(dest, src);
+    }
+}
+
+rtoken_t rtoken_create(rtoken_type_t type, char *value) {
+    rtoken_t token = rtoken_new();
+    token.type = type;
+    token.col = _content_col;
+    token.line = _content_line;
+    strcpy(token.value, value);
+    return token;
+}
+
+rtoken_t rlex_next() {
+    while (true) {
+
+        _content_col++;
+
+        if (_content[_content_ptr] == 0) {
+            return rtoken_create(RT_EOF, "eof");
+        } else if (_content[_content_ptr] == '\n') {
+            _content_line++;
+            _content_col = 1;
+            _content_ptr++;
+        } else if (isspace(_content[_content_ptr])) {
+            _content_ptr++;
+        } else if (isdigit(_content[_content_ptr]) || (_content[_content_ptr] == '-' && isdigit(_content[_content_ptr + 1]))) {
+            return rlex_number();
+        } else if (isalpha(_content[_content_ptr]) || _content[_content_ptr] == '_') {
+            return rlex_symbol();
+        } else if (_content[_content_ptr] == '"' || _content[_content_ptr] == '\'') {
+            return rlex_string();
+        } else if (isoperator(_content[_content_ptr])) {
+            return rlex_operator();
+        } else if (ispunct(_content[_content_ptr])) {
+            if (_content[_content_ptr] == '{') {
+
+                _content_ptr++;
+                return rtoken_create(RT_CURLY_BRACE_OPEN, "{");
+            }
+            if (_content[_content_ptr] == '}') {
+
+                _content_ptr++;
+                return rtoken_create(RT_CURLY_BRACE_CLOSE, "}");
+            }
+            if (_content[_content_ptr] == '(') {
+
+                _content_ptr++;
+                return rtoken_create(RT_BRACE_OPEN, "(");
+            }
+            if (_content[_content_ptr] == ')') {
+
+                _content_ptr++;
+                return rtoken_create(RT_BRACE_CLOSE, ")");
+            }
+            if (_content[_content_ptr] == '[') {
+
+                _content_ptr++;
+                return rtoken_create(RT_BRACKET_OPEN, "[");
+            }
+            if (_content[_content_ptr] == ']') {
+
+                _content_ptr++;
+                return rtoken_create(RT_BRACKET_CLOSE, "]");
+            }
+            return rlex_punct();
+        }
+    }
+}
+
+char *rlex_format(char *content) {
+    rlex(content);
+    char *result = (char *)malloc(strlen(content) + 4096);
+    result[0] = 0;
+    unsigned int tab_index = 0;
+    char *tab_chars = "    ";
+    unsigned int col = 0;
+    rtoken_t token_previous;
+    token_previous.value[0] = 0;
+    token_previous.type = RT_UNKNOWN;
+    while (true) {
+        rtoken_t token = rlex_next();
+        if (token.type == RT_EOF) {
+            break;
+        }
+
+        // col = strlen(token.value);
+
+        if (col == 0) {
+            rlex_repeat_str(result, tab_chars, tab_index);
+            // col = strlen(token.value);// strlen(tab_chars) * tab_index;
+        }
+
+        if (token.type == RT_STRING) {
+            strcat(result, "\"");
+
+            char string_with_slashes[strlen(token.value) * 2 + 1];
+            rstraddslashes(token.value, string_with_slashes);
+            strcat(result, string_with_slashes);
+
+            strcat(result, "\"");
+            // col+= strlen(token.value) + 2;
+            // printf("\n");
+            // printf("<<<%s>>>\n",token.value);
+
+            memcpy(&token_previous, &token, sizeof(token));
+            continue;
+        }
+        if (!(strcmp(token.value, "{"))) {
+            if (col != 0) {
+                strcat(result, "\n");
+                rlex_repeat_str(result, "    ", tab_index);
+            }
+            strcat(result, token.value);
+
+            tab_index++;
+
+            strcat(result, "\n");
+
+            col = 0;
+
+            memcpy(&token_previous, &token, sizeof(token));
+            continue;
+        } else if (!(strcmp(token.value, "}"))) {
+            unsigned int tab_indexed = 0;
+            if (tab_index)
+                tab_index--;
+            strcat(result, "\n");
+
+            rlex_repeat_str(result, tab_chars, tab_index);
+            tab_indexed++;
+
+            strcat(result, token.value);
+            strcat(result, "\n");
+            col = 0;
+
+            memcpy(&token_previous, &token, sizeof(token));
+            continue;
+        }
+        if ((token_previous.type == RT_SYMBOL && token.type == RT_NUMBER) ||
+            (token_previous.type == RT_NUMBER && token.type == RT_SYMBOL) || (token_previous.type == RT_PUNCT && token.type == RT_SYMBOL) ||
+            (token_previous.type == RT_BRACE_CLOSE && token.type == RT_SYMBOL) ||
+            (token_previous.type == RT_SYMBOL && token.type == RT_SYMBOL)) {
+            if (token_previous.value[0] != ',' && token_previous.value[0] != '.') {
+                if (token.type != RT_OPERATOR && token.value[0] != '.') {
+                    strcat(result, "\n");
+                    rlex_repeat_str(result, tab_chars, tab_index);
+                }
+            }
+        }
+
+        if (token.type == RT_OPERATOR) {
+            strcat(result, " ");
+        }
+        if (token.type == RT_STRING) {
+            strcat(result, "\"");
+        }
+        strcat(result, token.value);
+        if (token.type == RT_STRING) {
+            strcat(result, "\"");
+        }
+
+        if (token.type == RT_OPERATOR) {
+            strcat(result, " ");
+        }
+        if (!strcmp(token.value, ",")) {
+            strcat(result, " ");
+        }
+        col += strlen(token.value);
+        memcpy(&token_previous, &token, sizeof(token));
+    }
+    return result;
+}
+#endif
+
+#ifndef RLIB_MAIN
+#define RLIB_MAIN
+#ifndef RMERGE_H
+#define RMERGE_H
+// #include "../mrex/rmatch.h"
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+bool has_error = false;
+
+char *extract_script_src_include(char *line, char *include_path) {
+    include_path[0] = 0;
+    rrex3_t *rrex;
+    rrex = rrex3(NULL, line, "<script.*src=\"(.*)\".*<.*script.*>");
+    if (rrex) {
+        strcpy(include_path, rrex->matches[0]);
+        rrex3_free(rrex);
+        return include_path;
+    }
+    return NULL;
+}
+
+char *extract_c_local_include(char *line, char *include_path) {
+    //
+    /*
+        char res;
+        res= rmatch_extract(line, "#include.*"\".*\"");
+
+
+        printf("%MATCH:%s\n", res);
+    */
+
+    include_path[0] = 0;
+    rrex3_t *rrex;
+    rrex = rrex3(NULL, line, "[^\\\\*]^#include .*\"(.*)\"");
+    if (rrex) {
+        strcpy(include_path, rrex->matches[0]);
+        rrex3_free(rrex);
+        return include_path;
+    }
+    return NULL;
+}
+
+char *rmerge_readline(FILE *f) {
+    static char data[4096];
+    data[0] = 0;
+    int index = 0;
+    char c;
+    while ((c = fgetc(f)) != EOF) {
+        if (c != '\0') {
+            data[index] = c;
+            index++;
+            if (c == '\n')
+                break;
+        }
+    }
+    data[index] = 0;
+    if (data[0] == 0)
+        return NULL;
+    return data;
+}
+void writestring(FILE *f, char *line) {
+    char c;
+    while ((c = *line) != '\0') {
+        fputc(c, f);
+        line++;
+    }
+}
+char files_history[8096];
+char files_duplicate[8096];
+bool is_merging = false;
+
+void merge_file(char *source, FILE *d) {
+    if (is_merging == false) {
+        is_merging = true;
+        files_history[0] = 0;
+        files_duplicate[0] = 0;
+    }
+    if (strstr(files_history, source)) {
+        if (strstr(files_duplicate, source)) {
+            rprintmf(stderr, "\\l Already included: %s. Already on duplicate list.\n", source);
+        } else {
+            rprintcf(stderr, "\\l Already included: %s. Adding to duplicate list.\n", source);
+            strcat(files_duplicate, source);
+            strcat(files_duplicate, "\n");
+        }
+        return;
+    } else {
+        rprintgf(stderr, "\\l Merging: %s.\n", source);
+        strcat(files_history, source);
+        strcat(files_history, "\n");
+    }
+    FILE *fd = fopen(source, "rb");
+    if (!fd) {
+        rprintrf(stderr, "\\l File does not exist: %s\n", source);
+        has_error = true;
+        return;
+    }
+
+    char *line;
+    char include_path[4096];
+    while ((line = rmerge_readline(fd))) {
+
+        include_path[0] = 0;
+        if (!*line)
+            break;
+
+        //
+        char *inc = extract_c_local_include(line, include_path);
+        if (!inc)
+            inc = extract_script_src_include(line, include_path);
+
+        /*
+         if (!strncmp(line, "#include ", 9)) {
+             int index = 0;
+             while (line[index] != '"' && line[index] != 0) {
+                 index++;
+             }
+             if (line[index] == '"') {
+                 int pindex = 0;
+                 index++;
+                 while (line[index] != '"') {
+                     include_path[pindex] = line[index];
+                     pindex++;
+                     index++;
+                 }
+                 if (line[index] != '"') {
+                     include_path[0] = 0;
+                 } else {
+                     include_path[pindex] = '\0';
+                 }
+             }
+         }*/
+        if (inc) {
+            merge_file(inc, d);
+        } else {
+            writestring(d, line);
+        }
+    }
+    fclose(fd);
+    writestring(d, "\n");
+}
+
+int rmerge_main(int argc, char *argv[]) {
+    char *file_input = NULL;
+    if (argc != 2) {
+        printf("Usage: <input-file>\n");
+    } else {
+        file_input = argv[1];
+        // file_output = argv[2];
+    }
+    FILE *f = tmpfile();
+    printf("// RETOOR - %s\n", __DATE__);
+    merge_file(file_input, f);
+    rewind(f);
+    char *data;
+    int line_number = 0;
+    while ((data = rmerge_readline(f))) {
+        if (line_number) {
+            printf("/*%.5d*/    ", line_number);
+            line_number++;
+        }
+        printf("%s", data);
+    }
+    printf("\n");
+    if (has_error) {
+        rprintrf(stderr, "\\l Warning: there are errors while merging this file.\n");
+    } else {
+        rprintgf(stderr, "\\l Merge succesful without error(s).%s\n", remo_get("fire"));
+    }
+    return 0;
+}
+#endif
+
+void forward_argument(int *argcc, char *argv[]) {
+    int argc = *argcc;
+    for (int i = 0; i < argc; i++) {
+        argv[i] = argv[i + 1];
+    }
+    argc--;
+    *argcc = argc;
+}
+
+int rlib_main(int argc, char *argv[]) {
+
+    if (argc == 1) {
+        printf("rlib\n\n");
+        printf("options:\n");
+        printf(" httpd - a http file server. Accepts port as argument.\n");
+        printf(" rmerge - a merge tool. Converts c source files to one file \n"
+               "          with local includes by giving main file as argument.\n");
+        printf(" rcov - coverage tool theat cleans up after himself. Based on "
+               "lcov.\n");
+        printf(" rcase - tool to swap input file automatically between"
+               "         camel case and snake case.\n");
+        return 0;
+    }
+
+    forward_argument(&argc, argv);
+
+    if (!strcmp(argv[0], "httpd")) {
+
+        return rhttp_main(argc, argv);
+    }
+    if (!strcmp(argv[0], "rmerge")) {
+        return rmerge_main(argc, argv);
+    }
+    if (!strcmp(argv[0], "rcov")) {
+        return rcov_main(argc, argv);
+    }
+    if (!strcmp(argv[0], "rcase")) {
+        return rcase_main(argc, argv);
+    }
+
+    return 0;
+}
+
+#endif
+
+// END OF RLIB
+#endif
diff --git a/sorm b/sorm
index ba5071a3308e867cf74bc2051c5777e366c39b9e..215b8131df29a6633cfb4927a1e0568ff2b4a91a 100755
GIT binary patch
delta 47835
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
Z@94r=lpbOa@T@-He{V-&i2Wn`{{o}q+Q<L^

delta 47903
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

diff --git a/sorm.h b/sorm.h
index a3d189b..aacf85c 100644
--- a/sorm.h
+++ b/sorm.h
@@ -2,7 +2,7 @@
 #define SORM_H
 #include "str.h"
 #include <ctype.h>
-#include <rlib.h>
+#include "rlib.h"
 #include <sqlite3.h>
 #include <stdarg.h>
 #include <stdbool.h>
@@ -550,4 +550,4 @@ void sormfmtd(char *csv) {
     free(formatted);
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/sorm.so b/sorm.so
index 369b11ca8055e4502f004a129e7ab72771ed2027..988baecce76b24c1dddced3b7d447856147e24bb 100755
GIT binary patch
delta 60422
zcmZ@>cR*Cf^Jkx)ih_WG$6*6|K@aR$K}E1*?+W&=DA@5pMaA<Jvg%qBiQO1Wj6sbB
zY}le;*O&;2#zTyvCJ{^IH@mZU?|k|G{DXTtpPA3j%$B!r-`;sI%k5s4Tk?A6R|Uk0
z|9f>PwYlQCY<9!CH?O?)JJUb6>D$<M<xPI?ryPE+RH|rL_z?9L;fGV@Qch0goXR@Y
zrG8cPWDgChGJ@Qs8>)nn2Q;^e-rzo55xl3xUni$B2Gk!%J*w(SPg=KX7zv=!RrQ94
zDX6(xGLP{_&3-hss*y~h*`WV~=E3z5YVaLlxGtG@Nap^MIfkbA>Pbtw$Jc0BJqbC(
zY&tH;`44^NYa~BXKR>-vnbDSh4M_~0;AbRv=mtNd!O$0dXeZ59c%oS!n(L=09q2p1
z5uMKuM4jbQr&?9i@z{e^#!LBY=~n0{lpAGumwZrvAx*6oMi$Y$YOBdMI=8yfu%Z#F
z%##e|%Aw{8no(VE_%#)I@+8_(Hoyk@3eeUJZM#aew+Gr5QNJ2SXr5j*^oEODP-njM
zq)}Pa38o2v4t;_A#U;bS(un><4{@|B8r_rV+46|~PICcWvK`UI5?v;lZ&Ht%dUA`_
zt!Xs4FGl_tsk2@(w4>2A^@b`_k-?VL)C$Nygr)-e!(K#p;fK>}8Qn0NUDFuo_6Wtf
zl39^?tFRyC+oV;RY?1G2U@g7j%m5Tyq}4pxMLN+aK*PHudRL+WvXxV4O05x!t{Ht@
zt08$t{c7t;EDfq{G+Y>h;Z2YRcbzeSXEdR<KJd<NL|aMplnl@5SFFZOx;Q|}DZNxX
zj4Y%cb@XH^ty{-v2w8_JT_i&V8O%8vT}N;DA{J3Ei7s=)+Hca-I!2O7vq9&d9;jmr
zX`t+gft1uWlGQY@uHF#ufquG6f7;4KccD?BvzDgR)ssTHr*0T|NMC_|CnM?)k@_Zg
ztha#r)iaVUv{$__ADtWOw2;1KxuQ<#S@gSloeYO(eGbp8f^ZY+QD09^(7N@FhRF?(
zf2gGJkjWiJqw7QO)AX#Va%7ljYJFp137I%s>Yqv5^&ODYCjU~7bt@(QMp8fn{q=_K
z{XehwBIK7(df(D0|1iUZb?EuO(yP^y`2o%F*OLMCzJD0;qkavHq%rN)KyR=<K(?7u
zKUGe2yJ!NSCzFwFnnZWWy8fnz06n)1(XmM36kZWMSx9pm=*d|6u7T08Jp#eCl3}pa
zSxrM4>PbI3sG-sD`!v+KAa&xU4`*p=L%pF^B-S!oqTfn1gJw4jGj!RBwm+eg(?r>j
zyJ(=%NdBNvMm>2==fd??y2l8!sTmc=NH&wyZ$V!fp)NTu!oU*${?cPa>#1LWp1h?&
z0bwxXCct$Z-4I|T+v%kMqt7H~<h0EqL9(}ar_yqP4aqSY5~w$Hoq>+Fl+^9zXqZBy
z1NCGhO$sy`V%wn33#rpaPDk5mc3@SH94Rf7!@d?Jjr8OqH8ct%r)X3oy&+ECwMIzI
zYO?V!&=k;YL-#Z?l3(b3_`8QXHx474Xs^b4gO409{?clxto1le0Ce&W^yycL_LITQ
zpobdk$w7LlvC&XTHeg?=6D)P6QjaEjpQ2o3u+0OTWKv6&q3xS=GPIKObZ2Q?L-vq*
zG_}bHvY(QsFjei6&5KM<(Xt;_{0RlyrR@tjRTa_BO^t@6#fUzT=sh`_qG?J~-aq#=
z9bw2^iOkm}^Q|)2;(t-UW_rWH!H8Cn=#ol^KB2vu8Od^*&`htmZKNBUH8iYSg{pOA
zWuelQM4Agk|ExrYUnHuRtv{1`G&hn9G^BZ$AzaRLwmInsIr%T4sm=AI2R+u@*l6^^
z&qG=v2SdsJSo>JXe^btp`aRUAMMK4BDecl?xMAsf)Pg9)zjD%gH_d3FCpGB(7DmH9
zxtOwfT1wtF|E7LHdPCL-WUvj8ag{M4U(;TIwljYo<!`bl?WPGqBghV#8>H{NEbeoi
zpJbH9WFLZCi1=4e);ns+=lX?mz_z6!E%kvtuOfO?T6xK7wu}+w&=JMIVe%gEh9<Q%
z8memUIvz4xTWEGmJ!wYsK&Pba_qK_mq^$P^4Q!=1RBM8HXpGf3t&^FYLZbj3D3@$q
zB$_N^`Ie>t`dt$gM@Zie$!^)5X0+0iY<j;HEW6~SS5NAUl_Tmn^=qvsGigw37<IBw
z*}8YCTpR__1kkxbH?%gA2J{kWmY1uI=8`Q-`tzQ8w9y+5e}(?k!jPP5$RW_1h5%Zx
z1d465Lp|wjZ5rK14|m+8Heuv0&4%ljG_Q?O@##Z-+IE7qYgAjk&x+MZ-9uJfTe?^x
zoPN=^A^DDGwAGt#%9~z$S^w*j*rzHsL}S~n!%vQxNfhM@emE_Z9+gi=L9ncBuIyRO
zhoRgJc=^9LIWkA$t&a|9=h1mtZ`27u6{oV&QLj!Ye}x}T)g@>5K`2-z^$*B7?HWDQ
z&Pe*x+;)0H<Z0AtDs{e;I*|2XBRNe&f+6?vu8=5W|3yx0cWE@BOH+^`MlvjsEz^^x
z0>dbp4LYag6xd99SRi$RC<)QSm@|YJeTD@gm?L?LWM8frPe+C{B#AU7MBh327AmDk
zr9(0WE;2Q~QvOj6rTeL<e@@CTOMQR(3M!7F&h1ASCN)K!XsJ_7rT`Y8?Tv6_Jk(xK
z9??s1U5CDFZ!{E_<7vLscag*S0S)QEJJ_HOMzWJ8bqFJAG#e!6XkG`SVbUF}#YZM_
zfSh*j(!h>-@-^+;(P)@1r<a+Mxw}l$FEpj2-skiZG}RSD_?leEmK;UTbR5nXOrb_%
zroBSL4ExKX>HtY}N#-)29twpAqI>Ad5s4PadBI3?fnh22=oDs1?Sne4rA||M!`noo
zJLwH$Rv>B{)wO+aG&G>8os7gvvpea@GMd-PXt?W+p4gJxPBuUj8W^TG?3s={p|Tc}
zO#N&c6=o#<G$m|=;`tkW9oCTSqJH5<GM)B<zjJ9qIA2t32%ilL29M5qa*x*SY&2AB
zfRz;@tJC)~>=QJ)Gd#BTrz<))B;)C^&Le!@>_^p?QuT^#M5XEBMqO6bf(Oft>3YNN
zv#6Ck0&@;Z;@=PS6`<)7-Ks$!QNL(?=f@H~s6jtS`B9DB=^WOTu8~)v3DJ5(b%|za
z(023?py3kD(V*jLE}&B+TA)GaQI8q$<RVe0$j@W^iiQBXU83$9G=oM1dO@PT8uS58
z1@w_b12pJ!nhoeHi3V#>H%eye4W8#Q8xb0`9t{N4DA7m_8cd@A4VCD04LY2r06I#d
z@fvg%%>Z=1M3Xh>O8N@W6p3!tpnIubjNWiSq6anTG1?2zQxZ+rpqFU^pw}gur9uCo
zhhp@d^Cg<2K|e{kRU<EU0kc=2kyoZ3v9K<Xs8iJEE#82J0NO~R?iv)f8vyMnQC|((
zg{A`9Q=$PHv>(j|bg)E&HRxDMX6X%+BpRVXqiG<Zu@a5cpo?e}pi3n>U4yQpDS&R2
zXuJm9MKb{XMxx0Y^eBA==n08#)u7j@-)z0%rbG{F&_8G|K%Yr8U4y=+3A6Q`|B+~x
z2K`sc?`h;D6WcULBQHa9p)NOx7HCi}>M=)eFi6yC<mWA3n}z^dU!v|Bv>A;Cw53FS
zHE0K#3TT)_12kxFnhj`wi3V%X5tPh@ktop!4LXem0y<Noks5R%jRJI$M5k-eWSRo#
z8i~ehP?*&L-6hdv4GJv|=n08#)u7j?-#oqHhC~l)&|he;dHT+|5>3~jg;IV|BmXGn
zSsJ;H9)h}@FUl6zpguGg&?*uw(4cjx$9%n^fkd4~ecs}2XvloMbBILUY2bW4oipFv
z&{;}+HTolIDzJ@}Xn+QtPqP6vNi<l4uB2pv-jFQO2o1WK1_HWOqLCVOH;n>xpG2o?
z(DO6}&`T1H*PxGR2B5!7G+BebpsyC_JHL_WRt;)vsofg6t)&iX<W96#oZg_jge{e>
zL7iy=pk*bRr9sQlLxAcfnxjE|X)d5OC0d|C1F6SCy`h;zokoA&%E2@Q&`^oGYtSw<
z8ql5+_0^yQX)2(@BpRSWN78IS$4N9;gHEHwq&LJ!G(v;6p@D$f`d*|4g_#`CrP6k~
z23<*008N%?yawGuGXVWsqRAR`Gkpc9t*33(ps=uvhn^;F4{Fdf+6&MV5>3~j=`;b*
z^AgR{pqJ<&K(9$OM}yv>xq$vG(E<&cLp>7oh9?qr8uNMk7SNCcedoU=>aIaQO1Za2
zPA+3F_0`Br(^RO-MWO*3)SG4lT2Z3G8Wi^T7U>OjB^seY8__^On@KcMgTiVJ&`^m^
z*P#7q3ZR1}8m~de(F{N*Ni<o5E}*XfjhE<F4Vp~-7Q;P4q6anT4%!RQJrYgVpeJYo
zpcxX)(x6xAAwaVwnxjGQ(p*3vO0+<OKBXQ@^oHjWbsGD5i|c3zprx;13%YC2nlu{F
zdJ^^3piO8hpg|H1(4bvtHlRHv8mvKelq9Nmq6iIojRpd0yC+6!P#+ovsO>&AU4ssw
zDS!@<^~P&Zn8N|J&*2&r=5RpmbGQbbLj9KN4KpP3K@A#5djYygqUjp6A58$%wo=W~
zpv&kXKvzoJ91XgG<^uYqL<=<N5$dr_Z#XVdr*WUR??oB{=uZ-L*PxGRG@y?q>Z?It
z(o{hIl4yViB{Un*5?8V31Zz+)N|wX!x<n&1XjK{rXbp)*YS0EW3eZLpovuMcXbPa6
zBpR<ld(jL)`%5%ggSMfs039aLtr~O@^-F@)qeKsC(22Acpi?E9u0dmI0-$pxnx#SG
z>7gXO^Ad^X(9|S7wI;b6R!T{MM*j=yu|jWHCsC*IpSS5|8UpB6iMngh-834|eG>K6
zphsycpeH06pg}LtY(OtdG+2Y)q{OT@+?8mA27O8c0sU2?ks4G-qX2y=(dio0iKYOm
zlkc(OHK-fS0Mt{W$r`j8eFbQ3iEh=PO{w2Xc-D~UK@A#4djZ-_qUjoRAWZ;tm_)NQ
z=p=dw&=`s4Xwbzp7toawEzqEwsfR^x*dbA;37@y`k2D0(a}ssepf_nWpbsVLt3jX9
zR6yTIG(dyuXf~i_ugNj1K`T+RN^kI!XoLo>PXhrBkZ7a^ZAYU3?I_Xd8nhQp0kpqF
z<2C4TngQr2i6(2%ne-K)b0oS|gTk0ytv4)_=s^t{NqYg><1WT~QG<4&39I!af^Jwn
z0ybjbtv1r&<We4WCVt);;WQ)}<{QZotU-Iw=w!Wf7l}sDz+^q$om_{6(`>NnCgsyL
zR*w#o6grX&I=uExjbfzf;p6|5EKV97KJ&hJ36h)UMaVru%CHv-=}2y|#>L2BVrHvA
zkwm4PD@J0Ak$0?RNpga8Nqbw8jB_W)*$8hEO=_lPdy~n8JWXrsL-v;>oznjFBNt1P
z09LvIsTFdR?@8t@fj{Bq(86$YuzPr7dQ4e+VR1UicX22w;pTpz*1J@A(uMG(yVmKf
z$e*ksUDMVyAbp5Zdk;IbmUyzPs-%>1e;+$^nN(!ejHE`X@FPV<oQHYLRy^65_C(L-
z8c9oXg?(=%e#DvGfs#w#FNjlk(w*?6OzUA*DS$);K7%cPDd}{us3<W#wtu)e@!|*0
z=5)L`ciiH7Q7B#GX3=ba05Q1qS0&xp%>dGf7+8rw(#)l?3e0BVfuw=5VK2*=M#`_N
z4^GfP;-NfCV><&$)h3tHpc2SNdyF64xDam9txM((Wgg|5v(^iHF)Cj3itR;3$t=~M
zlxHrDNIUO0M*&NMq%Mvtbc*3gv~smdY*ZsMnxwIdjmUD+ko9Uz+LCE3xiRr1E!mF7
zB)p@?0kE{7`i^aarQm{Yqkep8-bw}GNg3eB_*LAGGp9z26zJjr<@7raaa-L~7TAQ8
zS1#{j9zLW(;|sb2+#1@>9QrXSJLwFlR1yR{q%~-ZA=Um~5X7_9O-RM2i?Pyv1z<Ne
z+->R^VVZ5>b#v3v(v){2>)pe`G=e>9LIPVZ6-vBOka(3q`{h6g_hgH9<sxuuba;Kw
znstC8MrY03S;Ts6Q_8bpO-YR)Z$ZL4gy^Z(%Ks&K@ZEn&`tQVkST&cFV9%!zS7pn0
zyp=uK^*%($J~kzFD-8M{cDHw+UC(BuJXyd-H6t}if0opY)ayFaOM&b|Z;K$|X5AQG
zN^-xTqh6v_bbTc(@^cd2`(l1#0k&u0D7H-$`_zo|_U$H=)co`iXkr2H+R%{G*!1S4
zJMm+unv)*n26Jse+L13<_ZFmy?=a8tr7skBZvYL@8!ojeoXS#LkQ(F?yU>CJ*WHxF
zol)y)@l8>YNM?Se@Wr8p5DoUUgUlF2{K?|9p+TeqDK|Nl`vJX8!b4M8l~$wz+t?C1
zY9u?*k__{>vGsGEGpuqe(%kv@W<F5e)}*t9KEzN$bo)_h3tADKLWZ$LZOBI;FtsJA
zWPh4pJ3>jR!JBv+4l87B_7NYqq>IZ#&tW&ow0_u__9PglIWn46Y)^bi2iCehiGhK0
zs6DAo#<KhENg#<~Wjc^L<Y(5T18GgZWYHan4=Ki0b|6v8E5=@SAlt|ZMmv&bq$#`H
zk<@W@*~n`Q&EcueVMQH@mojl1OARIEJ!@{@km#rvWk+q#+Jus7<SP~#O1wxCn-xmx
zk`ZicDDm{%xc)!tFt|gZ=lHP~p(KPHU;&-TUFB&qa}Fb&$Z8f52H;#aD~vP-clL&n
z%HFk;fh6f6Pc{sO;<mvMz#fH>NT@eBoNO%nc#H7)AoscO3-)3)S=pjr7TAD9%$aSt
zf~DVb5T#2|X$WR{=u(g-gEUJ@|60%Xbtd)5QFga8sZ2JqzdMt_61&$G73IBV(Orl)
z>)3@96n_9-eet)?Q0^A5bcyitOn6dOct(yAPO`!Y)RSqwx|Vy-?;rf;z;%T?M<B;Z
zp?{e}{|X<)`w?JXmx}R$lYN}O-r}YSY=2jxcP<TQ<9IQOUF%9}8zy{NRJ1s>fWU0m
zD)g@fw}mmly;#|9(A-s7a5qTHDVExe%yJ9Ev<MGdZ7E_=x%>`vj}&LdUZfPO+yj!{
zo>{t+JIbUl*sAVezN82FfvjPzdV=g^GRhi7ki(_&R*QR#p8544UQFpl=96A*VK1_X
zEM%lNsZIv7n!Vv}Qj!hqP3kD0ma;{?Nkejt9qJ8!ZDzmsCdP`Bm)g>SX>0ujZ#PIy
zQhOTzqGHL@{P>tPfc5M{Dk$$#*tkBVMfoBNH#*~xzG3V|A5xjmST5y92}(y4I#(a!
z@7Xa?Yxdhp_OcJD#4}KWMf4@EA*l({AATo_ZHm+J<~33%2f;($w&<k0rX4-lmwkzk
z^2aK6yf0}^rm)w2;hqJzn0{n=`}0c#j};w<0cF8KWx*uyb{8!Z$Lr&FFU@@KwG=02
zxBjFAnZPRaCqd=h;y?GTXcdd<PpT_>&FrfIa3{|Rfk`}lAStVKGqJ3J#LMIMiq9<)
z*@OP1hTB0?QBl4pR10^UOlxoEI)F6wKCw{h+HcIzGMUy;Hh2K3RL3eB3uAc5+r-=t
zjN9{^+{0Kz--etFfQE0xei}f$J?7dnER#8b{WAb&;5Dq`K$yczun7an7+7*$A4n>A
z1gX6vht~_b15tMnX<d8Q0te?}+q?Y``Ve%oH3`XO3kQLX3)?n`G$6xS_8_7+HT;{8
zp@?Acl8>~Pe~Ds%ECyh)g)DBsVjWq$jKy$S%zq<nBV@5S76;1W5mX*8i`NjXJzbVp
zzZS-kvN#9fIkFg)wrVikUwm4Mkg!LaO9@ciq+pDn8bX@3ngk<J-hb}Feb?;=r`FYC
z>cAau(OOQQar`12=7Zu2IBkjd+GXM@)0)8=4kbns$c7IkEl4<HLrINlH`k!mJ+%6H
zjLqtvxXQGaW4{a~)yh6v#haWjvNEls7V(j!_nsb}6t^CP>%%QxQ(gG{CAz>_)_NGJ
zLTa!f!(ayQzsRxSDu6o7%9&O-mOPBakrY;TI0+-2S^weST4%Nt4pH=f3qwZ?#=K~q
zSb&RO>K6w@Ft5VWn-k1HURXALwsg7zJzKg|P}=U2ZeCFlJH1Wus@4#|9B$viEEENG
zbG#OgO=57Gu&Lp1K5(RJ9$pK$GFvo)_!|y7z}p?*dn|JVsYRmMixEWcIY=P=3NUDq
zoOR3)Nh(&GxY!orV|av0mL7laZ1;E%>mLbs<#NmtN%oUbtaTKrRQwL~4R&ZGso>`i
z(PN5s!ULN$XQk}slNpTy^V{rl6q!MKvo<5iSmi@J+c6Su*LT^)k#LjS%-)P74V8c6
zSoKk)noG?Qyy?Zm!YS5k6zSlSG~6zk#<q?k!7jh3lIraFD45z4Se4PFGnviCk0xEo
zeD*z*%ASXlRFGqwP`9%(V~CH(Y#~#ZTXR{nF<=jdW8kjei>(?1E0pc*${13wTV5<A
ze{p(gc^hpxABssZU78c;6!B((r!jLs+ud{}$V395Q4ey%pwQ%*jX)xr_DdErmiV=I
z!HEKTYj+qmU@LlU(>_BT9IeB9l$@2XLi^<XQ$p>1tprbvJ-mA*L665-4|=}qCpbUu
zxQ@KQ^2U;GZFj0-@enWpro#OC_7EbxxeMaa0Y*=Aq0Bo7F6Udbnd3-;@@yviXB-(4
zU>HoC@=L;?J`2am!p&<j3%wx=F#g0-&vej$(T*8!$P&gApSssUSy;^#R^36BKi>qQ
zYIxFh)P8Pa=f)F1<=qVSbUZBIt}%}Zun-Kj4J1hG2G(f;85P`g1_W=3;7QsIiySzH
zEv`VJB1e+W@{su0a^XdC&)yQdx$tc?%bP%a1IFM?&QrJ>4aC40&hI{AC6;Mz#9K>p
z?PNg{Va{4Uk+`wB@P|KlOeA$H`A73A`8>HEd>NbR6o<nAYVu&$CX#OM=caQn>=T9;
zt2c>MuC;8E;6BP-GII^yU7%e;g=8+5K+j`=lS%o27cgze);=mKvbYX`Z(caIb{Re^
zN#g_T;3U$cR?akTWlu&nFFGXSBCq+xG)zW4wT6qL2Ao2x^BjrAD&!4o5Q&|{VkVQo
zpde0(4Z(xw_kbZWK4=e(@i~gkB+Lo>butMXbZjd3$ex(eF;Gl`Y5B9^1+$%Kmjx5J
zEByfF^StYtexJwRhL24-r^DTM3TayT%4ES;2;xE>YkkbPxL(b&rjWYDkBo<jETJE%
z&1y^~HN4mHVauPX7RMDh#qfJX0XJ;NBBzpSUMr^*6<s>}#;wZxe&I<^#9>Km9mb}T
z)nq-ZJq>1$GpzeGxZihV^QXZ!P*0XVjp$)@ac>%F8Z{Tr1;2J1lmSC+VLBgg=`aRn
z!&ybVIewQjPCST;F&fLK5{vFjlv&q-<4K_(^XtGvemK9$B?92~Lvi=k0j5eeSu~qE
z9Tpjb08*U{U;Nx1ZjOZ)bdezE9TTGGgRh{Mt>SR31jk_hY*BF&Er~CXSTE>W36g|3
z>r=Q{ENl*RV(Az<*PiHMlK(F|zq2F%O5o3LYO@=T4O9SS$TN2<!)|ut5#|F{;!f6n
z=+-F~6-^H5yFogVc_@xgVoxWqx-&=>pD;KM&eQxl+|557+S1<o!&%e}Xqy1GdIlL&
z))T(w0Zofhw_(amxLHnRb!QTPk7GUUJxeskeKwY(a0di*%rFfa3*9oWIw+2HdzlWE
z))RYQuie~TzlrCb49|G&=8<?0HVr@~KF7Klb-MtYHQXlQ+FR_}?yf1UN(}LDaT88`
z%ONftc?_L3?+eI>&5kp*<4iqm63)~>SbM~3tmE0~7*fqQTqEudq~R9(uEtbGVoCWa
z@5efJ^>DK;^)3-hyrNiNXr_<dMfR+Xqrez;64s_e>zQ>6Kxw%<T+Br6CFwD+_n~uz
zbIW4z>x#h@OcKNFg9y-<_gMl|S>eHbu0@hR1JAR)vBanLUci<sj*vw+4t>BDyafIx
z4`T%z;K{hyEHc8k63m~=6L02Ya4(CBjyu6I;8VOe@e%zKTQmz6AbZ)4S;XkEmrvp5
z#2l^-;D^!d$t==QIWn51EP&m@wzJ7lrK2ny;Dwu`5b>QuhPXAp4au-?Jk?|?=8$e~
z_ii}~FS93eNLxSiXTmsMN^<AP2mg4*n^?!WWOB%-n~t^xyaYR0iB8Xpil8FhBLQ<e
zE`h0VbZ4%iu4qoNS96KCdn}(_r4o=|V1{|5Pe}XE$eU=%t82;kg?~=2Ao($v3mwQy
zbMhMO-8|B$%Hk0`nnWwlrdhY+1_lHBv@oCQ*0Ij>NkDZkerrgA5pRnjD(v%WJg2bz
z^N7B-n8Vc|Dn-Ifc*dM~3&=@UlK2Ex9eXgJgqB)8oLA{}l+|89#>4cRynysG<xLcR
z%(#wzKqi`xD=LaVc>^e%VtQcz**=W>lURs8uTpjMp@*YN0#~VzD&V<Uw>1kH2`^Ay
zNOJ$rwDb);{Dmwb+m!y-ScZvID1D$kSIo5jF_`5-8CE$V3(2w4w?k0uf@0;bp~4Jy
zmeNhI{Zbf=u#x3JQPB@&hb-i1=`E71-#|g8v>AexSubN{>5_HM0K_8)3p?jLNe3Ho
zi-2zFAT$fSgk~-h&gh3`dj?{4E!v?MPy3?p*IDoqvR#>%iDpCEB3v3_<#m5FTh<2U
z0ez6pyFXTU_B`6{ZH;)J-iWvAhjw>bp?q#Hlt=YNJC}24_pT-4n<Efk(g*EoO8J?d
zDBs%~?fRWTyYL{id(s2(pL(HPObe8kk@7bY!Vb18GtAHitU1CBSuPZn3K3{^7QV>9
z8?<jXWNY0MYkPVMYx|=q;<LL79CjrSTA;zpN%590XqMO=%>quMS<@zHmfjih-Q95K
zd%<dWZBW#QrK~1Hl-FJPCgT^-#}bms#(?Src~=*Yp|(|%yDG|(3#mT`ftHxGnO|4f
zMnA|#q>yS|6Hh>ee19q9x8i)~aB+I6a5JCGCkvoE0J#9b>JY-^uNKZ@v*GA4_6Abi
zt=1i8S5x3l>&o7z5Z^jW1{4*+jX)1fxj%khh1n_J$7a-qwf}-NG|dkXVIygDFCLGs
z9GID%M4hj&OCa1E;l+a02||kX1h;Zf#p((5!s?elcvQXxGPL=%2bVs;2+laN73XYS
z&AO&`x|krK+b`)Z^yh{=?p=;n*CRk|)?GZtT@*=m`yoBw14KtyOG?_qeq<aatvjCY
z$o1CdyoC>#@c9QWYajOEmz?(nc3bpQhrEBlV;DSA@CO{-NcJx!hNg2w)QR^51-IMh
zXm`Bl|5zKH5958uX8@2i6prFMl4@|B<i0rWFQ=H2_`;zbXw;DLo4Xg9VaLGIG}w{<
zLI)m)t{v!`osgz6JF$k;9D2k-v<I#wb3^d(A0zhV%YAvQe7cNC<2^xiBzQ^rTR2Rz
ze2J4k2(&Zh@Z2o4FM#$8)@Cj7uJ$zom>?H)BoT;gj?7JCC)dEH{*|?`>R!zbt|g6>
zZZIc6u{y9Egm9rwbN9bQH@7rZ9QkH+W7$(+OL@c^Sg;4JBksOWpi3`Fk2Qcx^Xp*%
zUqEA>=I_C*<9n<7*d>itSd+sm9f(Ifs$AiX2TRY)(7!;}DZhf-sn9o~(xf{uQ#@pc
z*O5BjeMFal6|}{xU46UllnAk>#gg|a&Mf{QDPAlySX9MdfR^#sHTZ!?0SyBy2eYoK
zC<TDP8ZOrM*~fW}d_MB;!2_zm<}p&i^r<^^3x~%7v(EpBSc>r_nn-BgYHnxNt&uGQ
zqlv%18Y&{^-E5GY{uV<I!$zF@J@?vOnCJHa+ktl57<iD?brwbLrl}`ah4v0Q6H^Y#
z!LkT$>aZQF*mY}2R^A^zTMNzy02YtnaY?LlDlq*a5+Db^S@-lXuZLIp69+_&ZXPC$
zrSO>44mu-(OQ_3rcyJ4w@vBVhZZSRZ9txBGdQ!FLRF&TYJDz_#TW1Xdwc+*(JKDKp
zq~;=MVC>dzX!@!xGj1UDlqX?q$ObZ!q_R^R;Ei4k%ilm&d0eT(eNdNiHPcpXgf}Ck
zEX&>mukd@Zv71S?dixvMwZua~g>KLsmbC>>`G;Idica_w`))IAt|{!7%`h3?Vr90F
zU_x29Eu^96l3>s_Cocb;e+0MSk*Bg%Ti|WS#J2oQfESzI3f|0|-9jG1%b2ZS!W+fX
z?8uj7xO0A(jEQA0hI0Y|UlETwW4;BKc+x|2U=IkM332o80<Xm31?4O@;VaUr{uc*8
z+v2rb%n7iH)fH6Z5%E@7Bj<^<F5E9&4!iypF?jsJ$BDy(TnYB>D^kM*->ef&=G>Vp
zhZdgt3-ZAuv9>?~JPQT;j&*COGxddzvngGS3|^kb%b{mrqD~5ZYz}>V+!Ma2DI9Q;
zoJU|n`iygp<UIAatYoo=P4bVF%wXScB{iMX8lqc$+0R>vpXp0ktY>3%h9_t4rL)${
z-F-gyay>6gFX8Qe!SO0KFQX*q9cT;TrB!ksY3>j?e-te41tbu1hAn(9Ea=UWQ%R-L
zRVB^5Fq|lozlKJ>lS;~(-tUDNV6=)ms#!Nl6#1aa<yT@*l@x6*RBA!Xm2bcS-i9vX
zD%0956nshIBkAEjn^848(Rx_}3`G7^aEz;nVOz9^I2oV{{!&Oc)2^QfVvw?s2XHRs
zdMYVtf|<E5sI-wp@OZ&38rm(kqXo#i2y*Uf48IMul0|5P2+;<*x?I9<vM^PX&u7Uy
z-*Cq;6F7!fw&pqZDtD42NeU1iMx9|a^}P=Z-3D(YVdb}t7+@3m=WXyN{HwHx?eJcl
z^kC6DNCz^J9oa$Z!@56r2dN0>2L9av8%I}J^_}p(2u{50B-NC^I<Uz*$pF8uZTKC?
zZOL2S#mu2%!)}}yx_I4{J>E$gRNS%~owRse5K{;r{^;x|=D&*=%bbOue8FZr#>Va<
ztp_dO0<%*$OC+rEbW^buZdqSSRHPdw1?KnwzNrtH`mw#OHM0@xo|F@wbRSj+r9_po
zzFX|WF5)xD`7`<t@QW8bhj#jBQlQd@+v$gE=)bPbU6=H|*wo!5phZE5&6yIY4bQ;C
zgq}KiUJc^SglU@ImS5{Svpc)V0OeH^X50e{gz+qF54jEVW97Z15{YFk_rg(t4s5|*
z(ifU4doS@O=h?Hp<bIVQ4fxCM$MCZIG3>qtg=V>}o>T<WAn!0%Xvc5Ba5JmEj|^0{
z1tPf*Tf2`uC110+Z%HM^s{w1Zmjo-nw_?A13(NLDjHoq?_1;fjRr$H@fB4}MTJrZ`
zQ3v1zKrk~MfY+HRZ2tjb7`v>Yhz|C)yjpMJ2}<_;Rdf+98N69Y>Zp?CUkXVJRk9Ox
zf>p^-)CpH5BUyukWB_@<5)YC#<;%Ns4nD$%RpnQi*1_!dLDHz1-Uz<HOd)T|@Lns?
zTJ#CVK5W1H0|YlEUbJ}Wgq^rIy$ND%4iWF-$LhiM>&p%B#(2gd;$L=G6~T;&?ZEaO
zB17C~H$#q>@Bx$;nf^NxP-z($E-oOj7N`OqIXl{|WTU<#)l3E<OPtQ_EV^1)nuDdL
zSc=C|Pb@9Rk_k)6SXzvw^;kNBrL9;>tIWMk+>NDkSUQNMoBgnO6pJU(Fda+3W9cH6
z9%CsBOE0l>4@>W`l!K+BDs0eUm?Z+)!o$Shxuz?&!wGiyFuY=e&UzSn2yF9wPwF*l
z)db=;CywWqkhbTw`LPK|mQBPP5>q6{);t#bJ?x0-+4}EECGQ7KxgA%^5rIgh>g?+G
zqzSA@$PrR!;B6Qe;qn;VglgO%6pq1t+Jqa;utMd>;QWP`_G56lfO3Z>1aMp34PMk7
zI9SCJj*xbw3d=Y`Hj<fa=ntf-SM5p;U87bbFgEM1v*aI$SMj=m(22GN!x{zNO#eXU
zD~an_mE)wFXT6Hth6i!A45sRQHMa0L@m7Y^;1Am~iv!6`=6{p~mEN!pAK+pFSky6i
zV;bmVv%OgwZ7=wt?a=DNRtL7l*NBSBhZ=0kPn}Wu7K=Mh49di6_Ii%9%Ew7}&q3Zc
z)ekV)@=W|z6?y0Qv6NYg7yI@&`MQdmkw?hiGzORAN<}!}#cunXhHT1@a3lGW9r_X0
zhvQh`kHp_~M+HvDCqQeF9}7GIwf|Lvbvr?txO7vYZEWQUQrWZvS}t!tOkbi7Fxg&*
z*9SWXa7VN7Q%HO>{=Jv*^|YAhdi#Nf?bS#uKY$9#nN~hG=8wboC9tyRuTJo_cyD0L
zcLSE=#W2ngdll_jos%#d{^QRko`hp7E2`kmMx;L}ImMgbrulg$n8|{@c@5w2Nd(Jv
zczKgr4&Y_8S{4i0`D!_s<CAP<xc*A`z~6ynTKo7rJi)Oor(p5Z_!Ml1EN5Y-NM+?&
zbvE`C+zLF|kEh5?x76|?3VB<tFP;_4<a-OpfJ|Y-PLpuAHjY}A{Bd37&Pd6sCq>P=
zTB~I@<Ev#J;y~_-Q%%$?kxqPE8&;L^0&s>kNGD<X%f3AKiKTKlf*$~OWae}-$oG8}
z*b+@F4%p(8{I8R#o>YQ8lT2$@Ry>0=b~)m~{TGw(3DzM4&gxhzv+)^lCU_e=kwI#?
zJQef1P{?2}K!N<k%AJ9ax~$n5Qmg%16%VT^+zH_BSab{U#(=%VAE6cqML9xnAm<Dm
z%=(pOpMkXzJoCUu#ld{qFs~JnCADt>jt6s7@H?1QJxdx_?N%9z&?S1?0=Iara<hl>
zD~mo$s<=#3B~93-v!w3$F5a5=7sr<K!~^g2io8bMpcS$liDf@5^U1<lu*n%Om$!yR
zSJqMX6UZ>!ZOs21X#(HA<UYe<LoPV3vFLNKjLWag)&fk9u*>I2=gQT}I&`7^wP1K8
zB!dOalbKc{3ph`@1@?w$#be4TSco~D=11VI!$A}7>Tj3AmWnbqGc-$aGKYTemX;1?
zU$bw|6MZX-yc7K9!`~C$g7E4jL3sUki>3N#alJ3eJu@_&(*nE!$oPt^Upn(B2HOKk
z<wa6vNOAY9<M6Ts`pY$_!vfJJrqAW~*~(ZC4uT!vE4~ArFB(zTL|DTcTCvGd0lH;o
z=sCe-)_L11JQr^14ig6_9?fSIv)8xFNKJ?gyjrk~dxe`y)8Sfpzgh@EeJ4A10rt}x
zvyT^G!R*SaWr`O#p_ychONaN|ThV#p#7ia|9$3b_FOt)4nLMzh#PNKy%%WS&{<ui0
z*00O`g+5g?+>#hC5U-(plDD{y5Ock{iZro+OQd4iu0kw(M1MBu5~)(-E^l*K_V8P3
zFeec=n#PWrYuKhsq(zPS|5NjCyi;H<Td=p6NB{|AbuN>hL3b+vojEZaSVfo3^c3ZR
zqLxhSdUyE<uDx->&hljv>f#}oMKT&Pas^I68JX`D(x&}BamNw2h@CFt1aRWl*dN})
zOH*6s^Wj=#{x>0n%o{*CDe*bH!ekj9@J<Gr>Ilb5nb&e5WKo=nwlodHTN=i6gZ%<^
zd-U-V&hr<bBA5=$<tnMF{O-mYTqVt2UY4{E<`HcARZ_>}lwE>6CD@*;q)NGEm;|eh
zXLdQ}3UWm+i0ZMr&0+1b`YLfQ*GEGzq$1mUl~k_(P;~M{JHu6v|0j<#%ZeM45#sEU
zz!L+_><WcMSrFe95ciNxqNVVDa)9OhM7(@om2ep4S7D6gofkPqrHbWP?oY(i^w3dj
zJ=fyDVg$2+pnVHDgZ}9!%3^<p&r9bVZAODlex%J{DU|+ekm_hq9bC<ake~*0aIF^D
zU8$pnB7)J)H}R06*%!I9>u|`nOj6wQ@TAxrNC1qjYcO{&W2LUc2Fx8WHWydKfrQJP
zh-9@b;%al_iBqPNoN6A%ITU6uv=#DT4+i4Zjj>Cha8T$%A~@1mu<$}&9n?*6r1Cd8
zT9#CmKce}+pv<2-A&|jvGk}SPf+R`Fdx-cisyTdDL+8+F`Or`Den71>8w=lt{*D(o
zUnx*n%YSDLT4lJS=^>m)kE`5f-7gDlF#|;;B-fsrNx+AN{I0-M-H~Y=G96{Bvxv9J
z%@Jw|kl0qtyCR(Io?{Mu4$oI*g%Y1xm&1$$=S3FBeJpZItow;auUi6cK(q1<nfq{w
z?f*w{hq!+$Cln8ZSG>#f?x$-z9~8{2RyOer>nlc}?j*<gw!ue!!FPo!3TilNQfeY7
zH|+?;&PlIAk}kqAawqr(5X_8bU4Kz&rWMYFWs{z8)*?HbG-^3SIG|3rVnD%sA|G2?
zi!7|Qieh_Tm=wi>5rkNcwYdT3yWf>#<8F{{#fLb<<ka;Jsl|S|L24_{yjh8x#LuTT
zh{q-+{#NvoPpB8ghiJm7EClc&3&cR1D|f(migZe~U|-(UL!ha}E|!!|_XQV#<`}5*
zG4eCV!Cw%;ecN3<VDJSyc@rMnJF=hQ!!Q=68d&BC2a?*?K@Ko)%RFwuLj7?`Tmc8)
zA}(;wr28%SLdjXS`4*hC+zB4C5&ac?aWlWFSWYpxPK7Jm$cL9gx5x|F*L{8))@qNK
z`yKes!WGu>4(VIB(;RHcSl*IBP{7W1iu(?d>$64UTVIxE8F#>VBYSd(G#I(S31;fV
zEQqL8;w|_a+Yxk^fi;XKv*jE}Y>`-+rWXN|ZFi<aY3`Ot4^Q3qyqof>^72G|c3?h>
zxl00E!as0Zaho!+gLjFi^O;%b&?5HJT~f<r21oKM+ZfFeaJE<^S{h9T*akv%fAZdI
zQ-I7CgCZP45bo;2CG+?)!Um<Ef34|TFmQN50-f3Yv^O|zJ<sOdgZ;V<Z09|A%7*Rq
zdvF+N5-WZm*3Pxr!26_mo3-%cwbHB6M7-_fN5=|bOvb6mVD1r0C#cen#c=5#*<UH?
zX7OsJBBcm>^?<Z=eGL<uB+pjt$~rdq0r41oOa+%iK44Q662_-^n3}x4R>4UE6erra
zTT4_VO0l~Yqe{D~HI*!D@oKLkZmi$|Y2{j^w%$GBaOl7P&#;_4p@Pd`?*}((nt@~R
zJj)&1s^a79I8PaW7Z#_2gCUtxI!%>!6jJe)8=i+n2MSabp<7kA<*Oo!@A2;Vh;Ksa
z_#q%(3S?y;k_yfCz6T+H=gq4|s=K0F;eEJbS$q9C>I(A+8~l)Taap2Dda{ELiRZ-e
zs>Jxo7B&xSIfNCeg4M7JE^V$#U4*n>ywFEq-f^GN+*4Kjz33Bb_zRg8RQQ+&qfVah
z`2fW45iOU|gaHG8$oTB2TqE|&FQkb{|IXgAe*0*1m$#DaJ|7D0_!&FS!{I&Xo(dj;
zSf%u`D*Z}G#gTJZ(}-4DsVeR&bQ)@FrCF-jtlCGS6q*I5l0v8fKKFqeVm9W@BPd&{
zwmntb8lPAse8*_rBU07mtcq`a_#aXJ`PLrg_jcSC<z*Gz^{+k36RI>tNI#2mp{lsy
zt&`Cf<#-S;j(hI3&>3#^X}`g%27Zn@3NAzkgnJ~s2=DMOI$oc6nfj|OQCqF>HS}0@
zJjs?SqvAL0xGe_jKlT96^Za4^Jy4|wg!Ho*Hh=sy-lmzRYA#jnH>uL;C>1UB7;d<{
zrB3jHl?00odrNguZAYlKO+J2NuTI1JMn3;}fZ<3^AgnU2{hj%ASFxq&aK%-l`_N91
zv;qhA3qm9mbN{x-3nyE0VH>{_o0Ch7p~(R7`w4f6ucu2+$F0cI{{WpuS2)e_;B2OD
zJS=bc8rI>|VWzGRd!7p?dmFOA-$;8Uza)$O4Za+Gk+I)M$8x_HSACyd5^i3EWf#E)
zSE~gq^#f_<@!<`&dgVg6fEq`zh~J4%*<X3db`zb==KN0XE3f9E$)VTMWItShNmI7*
zG4b(U!%H@k1~^OHyATY=s^7x<+Wg1xj=8}+7GDUJ{`pEWJcA2hNMXaDz_%c>c*({v
z0Y(vvdIMXom!FZ+X@{PWbwv3v8(sMEr6f2C7eHWQ$xq=spkMNmjiC8Qmh+tWvincr
z*knyK40`fH8vX_sV0a0ic&&dG78P|*vUW?#wI9T}$Te(aQEZi!Oi{vSiTZ;|+GvU+
zO&Lj3;lDJ`{&b*O%qHiNt4iru%){m9(wj`U0B?R}3C|!8-|~{J=1%Wq9?~EW+lg{(
z2D-53nY2xT3$VS2%W><rzy1@+Y_4JBb7zm9!`EH@jmAu#goThej&vL@fX0KZ`jhyS
z-^xoilOX7f)?4hyKj8<OPEHqg<>IW;ZXR5K-K%2k`U_$xAIXb0!*_py;Trbg1sKLn
z!wTCxm4+?h0t~ZR*#fB0mzQjI$KHTlU)HJs?ApK=lX*w|_ldN74;Nr}i1l~{b~(Ic
zvzz-G>^#~0SL7U=v<!X?!@=bp>rr0uW!qoFw>aV^W8T}qO-cmalHaX(&}H91r}q{2
zF1e+0EUnoa@_>+4%;Rs8r-V-sZnP|wD@}E90j3|tDkRgYhf|uG4wRqc;M$Tu+5Wf0
z+xa01;hSTYf5-u)#CSm)bm5VtJqs5=`#>x$GOf4s{zJQmYuF-g&%S+249*)-X3b*P
z-;x9595WS?=0Qu~y_pCzfxker=#Gl}b*7bC|3f;CYuHGg*vmrrs%swec~AV=jdvsr
zUPZ$7T;)RntN5POXX)?BBiN+f`T=Sg^|P!c5-y;YG%@kRchH{vr<P7!!&VDC7kq?6
zAUf9eBe0x*AX(191+WB3mRpbi!?K%e*jPf?{*UBOc-GkbFYE#Yu^;{=^=tksrrV6;
zx4i_{k#pRDPp^~i3sdX!M=+?;Kf<}J+Mgi0TWs1V@L|n8=|c)!fOfc`$+T|!?LR)u
z<{CC1U`Ty}b1Ww2TSTV8^G<RRyiXl40y~WUt|aw@3n0zMnble=_dlfX?>Las-}&@a
zgH=`(_mWwB(O>wCEqF!huRW_&Ci~asDm#@QhvC?me_Pfu2QHwFX)KE<K5oN#$>!wS
zTsxnaGBi(6u@Q>m4O>)m6lG(}z8wdYh8O#ZEntWDf-V$F<U(kXQ+_|UANs+qP3O`L
zo`go-fE~$$kN6GM1-@D%fIh5SF`(JY#uQU(n2vM>HH(+!53Z9Ofx9GIQJ9h=goP+H
zqc9i}0h$9*I17ct_$eTGgN(u`6jp)00Kx)r5d7(e!lx*lj+)IUpfnV^IH>0ELnvll
zH53NCM<Lp~qHx9wA-spe!Y;!53NVR+`8_oM9fj#)uQNFqYl8js;)<ug0a-foJ;$VE
zcQh!D!Ydz9h}18;utUX_@}>vK_UM@akD|qS6s~~b4m7@KaS(-n^8?^X$wyJR35B-{
zgm68YFGZp98ilBt8!lq0`c4RQP<WMf(7_qQ3oK5j%y(XxEqaLcOGZj4l|6ia<|`yv
zi^#<e{JKL4WkEFtZ3BBRe3^0&-u;P@bQ-#(y>C@xKb278+7}KGdTpd0>`?M`WiV)p
zb>&#tpnxv(l7G$699;@u#ny4;8O2tXRD6|n1K9LWq*+k^>#|$-feT=oi1$V7nEU@3
zIze2+*41yY%B7Uwh}$}6MX%KE#QcijjadU{C75Khsm@9>(uM7CR-RPooBgRsd=>3p
zxH;a}9aGVcZ7r=dP+nbQ*Gnr+$;32W8KpZRlUW}Zr3HM~bft^pQ|jK0Pet%8>$fa<
zumV4o!Y;We6+OFv5VFUYfbjkVUPW4T_gJBeQkTTBYOc!n@U7yzu8{j*nMYYAux6#Z
zLLDAI`Qi`GMuIo+&eH0{Pb1<Rn0G(3ab=Y%#qR(7iDmU524A!8N{a#Tt~#_Z-(T37
zBVe=3{+w8rWt3Ig64N?2r4|3p3pd5P+%ry#Z7Np7?{BlQZc4!Ti?>0}A2XBMd&^(z
z$qe>}d4>;|ADcrh(0-NBIo&tBY}RcTAKWIQRQ_BLP$7WV!O%VU8Op`BvLFW6V0-qH
zn^McO<pU914t{|xhsRr+wQyH9G_DLtQhK<>^Sr3rqTAez*9CjHj#0wio;}Jdthk5L
zR@r=!5jQyQH_$_ASbyL};D@8miOYcn_egeJmw}6K?DKtV5&wR6$U~`Dq5OTQ7Jp_!
zt$G!E<)Ku9FDRESr_?gkyT>yGjguJ+eS_x(UoXRESUIJcQszDjc@00A@aRuCmAI#z
zQWXYO_wq`0W}2($*uf6)I_Oh5#aUT)5B0VxN@->+50iI$t``f(bIz7mYLZzjue>s$
zuFD-;ZSeu3I#HqM83~sq1X+7>J8izF0!!gPud(tKl!j$DWr%)zlzV91n%1*|lI;vT
znSQ>?D!3IL<R20IqZSK(4>#M1e#$5%;}SdMtJLI@5^3-Kl=1|=s$90Z(#GrebG)k0
zccBiXMOIh#5%?V$*P2RmrOO4DTT`jeqH97ZPHc5eCEPjfJU8>U!uy7rN<$LQKMZMg
zYAI)nk;UwJUC_MEO4n2P&m}dh2V=l3ZF)VWC*fZusju`PS<KB}@q(Y9s_CzEB#CJg
z{gv%Xxq$D06}zs;gZnoubtU}BPnRHgFAo1phD-IokA5o3hZ7V0>&#->f>Q#SR?|MP
zldt@5rcE{~-xMRu(!3ih1_F)JsEP8vc(sGD0LWNF%9}88e>+xX@ml{iB-P@&i+|wx
zg}&Q>6GjAV_~{B^x03&uz{!eSOXq9hMZUaXLO;_wU^h<(IArm<jZ8OHrqT{f`%jsW
z>NHZ_S!tvCR#LgDRL79&tV)&swd&Mp>C_oyT4`tcMlzk<Wp`>CGF^rblZ<bc1C@`Y
zI*U~8?No;()m)Y89#Y*Ah<J_X@4%FG62m)(Ooe7!cn2ht(WFxSh*T$4s^3!8_?Akl
z^GLPdPPJB2J=tlGZ#y#0RGHQzllU!&){^N0XEMRhQQ4{HOR7yO)e5Alt5WrFaO(95
zj4u<N^06}wkW9T)rYK~3l*&y+riufTiBFxpQ|*>i7m+G!g)LP^NmWv%YK2s5RjT7#
z)l3bSOqY;psh!DLGM(IE&y=SLsk*9E(~(Lz<teEyBUNiV)$c+-(>hb7D&QiEtN6h9
zYB@M{`A5vu6=ZsyB*Qc5E=j7oD%BmNdMFT)s)t{R_=HpOlIki_?Y2?r(j?QP?e_St
zB2(+FygI@3g#%NwADv8MB>#j|!|haCB-L7#YA;fGd}XH!M=CKVJU@={T|*{MJJWp0
z)Kz6#hD^ITlL@{0^rhN<UrVa%NOc)*X*j(Ml2k;c8iQ2BRj0m3CXuOuk|_(B;_Xb$
zB~#iqlRZ_TNYzO|B2^O|oGL4+ZX#7PJ5^;#HHA-WIOo+zrg|!quLILLSO)Uh^Oj&T
z>7FmM#aAR+DbreArOM?Zi>sni-PxjMYM!LJjZS@SXSy$$?(?|_oqB>y;sbNOk~5j)
zoE{*l?jY4bJJo4PwOXaRf>culA~Mz9!Kpvsj>6-+i%ezhOj{&VsLJ%sRzCk*Tx+OQ
zg`3s*HcP5|NOf+hEmQL))dxNoVSLNE$l`ib?FsuGn0ia5`^YrU&SV-OsSc@BQAjma
zr5f!(RZ3DlK&k*cRe)p~r!uufrWz`fj|0=GG;#mQIQ}bA{gG&k&skDcR;da&hsD)J
zAR_5mn?$BWPmcjAp7ck^wAs#-BdX4{-sE!;X6hL-J^GTHm;}{Qq!J^!o}|h_s@`_0
z3`v!wQvHNf;{}yqYVE+3^8-4Si%g~LOkYW+c3VH0Y+ikfR8>@}*BjNIuuf9_hE%7P
zaAv;bh?7)*^SKD)TY*g9ZQ(k?sof4t-6YfR$YhGKQw@?-->6ihkZQb2HQa$pkyMY7
zs-B&xkz|TenOY-L3xNoyJOz^pmsCfOV5*)XRnB5te5ECoUZr}?Q)F>1rBYqqp!S5R
zlF5op>+DPqL}uY@_IxhFOyzvZ=YNaqDK+WwNF{ng4M~-URNd@U`y|z3m1-S2HCSb8
z=HS$W?=ie*$fVer=9wf_kV+MgRPHL(^Yv;^NS0LjNOg3PEmPej(@Q=VVSK%iDd!8W
zBa;3#GKn$Mi8GmC&^$+~sdlQ$l4^%aRT8Nx2}Dp0bfEfp7~}gBnQGXXUWlFpXBJeZ
zlU!tRMdTW+KQpam9jLyOR4<U~K>}yyJw07gd8kwiI0$zKwR@gpYNp0ZrkBW+Y-dWA
zOqnnjnPjROA=Q_gd37Sbc}OKvRYg)2AXO(j)o@7_$EP(+`e-h)xb{_<0vw#W^&PJu
z<M=CN`e=&hWgcIEq-v~E`5;vdmFkamB0k~N3Q6@EslKx_eG>Ya);vBJp;H4mXmR~l
zW!j8PCehP_CDj|G8gHk{mQ-J<RQI^Z;(A!6>Wx%_>7PRw-`~ho#m=-#GWAoL4uQx7
zR1;LHQV#L$lT`m8)h&}PQwt?k8I@`o7g=1Zs!XTWs+k%oncgDP3OiH3&EhiCn!zU{
zOw|aay1j{4CwfAR1C_U=DnzPaJ5@vJ)NGY02${?(Q$1u7nYwn6S76FG{tl`BS!j!|
zl%#5)Qk6rh5S1!tjfhWBEfG{1$KNB<K08y6(9g8~&gUWwFOQ2Xu2#upg5kFgsYIu0
zDXBgn)kr(l2}!j<r5b`%-)^*Ls+)sT1qZk|<M>Bp^0qV8lT1B1lL@_wL#o9B5=mDa
zsCG)KBBZ(&XUo(uNu^VrnuAOR)v2RY&D2oIRIC!uf^JEiz5V(~svr4Wgieh_s_Pr<
z@lAE0DkrImBUMYgQ;j84w93>LnK}qWgjYi{nfSBc#r>G75=d3Bz!slgQq@+euJOPu
zuB}w39(<w3w@@;bM5di~rmsXkGOfSxxd_91$VDcL>jO1a$qrOaBvomo8fvFHD5<DQ
zb)1VVu0N_wogA2+eaqv?IPQW><?Ku;8^!ZirnR$5wFRk$t>-o(RUcE-__j(aH>A2a
zpKI~ibGCG<h)*CGpBb5+s&~Kd9GLnelj*oSQZ2MoO_5YbRH`LNMFk?98t*{mBAxO;
zrY3f#Ns?)j%Crob;%!W(OluVfsx$jARppTC**sf(eI=EjN;L$jM%bt_t+$fZOwEx@
z<&kNtovFEGy36MxbEw#*>V#DL*V>c5!hx!xr1C_n{&uPglFGvNg)5az!45W$zrjGf
z(8k4XQy@An{KO<y&-cg*xya%wKCsFES*-@LQ8HCPrZaPGDY-0}-tn0NnjCH=UN?{`
zYmGgSeMluHw+Kn4N2)n?s%?_$fTRMZZ;>fjAfm}fIxv-xOy0=UkTaP?M_eeW#;8=w
zk;+G<@^+v)v6uUraom7ZkLTFp8zh-3s!XGhX`IS*ZIwM!Cfy84<%3ik?NlL>Dx1$b
zI68VGRUegViAtrbBbh29Q-qz#D4CY2Ol^><tx2V7=|J`C9*nOlQkAe%RhCq3RH_C@
z)mUXJu-N0%t&vQA$aG@1EmP%%J`ANdeAdDE{E;eeJy#O#w-c#EPv|14sw345JC(Db
z%CzoLnQ9?ZLxBjUp$<+tNv0Z=_^rgEt7E5flT;&As(MKESaqtL1Jw_^F;g|ssb6Q=
z;?qecFO|s;nKr6S7fmZgsziK~B~>k?T4SgBAPh3CSNNoZnKB@ix2QzKw-A}c+M=3d
zs*6lr>`c!kQ-Y0&&FQPSn63!1I0zR49arvd-r0qr)kBs~v9{1oN|vTJ7K@i)u(;k8
zi15d1Ry)B;$>fhr-`klE3;p7m*8F7ls<)yyomM^B1zk*f(puU#K>N{l`%Ti5O?(!^
z%mi|g#kGw<geN^5Jb4Xgv-!X^B9o7u$sqK>lU~x3nnECQ;;MS`wX_dF`^z!5oDiX&
zX(g&BZd_z>Eh`Y=$@eSNoD7sqjgTqc&h(UVP8b+ze8Rz?-f)@4Rea#UnCL)NR#G)V
zs%Cbop9EE=b&AS#ADLbVL^$Q^z;td0uRG&-vr40Qg}Uc6d70m<f0k6$RVojRuc8{?
zog_8Bd6Fs!o%-6&WXsh3RV=zMyj%AX_9D?6phL+fZz#=MqIrM2`QOqJ3!knqJ0;N(
zch!+#2S*-n$Cz3nlZ&0{gJ6Ot?;t(#Ry`@Eda_>Hw?_N)8Mc(Xm7cui(*b(&f^Qtc
zBOCv~cG|mKO-T>Q)CQSm*_r+n`ryg87Lk*n7wb5I$jKDwP%<Zqv~P>{_3ZYSggX4F
zzD10pps~U;VP07^|85&6%{bl;%^yVbB5&Ie8Hk64h4g_z*hw}237T8hK2n+oqxlNE
zd0lCq!Dk@MLt8GgxP}Wv^s<;`Y972LQ+s3zwlf)pKICEcO6(g)*V^;YT=nECfByl2
zbU^#RrrQFcLLGjfRrRDadg7^i^6OI7lSPuLBQou^GZC97xn}N(r%81r6*`_wNi%64
zisr-Z=4+)RYx&fJDaqw+1VdOfl}JgrgCoyVF{ChL^0YJMW78J1b`_444_YafNuq7b
zsGe+<_TgxMahfe9<AgeVmwSci8ZC;ef&2*lRt6Fw%{!y{9J~1=X?}nO_ffn}kJZX2
zsn$-?x(iy@v0G<K>k)j4!8C+m8ak_KD3_?V#}8XE4c(CG*QvHJY6^Ym8D1-}XVfxt
zNTlI5w6=_6qO|Xh_FvfToiUBpOMGHLPrl)qu(-Obo-A0Rdg3dYdLUD{o#~}WU@>@O
z&8G8?ku2V?2}jzgj@<eR1L=w8AE(#?nJIflW7QEabmXu=M9=tRvFeD}8HUatflS}o
znNoy4q$F>-NJ;4XBzsEsK);hIX)8VHh4y3Z_P@x+*}`Wio)Xwqc(t01=%?u6AoA>f
zN=J{w{05IN>BTvWne1vmWv{E%w)g{!hiq|wrG<BOXhis?*oDv!PJFY%DL(GQh*+cb
z1gkedsmfmWhl2v}ZNCAE9~r|%6Fs{?uJJ4ff9b!TSI*LQ4}en=aP*<wAZ3#BIE4id
zQUcj8gWwQQ2CFhySy`b;g3XGg+wDv&eXvrI9A*y(D^c*<4Q+=gi@HpOF1NT)5kD{>
zLbHG%zlAN(o&qK+{3|f$^PgxtwTfp^9w-f;4@V9>8o_BH-=T^#oT#ifRH>}IUBWsK
zRs8DKz=cH&|2Cxf_H_qP7x@y$SL{cEt};4Q2`uaC$XuD-7z(E@PBAh}@%BlKb*S_r
zpBH3<__M~tlorbG@odU4CDNCGmx~LF#Ba&DT7-@DB=jWw{`BuF*q_6c)+CYD8?H>Q
z&;lAZnG-qwyzwZuZ@6OiW-uLd?6d!b=FEamEGh-gT|L?WXFev6P+a=-=XwrbXR_#y
z@RflrKLhxPvFLh;!6<Xq0b~wm-2vX`Xi|e+8KKm5|0sryH2HI}IKA)5e>ATY^NmzO
ziyfOU5A?@HD&^ou_>v=)aqv6;g^@}<&(>n>B;MnP<jld5yzjt|3q&a)KFy(Sx3okn
zAn?WZ#a5DZ;WYF{C+jMf5(S;lpB;`;SlI*OO{lDV02??`sWRv*A>+gEsIaKRTLFF#
zjaLF+2NP!n#VCKo=PR3p-#%MKI%FgeT8Mv}jGKX9)gZFuEyS~J{kfkUzZPcE)pYdX
z&v<RlTpi(S%x@ITzJ)KwmWE@VFYv>PAHVSr-je3v;<jl0p&u^ST>!-G2i<A-z;Ak#
z4>#)$K?%OY`W<}aW%A5SkK?*uqAr7v<)KCKaYYr~5@Dmj$=Zv<LNdfTcESZ+3}_Jc
zXq4h*GA=9&ib1AQ)+(q3r|W<!6f{8IDz>M!grmFx%A3YEzo4tkS*%YN@T$GwI=?!v
zGPe8$osJ_&^zlysAOcQW0N3FC6Y=5o2Yg&&{YEQITx%}ktr5DFC)=5=8?DrU?@InS
zS{drKY}P0F(?{JQ_t>a?nEx216PcVgbBy9j;OiF&W0kgbji3qS>z_b7;x~PVf#c!k
zEpv)^55xbX0r&?n>sV!cjR<jbmfa);VnA*^T-iL?#A3!N^@wlUSL2j#NwG6C#K0<F
z^0Y6{=^Zv<g7O#4RKq92nLjVKaiY>yxwMdtn5a}>|4vlCga1kD;3TEKa&`tkE?0{c
zo2*=e1Bo{#E3@FhT4(r9L+M(-^e>$Rjjl7WjZ>7qO_Jw*Dl+SiKkQ!`=EWr4A-I5F
z6tflg!i6<X1jP^dnK|leVb!K8ZA*6I1+Q>6ZmLqXq^~GcW0tAP(o!EL^DHD@WD!%8
zmet$-3*YC|4f$Et+e2JD&W{4VW^irxYVkAcHB)KQ<i;HC%Et%Nl{au<*8OcOK8FkI
zX+BXxs?A<Man$uX%bBLsFS&^qytc4%)0L%g#%{xO2=vZ<S>Yx2Y`Rjt`UWVQy*9z$
z#m`964f($XwBg@Z)Wr!5erzFHsZc6X6h_`hr#?a(n{~Cg8P88;4(h7fiWT7ELgKG5
z$iXLF;XPi(`+Mw%Xypr@@EJVeAhacXhEm(~<Stiw3V-cRRC8MbKWxDnE(-9nBUsyQ
z$s1^V0KXC7w+^7&DgGlIkKv0b{5a%wR9hm{mi|Yr6ih9N=`47r;#_i=(1Gv&%v74T
zeiy?-tPUa(q7TP(m2AcGa3MpqKALSy|DSh2$@S$OmN8S=UTV)chX(KYod0fw&KWdB
z+#hfAi^mYaA8=*%vhuRb|MJ8~{Pz@ew?HN;zXBI|?=X-wp?-`th*k8=HCA!fueYhK
zh6^B!7aEJW#+cGIY+yyUIaaCd|KkiE){|S3`5|1Gb-&t*x8VX9PI0MMI(r$b7(92{
zz%6i*nV18v6=VL>mC0l&OPZxrt?}t5$aNp#FL>ybse2Ds&~R||TwWy)qZxmDvD{g3
zv^0Tznx#xA-4h^@i1sXcwo<kDi%3`-JesUbARg?~Y^8z8d_%gp2rj^<N$_FzngV}q
zX_8;7wZc~Ab$EC?#jEEN*M`xbit_$0CVEFxVb$Ehs&(nu24-Ddkcia!!bPUe2mW%G
z;f%ioD(i~D75|@Rimdk`XE?r|W`h&1dD$#?no_BOuM<BM?rGMY0kL2^1{Zntxy@?3
z%@$$v6?31f)UGp)7rdh3uPut!4Pa^ywrlqg+7WETT%}2+D-$4+Oa&&nSJ5^Xin6#1
zaE=>X@MBqU(zawa7kS-e59ca%e7_cj?eN!LL$w$KBrr(;W>#aKQm5o#Q5eel%u@o&
zm9di>xY)H~7Vp5mrX|y0k^;-T>zqFy{@N+$$NIxB7Jx*Aodp;CrU@<4ZYZ>bi)@Kf
zBf<aCIEc3klAVquahzn0jl`^y{4)ed++a6RwCC9<V5y2MBLqv7BTF65($mJ$No6?-
zPfn-GNRow|<N+_3bv}Zmk|Rl7PEy)NLIjCP1Qg3z%1V|X&H_&goaOd4o|U`s*PfLj
zv31S5^B@sfIRO_kD@GoWt0eggy1MvbUMd*YIx-C742zMWVv=s2N|8SpDBLB*cdYvY
zr51r3;{v5+mE<vEqFF9~iN<dP6z$)shNp}LuvTl&UMzsa{F_*fI3-pI9nSm~!O8Ih
zaf%y!LGW}O+*e1kDGL>Ek9W}L;5M~Yl64t|ntK;2Z5o6O<SioBZ4V(6e0n_#9xXn(
z9<-fef*tIx4rNgZN+lLxQc5XrC$W|$@V5$!GAUll_@OL1UI}F<O-eb}egpomu=9Y6
z;`-wK?yQTFC`CnCKm-L96%{)Qc5Ja>iyE-SUSsSESy50CP_b}qsHmveNn(t~MxwE|
zn8Xqr`J=(a#FC~)nfE($&jR}1=kxd^e&?Qc%iMdX?c6Dh`PX2&W!LIzS3h9ix)e4?
z3vlxt^+tK{ea|`CW4viJI8N(qZb&=haAYqvps+fn=&v}<y~NBB{CZQIR>6FX{O00U
z*UM?~T+QD<#p6Kl!u)y<<T~&=429Ljho<Ig0q@lAU!a>4xK^}ej#k~dHr|`buLdDL
z>qxWaX)Z2RMsXN9A5N#Vd0O={jrwp=)wSOXIy(<9-QjD3rRbA++B+_nM;3DkQVu!2
ziyRWzp$bl8exHZSug2sYula;N9Kh#`|Ka*ipL!arpgO)PW4<_ozhsJ+Nv!`|7=f3T
z9P2#t+sk>7@Fzqo(3E)14L=l5h}U|z2|vy6o|qiVGh(S}2=HYO^yD$d7WZk>8J1xy
z!B_?n_p|Vp5wtw5mM8B7&1OF<$!FZ@F#QF?WW-ta!G9~&>WO74jbNXm)Bj9#`G>xk
z$Y31$wsDQOj7wqPy-|YqCCf{gPV9)#QPO^WVVKBkr!;1X@tLQ0Ob@YUHRtmk>heaR
z{vHlNu|lOry_HW7oWgTWM<E{sXf4TuyjzWI>Yg%D{rOtC()XIPr7;j(D005$9n|LS
z+@`&iTW+Kgv?i^buZ3z)dei0kS`92}{$jq?&Mo8vqbSCTk|@Aj>bgLyR_Ci;hE%Oj
z=~1?5p!|$(!5yvmr6^t!U7!UGjTmOsK~ADkL*vbs%eb<`>qZgz`QP`0E5D+XVy$bK
z@-<gTai^b+vKa4i<2Hp+N8Kp9x+?#SYA@8h>@SO7g|3AQFU6`lKS!M3tXMH(jEKs;
z2Z!RDAjU^Ecf!=tx0q?9VQTd{VRTk3B+6?8zcRWcZZCN(Gjc_l!sUWtQ+L#`0iv9Y
zFrwr?MNd;Z>y*Q*%u2(ns5hpNmZ+uMU5i(t4L50uRVyy5qh$KfVg>Y4vZ}@HoRn-y
zaoICW7KryvaoHWnj2-jvC(N4UyGV1jw|2A*hEIye1H;^C^M&Z#n4Bu`kT({V=QZjr
z*n4vPL30`|2a8<#D3@|?xVRyM--ct)i2c$c`@p^hZ8?uO9R|M-2mTn8I1Ddx_!}eP
z|F);ci!gBoQ`sb~f%c*gbx6`$`1J3A`s1@^=yM2#*US3x3rxn#DJ>`?N$Zcb2LDUK
z`QS+MOxD`Fm@pT^z__{eS2VA;;6ZW8ny>j1ZA{jDTFxC(Y$pVwi0BuKzs4DxtV}l-
z+s686Gm8nwJA}jNKLoKaL7H1l_3BQ%i;_HMu@EcWrC3W9&toS~E=krX!^I6-?_dkQ
ztMCn9OUHTnrTA+c+>ukPmj@Rs+hoHJa=sq`Io{KDsI5rjrS7#UT8zD9S8mEF&5Sy8
zkxu0|?1>zWd1h9QDrZWWl7??l*KLI<!RSI*G6B8S5t#!g7)KxLAIG_vMK_reW6^)C
zekx*8pI7_>YtGM<wivH#ouMxlYt`&Lh>WUm`>V1XLp~^8gJQ*tGDa@XwwsWJ(fP`B
zAH+2;D&8or0!}rLDg#9DLvofRQOAmEe2-#@G*D7i>#uLx|5Rk3&qFK8dWJq(qQy6|
z59I9d>K~8znT|v?Bqli$eA981BT*WO!PI1_*2%@wkjbopwG5VOJM4WsAUOK-0}L4B
z(M|tojxR>5P!}lPXi2QyWj0>vYzE8U+9GK&l1`j#h@@sD12`Foq}51P3PG|0k|m7f
z&p1Wq*Fi1TJ5h8f6=!9G=t(N>>4uWiGObp#N?a_gE6VTAVi8UQ2`1xBT4QDiH_jTA
zB*o)=(K%TFja`N-r?hUkt&3+AvcFOi+}IaCn5xIME81CqaED1*X=sy*XRu!#cZ@7k
zJlYp!u<i}TS2(Gap)?PQc?r*PX=qNOipw=0kDm<FH(#SWMID!Gp*>%BHtNSW0Z%35
z;a?nm(4P`6W0S{0I=Z7;*zlN1L&r|<WY}}`hfmCGYW);r!03U-SLL_R)#W&rVhzgW
zTKy`QF|v3V71let4wtj2-nhVDfw#4*(dZSLxATrJ>ee<s)VEBtQKc1{d(D4QLgRyg
z(mamu0-g=#NW3P@mnerR|57iCT%lETN<&ls){7>s(8@ViGU8dLHZhX;m_(hGT4k@+
zyfc!F7Q!??xIf1+c4iG4xl*g<?bNAI@(<6PMXhm)wy(tbdjy?bsa4gUM$qGxT9rl@
zB4A{E;!*85`P`=L#Z&pgJfz=xi}4J#Ptz)wwsnLm5mRxJ)rlshX%*W|Yimd_N%uLP
z6mcFU!(M2OUIepym;o@0V{InR(Rf$*9w)1C67&1K<9JOKZ$Z)dG_8{7N~4+)*VP9>
zyy0s+>9|8?(!BiIsy@LX9cLEC>43ad8bHlSJ6+}{E)6cAIBZ>VTZMV5GSyq9m3Q_s
zW|xE-xKXfC^Qg27hDD>(@l8czcEnf0?W?qyYV(XjCtwXHxvjXVHG(I3O#YmkTT`}+
z$$zyLS!P_DqI{2&eKqpkM;lga4f@pP0hMqIEB4Jh!vC74G{z3%pfX#IZ4cK(o*J|F
zBQU1Wlrq$mvnc9y(|J^5nPB!p&6-m6HFysjUt3<IRqa~3=%S<zVyOc|0#+2oPWEsu
zQU)p|?#?-sT9LApp`1F5y06t*k;_`mBhb5*qvQ{LEnG5(+rnO4I->_JppI*`!S=?@
z3r$yJ)D@W??^$T7p*c}De6h$8=TVXJe!I5|eziz>S}BVaJiSP{6H2PSP8$;V098;e
z{Sco8DprUmk%fh*Lc7;#-;NlISwT!Ms`*2j>s60J(<bO4Z?<J{Q5-L&ELNoQMatLc
z3^+1O=eCR>-}RVYu2YBgnqT0*+=GmL9iGi4<b6HX$g*f(TPS(GRv+Ex*m^A}a9W|q
z;e8Gd=eIoOQke~!UztC;bJ;mi{)5icYy$><If~k#)v$ZXB#7?!+grWw7<RHMk+m>>
z&%!{ekDoL8z4g&<RRA;!zpQ>+lE`irPs(_?{!N1}dz3x@fTq7;k?@2Uu7pG9CY<Z3
z{5Cwqu#6`=;w&nu(BOtq;#2wl%0S~#Zx}4Zh)|{L*35`;!1$FVVpw<cma&TEyQ)Ct
zI|lLax?}w4P<`7d-$rR0wSi_Y`g@}`7mNPQ$iQ>Xot@OX=H^YBN59ftIZvZGUn4W@
zQ2C<PbWB0d4>@taNh$MtmqM#+4l4{6({GW*tu7W>Wz&RBnwRI^B1w|Nk5BRV8$905
zbC2<pBz&ZbPHfWpHGGEQwJ_q}IkErh_!Mu7wJg-!d^?(=>fySp$uu<;7x>UTKdLlt
zZD>eUtUNz_vsR;`dnmWII+rfI(fO(=ZP|=h$>ZqGW}Hd4qyK=C*BbD7OCH(r7?(n~
zXs#7UG&Y*|+IFrdnpb^)!;c1S(LBO#ase>U%fj=<7pv~c)KGw4b1LF{)QLX{$J2C*
zM_1!$YRnvXxgHU0Htq@h!E5ZI(5oMxhM_U*W8JGQns@0np`5MZu!yXgINxkw^oWSl
zMMsI#+!Q`xQb%3_!ZiU4#7p<+)yOD+i7Y9<^(EKD=pOsF@s>&Tjs~3IivYDsL5$Jo
zqo2QVjHuT!k#=Ni9+mIbW@9<mtI~pVh`3(Zv^jJqQ}e_3J@ib?-+nO!$M+C6;BxNc
z;#heJRZeNxv1mVBETIMXqDfV?R{a7z_<L+JzJ%djiEa71IF5fe;K+4)xREPdSY<0-
zpr}ICsr=&sn5hb5{aw!yt8wvIwdtF!+SuClP*Rizr}6mT2s^M=u^cnFiRCH_YgKO3
zyhCqfLZ4(hiaQ!ceQaDi%n$tCo(o%X7vIFEI>tD~*MIOmyvE9I2<_RX)$KH~11I_G
z(AJA85>j6x)dRk~XA&ch!>g+@JB`gwYV$HS+pEp%*la`9w&M=rGU~b=x4*X1Xa+uV
zvRw-<5rrO2{%K}U+^Mr(KrW88dbyq+D>x(7=s28W$l%kkea)rGB@6d9&E%Vfn~3Xp
z1fW@xBL2cID`-SLvoLcEr0gu*8XQWuv$SUAr(=&{MRnXNPv|HI>4sEmhc?v3y@pX`
zHCN&KZHLyV@x|)JWX9+$a{IU?7U8-b%uU^ge-cnW5CKe6tazmAv{MVRm&`DH^E<%g
zC^V*H{OBToMlDCO3@1k;dB}LCkz|eD%pTlJtnHMqH+It@wnLM&EY!YitF*5hBJ&ih
z*)V1|hoVHC0=*Ahe%Q#K9(NcRF)7w-h9{f;A~9}q1@H@wLPee^a-hgRZwz{CxDnt~
z{_DExl0D2*D;0edEy=Boe5!I)(F>A1hHU1njA>voN{1fCr-#P%{!yc;tapvy*5JYg
zWrS<KQADHKh+}x;21sqS00zFp=U(+d8xCnq??cg8nBMt0hrUT=i5>l_A)VNzb*MAh
z7!~TCW|B3%$e<?11HL-X4hhDmUf}cvh3?j>nm?sz#srGnjh|Ki8pLNCCwRqU{2W2n
zLH00ajl$$s1p947u}Fca=e*}7@NH&?54Uegqtr6-Xy}-~)i37r6n&k4X~PTHt9;nU
z{;)MyRh%vw^PzRg`ofAv8B-^|DQ~S=B<x@a`LG%25Z+LoXn*l&a}Z5+?Z(Jk8TbSg
z%WhDk0ynIh$j7D(<(MB%oAzK;pSE;<4}M7zCDNXC(MS=uk|J&yUA0H?Tppk;pg3g0
zAC9>#4INg+RypTmmqUB7oT2rY%-WPjvjB(1x7;akm}0B)%4&(S>fNuH*~b6dY@#x&
zQ_N~sF{>&nSTAK&s+d)8`f9IM$zI&CrgF^ZQuxF1klFBV)U24Bld{3b;cnq@*&P~m
zdq*`Ma#!b}VSLJ-M}W-!gHevc9lV)$gv{Xf6l+9r-NHg0z8{3M0%U_u`yGa(YRVc$
zU*}HaQrs<)-LSM!OCy{7WhjU2s#EzZtBdoQZ%n2?U438jqTwCqohXH*>A?5<w9>9=
z$FZDLb^7_ZHuXTi9BrbRzW-YL3x_}$occx^UbfG@7X|u?mj!xt{69*zIqii1!-}O@
zR{a0tqMP)V+^{(i_oMcmhq>v2-jB2>Ebn+A>#6pQ)jkF1ECHS-(`B$7ST(dj9|nF2
z#)ChDTflP73iK0T2$%;>154OUCO!-XfGu#8Z3iv`hk>OrpyR;>;1=)+cmn(g6M7za
z2rS`+H@4ovDR+RE$ut>k2j+ppz%n@HhzEy*TfmFp2`~tk6M5iy9LY;~Lys$-05Ae)
zLhZnx!C_zmu7BdeSX`rT0r?{51eo_8rd;qDZZ4GK*DPjqEzoP=_`k7RfzChg{0STf
zR*J+=pFo#h1^VaUFx-v24u-v7pg#wD^efOkaW+!De}Uc<ECBm~KMW|)XMnqKe{L1n
zItpC^EFTSjup#&yTmpL9eR0UbMpN(^*bl5S5COme;3_Z+{1UtmUI+Q1<a2N^=vmoh
z+A$dZVBiq=gMGjmU^ci4Y>j6yUxH`B>)`tz!XLZ<+CBZ?Fbn~}TVOx%#Bc-ve*ss4
z1tSmuY>DTG*THTR5dho`dSdM6%s{^cUx86zwV4Ha47dke2Yv${2JeHnz;|aA=&!(l
zSy-{a2SaNH1YzKBU=)}=8v($7z;$493<7|?Vi5pL0bhY%fj(7DrdD&{53T{Dz`bA$
zcmiAp{s|ri%f`VUT(S`U;J8FP0$_q}zX$=qs!0d{z6N8!o5=_Oex8B=VCrH70LLyt
z0I(x|#O@P_U6u-ePzR&H8_VDiez6?>;L;WF2gk33KiDA+{$PNe5TF{G7z_h{T7>}M
z{?!NoE?a{D;63m#xOiQGeh<{r3v?6Cn`VQ4;N<n_{ovFM=>6ayU_7{eBYHph6L<o2
z$-w9VJAox|DrH}ejR0%}ZbAUC9XJf+6-wg4Bj6Tr!e#^j{{!>Dfm;wD$YgpB27nba
z;SXNk4u9~y9q<Rg0=Iy<yWkII?uI|;y$Aj^G5&jEBcP_qRB|r@fNjBHU@{mFy6!^&
za0++=?3s-KVCBy-esMy6bU%hKIQ#%+WzhE^CQUHs5UvuzWnUHO+rez`G#Gan;~%Vj
z9R9WK7^m2%feVJ;b1?qFyI*7cgLl3u(38Q-Ckpgk;MXS$^z&ecZwvHC;BK&VFgh(*
z8{Bsq{$SHH@CSE+$za{H@CQeM=fQOF5qK9YZO0{`_c;UrKLERcPc9+=*yj>z01mp0
z8h|suLkob1z&!A$AJBw#(bPYp1;O{Pp#{OJ*U^IDDKH*<eFH5B?!N_p@a}E+gMIH}
z{FlHr&?;;MfI;^V0GynQCInOdhXQ~P!0q7LJTxKrFPIOGxsN6cL4m;<;D-;e3&8om
zz#lC25dL7rU*Qiv2Ty|~AHg4N^a$g>RDC>TfuIKX4D1M&{2c*6A8;Y~Gq@eB@CO2b
zgC7^@Pr!gDn1C9fCeI4=R$%Qv;Rn9+7p88o!{3;=z}SB=YQWylQQ(Fq(~1`bdOh&_
zmv+o}*eL%BmxW;O*T{$!;Azkq>+3%O-@`WqJR6}!@QH&~;2tMk9|d;7BG^m8SS;%O
zB{&-k)ZYVnp?VXp?$YpKp&DQ?*4gg?+Hqs;Bd`QMm$4MAZ^y<yYzzc1gU7%p;8*zA
zgIg2q3Vf2JDfkQ64|KyPY+^vIqOPw47lVhvAHiGTUQb<r1%6@Eb)Tj<ihAjK7#IOY
zfwA832k(OGKzk1#1i;2Z@D|9Q>UjnF_#!|kj*4Iy*rqZ9fcwB05X;l*>%bqu!(a$L
zIduzs1-=4%R)v2v^bIf!TpR#@un)e|7z2jagnu)P|83Yf41p_t>vaoU5559}anr)5
zxyf`G3<KZ8cle^fpTHO}2_Fnx2X?FnfADY!njS1uA59;I6Oe|w?gx$oTY<Bi;OPih
zvnjqJ0aj_I>s!Jw{<~r01O!>lbv+Ms3Dflw;V^8e>j7YND_w5~E*gvg;5jfJbRB{K
z;8gGgxEIU=&wwRbm`t07!XNx{IQ+qjBj67<83}(*gIny_m^can!1G`p=s6kzTAEDP
zzyL623@(+xOmGx<9b5?h3vLJNjMeqi;4&~DJPej<g#u1M=L7429l@^PC@^Ls{Fzg9
z-M$MOr?7DzY&1>RAAtmxZjBibtPT24*Yz&oIB*<z1WX2J&(QT<VEb9{2hYuhKg(m`
z-v)ij4u9~gIQWBqg5$u@x$p<;&C~7rE^KUGfB>N9V)TA68FXuF!cj=q>w)vZ9^fhP
zBk=q(3?H!m3XC3bGk6*FPlG==A9QPnT}Qg!5G1fScnO>Wu3xR|E5L78qlBMh<97(Y
z2ea4c`d{G5wYpwD0_SS$5CBX7dxLr46mar-1OO*xz#p8jN!PD~i#O}~b8rXf+1_OG
z+lAo^P6PXa55O7VrQN!|3Y;}+4<-(5yuTL#z_0hA_k&@dqW5<|O~5el4j9G!480$;
zeU9D_t_BZ-&A&kJ2kRU_@9$_b?F9Y6mtZUKzXRbG%Q<J?duUWsgp1pJt!)`6?ON%Q
zr7+YXy6%jT<VUm0TfC@M8A}OsJVlhTRMrmo(VDW5&4Em-?N0+MAhD4R8dD|=@I|+i
zY!`uVhgP(BrMW;ehO92oOr=0TdsdZvp`pR7sz$?EHYb3ZaZVdq_7i17W(f!^pbcRb
z54z=IDP@UAs&bgcmgWkJJ!Ex7z&jKOXw|FH`d|(Sm1Rb?0(!5Z#YS^D6^B$yc+p07
zJ4l&quT`g)T!nj(Y2nprj33JB2K{lex*=>R1u|Yx1Y;TvSE&TX70P66pp$Nvs^-7w
zA*X&OXLq0@1-V1mg}QQTB#q}(0;Mu~(tbuf-C$i9y<pTMTUp>23T3RP{)|2}6VOVx
z;CA-K{pW)$ZAdp1UN9z-tsG#dP{uOq4``cOQVTSLwTm0h2xv8n9=61~s}?V(WQeSI
zY{lEVu<hT9*4KgQd2F{LTX_T-L!pe5)SvMK%>*>}HZ-sv?8dp{G>Hzf=2yDGc%NRd
z!S1%ytqOuZf`LanYUY6w$54L{ShS;=j1IJ#(Si;#2GI>hH+sQHAzKABN-Tv}Kx!35
z1KOtdRmdLYaM<og>nk9nPDfZ}?nif!)JpcF0;Z`S_at95PIyHGSU}N?V2Wk*q;$q<
zI>MMpw;74_nn6^_(^A?0RaAjK;EnztS=j&GJWQs>6b&;hNFU4aqjW}HI>M+!w;4(F
zn$eLe*-$`j1hufCK*uN=N%KsKWi+OARz4X;N4+fGB`V-dk#4hMB)w)}6?QM+4uvz;
zQZ%6T8Bd?sEZ)|NxJa2m>%9>5JRM<!M7qsrORw3^G>Lq@(H4g$an{}?JWZzQ6zvUz
z5Q=5|LFs_zGlh<NTdLshZ!Sw;lGz97MgBh61Jx-4DU0)r0&=xt#KrhnO5xUR0)*PD
z8Pu#CM$2&@j273KDshh!Rc2BPjQ+Gr7--=$)$k-gq)@TIN^rd~la6}wz+{W-u-My(
z2PRUQ1?yk&B(RYa?z3oXCDdWlEV{|Fz&#ea&ZY+tVn14a5$pVH6|0pm;-8}k$jrlN
zIAA$8r+_|a&Vw8}%{7j;`XZReJo=V-a2~xx(6q`ZgKK;N?c~Y94=Jr$JnaZXcC9$^
zRlG4gXfP6Zduw=Q<Y`Kv#pvC%k!2rJCS>OAbdoWG?pL-{)m#(l9X}LuF$MX-!6TVE
zb8-)jMiP4<k)=N`F^X=Dsf4Q@I>VY&dI(s2Rv1&9&3X%}7z*;ozF19N{b4bd#xpuo
z3ZVI{qHg{eh;w{#B}W%n(~Ev*tfn$mfCCiFh@!5H6Eq&sJlApgea*9JH%nL01x6PA
z&NxS9ssg`IFrbx8r*2hY8bjl&TD&n0B(icZWpQdZo#fO-x(`?`ZI$Ns3qZ3}roaIB
zzq_5<2f+UT4M)=4oDvw3l*xEVCmDazeL(BHm;T^Z^$UdiI0_7e>NZ6LqB$+uG$s&H
zUQ;4V8&ekJ9GwBQlAluxbQvpO_YWZFY7iY)A}7A|FSnmMSHu3U@CA(l%`+$wCg_S;
zj2d)?9V#9&x}6hW`v+p1Cqcgc|A2z3L%rz`&o^F9J^?sIknJ#RCm*7LoOKko>r)m?
z@r9i;)h*S{qv$E1l{i9PH7wOMmt)ihG#{qXHK6^NQW*>AAY&!vGTM=I5D-Nnj49Ng
zkxX%bWy@(f<{b~Rl+sF^p|e4V>VBTQYFesT&sQ^<YLTrb>?5c(qXms-d`_v1BXp3l
zoN{ZTgwM!a3#kzl#Q1?CYjGpqq>J2<+SS0>8>K>Io<-S=`E-SGik>nylY4E{tHEuW
zP{mS#dep{*uz>p4#!gDUqxxbGT(l3Q^xCjKOGg;b=r&^~y=E+<O2NPx3TNa}G~)%u
zGMZC5Bbkmcw$N?H3aV5GGv4KzxG>~R?#|(iI~2{RO|gtWDIL(t{z6CVU_W=I+bn%f
zuNif)ayMc;!S(zu-mGk{Nzsfe6w6pm>5Tu;5k@V#%~(UP0nPa--KmSVd4g;C85CX*
znqMfI@jk_>R5~M`j?}|I{ho4>^0)p|fL~@6JBhOVW9Fj>pG19+tNJ|h4}lXtzaGL9
z#(y*-1f^b22`rsPnSeI;HP;0bUkHZ85xUPZO(&=Nuq>d!`bfH4s68irX*iPRmXrWk
zKCG(KV}DF&$LnKy%R=gIMWpT_h0iJ8XOkl=tj%*?0|=*4U<0_1qX@=O8qU~B35+U~
z$=FOM8TaTupp~vkP7RUoP6}*@O4p`N4WVpAqXA3DS~?x`wAidsxOneCS*#jJXIQlf
zszDW?It<k=a&83K-C$*2@)cxvBw_Wzb^C1^4FmHdN^FEoPSb8q{Ye)Xt?75hJSx)|
z*g?UJ3)B_xf8I#fBi}fJcPu=D^YwoarLgrW+RgZwE-<dq?~IXDrU@{Nf*B*JE5lCX
z8JU#Ah@st#OLU<LiseU7IW>jcn*ygPgi(hg8Qp0Tqamd-Fr*mg=n5l<o-!tod#I(V
z#lM&Aq#mKzWzCUl8H~O25mK1br-t&b??Y*!n9APiLtil6`_PY|Wq%)?{&R=1TQeAE
zkw-IxeNK%SLDYvail#EI(MraC+TRQXUraYRwU}No7LlzvcE-KoI_Y&RHmB0KxUVpR
z1~kWB9zipq!#U1sHaRpBCZ0GSxZE7We>&Z0j$lXWHFTQiSn>^nM;i(cgU2k2W(=TM
z##BmY{6I&-;L(e6IaQ6!;lModXM9Sn!=YPpV0gIYy)x#!1KFJ|m&)5Wf1~m4G;J4t
zAv`X;E6fxACp4W<e!jx0!j{60!coHU!db#Oigwcm5o{6W2)`BH6y6m+5<V5Wo>T=X
zFRUr7D{Li<5DpZ6XwZ%;LlMjtCJR%AJA`|M2Zcw4XN8x94}`x73xt+$RY5BWt1ywj
zDOd#cg)N2cgq?-mg?)qrgd>Dwg_DF+g>!}Tg=xYyAm?w|CW4*9FNKGNmxNb^4}`x8
zp9%jFz80GKZ9n|ID|8il2yLe{BY#tM5!4bk7B&;M6?PEz6!sMk5`HM0D4Z<(L^xNt
zRJh`lU6pXN2(}5o6do2{6n-bXEzA`@7rqi&Ppi1jLNB4OFi03|myK{?Yhi@2lW?eT
zgmAXd;h!w&rNVW>jl%81UBZ(>`x)7|EBv4E58<D}w`*uRqiSdsItyKdWrY=me!@Uu
zh@#!pSOl$v5yH;G?!tb;XyH)dNZ~}`6ye(~I#=ZLg~<ld|CWj%UARg3b`x$B`7YrB
z;bGx%;Yr~c;YHz(!k>iqnB4#Gi{OdyZ{aH;zM5wYqj!X*g`PrhVKrfpu)eUdu$3@E
z*atMm-vAMe6pj_f2<Hfw3Reg-g;~PG!W`jw;T7RE;Vt1WXJ!095`p!c)KnNKtSM|L
z3>9`3b{D=q?A{)>Zx6%w&&l}zKmz>#M!|To`&bw&oGW~LYF;4nWZ`Pzdf|S%Y#b7v
z7G4nE73K*a3;z=0>yt*`a1we5y@Zv80m5KmeWAUzY_u0f3i}Ej!zfzPj$!nnq{j#+
z2&W2X3g-ypg$sqrigwd75u^#%2{#J23wH^>6do3SD?BT_D!e8{Co@{;j-(xZ?6HyN
z{(nIkScR^_^1>>@>cU3CX2K4_F2a7oXyI7l6yZE!GL!RPCxT4jSHcs*tHN8tUxj}P
ztrt}VT!cPCe_<_QJz+~>J8(F+O{56=3I_^56iyb-5Y81Y5DtE<3c#`WuiG`1?kwy<
zS4QIu^e#OeZK)gCL!=#r?S;zs|KTnAlTTGthhG<w-#svCjHRxIOM#4WmO<twWFBwn
zfD4LF<1N#1*_JcjQWxjIPa)J?{zuIwSnAk5E2%;mFTNn(!ANQ*7u?>An}AS0_vurZ
z;oeH_1WQG}c?u~mD1#<KsXe3t6QOKLiAdti`yitWJ!B-4?IYkkbpo`~PifXi$gayX
zzFfu1SH{11_Fz%jou?c&Gyg-+V1^rv{*&OGK#`2C6vt>s*^J4Q%a}^;9|O;*H3MrC
zG6E^%V@pNbE32v$o=Y2l1FR~SzI27H?vi=3r9-EsWtCODSgjGO^5x!?ZxeY&Jta3f
z3VaTU{34}JMy5d(mHM27yD93wu;>ERojsL$y{Jn%sWRo$Q>Z)5w<)!pHJL(0?G&Qq
zK4>WZ3ln))A0^LMFm)GsBZ{1Ya2s$3k^e>+|KhQps7v}O`4W-O7J1rR@)VH=QZ~Zb
zKKFmqZKtT)QZB2nR#EDG67{U8=aKtVs9Oap^%S-5P5+4cb7~EBCu?=3Htu8~LQqN7
zG9`kPe6U1qD)M0>ca<jTCi2OYF%{i?2|b)@nI2*rr@Y@2?~4v^ksFup(A^OEeoCE&
zvbLD0+!Ca$PelC<<*<74$4XsE!Q_lbRy<s=94gf2-^h77I@mD^osJQgN7>UY$844Q
zs#x`;Bv;{67Cwh5aR#h5k$I+NP>6ROWwlbQhTtI>TeUr><fWxRc9CDA)R`zy_kKz~
zP24t!8sC7MiIN<or;O(0KMTc+rO;WHCALuwl}~5!>GzJxsx{@#f^j~%&qh1q?%-@o
zUE8;fmGK8+d`XNyqztId{&ZzFiZLNWHONO|^+K$+k~s!elPDwx`D2lw7|RmeBEAuW
zijSbkSO|Zm(Xq&9{0f!NOo`B|v?|my%7&G#`xceKSY>4zChA1W<sftDMJ&o3POU$&
zbg*SDQO4!P_>>qwp$w>Tv+3a{C{za7?3O{cy91O}MKO*nqcW~dsdh_6?VV|~!;UHG
zG~KYH(8DNl4vO>Rc9jF3@f&~7#OVOV%|YnzDSHkw>PRm*6-_~LNG+gAad7>6j>_n^
zxbAXM`HiQHI2ezmD~#u4o(n9bkh$<#HdXoH!I1G+#Z~!Sqakc{i&7cKD2I)!1go+=
zmkNy$;|27Tt+tT=JRp-I=iwOf6=icOo^lzB$UPn<y-EG!k(xq@oLWRz;$gXkLK4u@
z;nXPst!8haqK}pmz3Z+@RE=^HEOkRX+AH-_DMM3H$Inw`n<8#KM1F|;=Og$@3Z0LP
zbs9Y%Ic}pfoa&6V6wqrPQ{n;~xXK-;?-p1V<Jd4{Au8LRm!ZMmAPIP{tSZMUN`)Fv
zG_w}sxZ<8gHy2_j29t9lYJ}CU65*S*Px)RJ-*I^C$3yNjic3VkYbl$pN`9z{Tv@EL
z#VUkyp~em37cjQH_pyqFABz}&cf~4;S}#J6v?Zw^j$?;^d6ktfWh_D-hccCVmNZwm
zsQb|s_O9uq)VMip{LK*c5(-H|L9=K`5`yd}<((~7Ux?NFl*(3XC<j)!6?P*DO)#JQ
zli@QiSouVWPdIuQH^C-~gc^HbbTTS8E>l_E5v%E9wT-fqQM^;hs(6>A^x2}0BKH(z
zT%B5{AgilwmAZ{GHvKAAmuV8z<}^x#u`PJ4QV*4^D&mnP7YM_GgG7g_AooNaD(bpq
zUW{6;qE3s^aek$&#g=Wj&lkA_#S5ydd?LgroS$nV<W0(E^^cNcTTxFD^+s}EigF#K
zprr`;4<#-|2Ak>1QdH>{nNy+rfNZH43w;`?G6(yq5YzD>lr!i~sj#v|NC%Q)m^O;K
z8|A<ox0?Nz0so^o#xcrWh77Ke`*LLP4FxTSuqP!h#|Y?3wiRe1TW?jLmQvs)UMjnf
zX$aJKVwTFNjgNp@rrT1pRM|EuACsH6GX9q$SE4?5Xf<Od<*r0Y{~E8XYD(n6c;v?w
z`H0-pP@2yuC=JF(@pdtc|Gub<`RmR6_k~3MgfiIp7#&PQ+q9Ac=}l#1DiEs^6hbIv
zR~kYHIi0eQ(n`HcHwnWul$=+=H(CxojydKGo@;P%=2P4%o(VS7*;P2FEZJ9;V1#5*
z8V@wp{&ioCEVfYV)o8<SDPuKCy?e1LwPW^;6XVHr1;!yh6P3ER#L5tL*ZxYrK;)l^
zJb^;iptAo^r!~kboo22<R`|gLr*4z;TGXuxMXrSj9+$1P)b(n+K?QOgC=W^#m&~M3
z*BXbJ+_gB&T&4c&;M<Eb)>$eJxw7ERLa)MH#5MHlrR2DaZv5>M`L$z89wzeRB7ax9
zAo4W+PKz8r21!TRyyeK`*jFz_ZMs84(=ByET<@x|x#I5Ur;6bz2mihzuP*Z6C<kFR
zYh!wrZfS4xny=g)O+Q7<VkvSx4zv~a(3thuoj=N@$TNxdnV4OrY?#^pNq#fRc~O5s
zxvYMCL#Zc=_hV7FB=-$a@0$Cjw=U{@YP|vN-Io$KV1)VqpseuiapP~ezp5xEAr3NF
znzxbCn&yf637I!yzi+3Ijj*~cJIApTE{fF>8nO|c<P*wa<9K?y5tESHK-GtjNyxEP
zRF2IkG6S*x+@sWwr9jg}olkKY2vU=>GZ69wxo<*Gt42YaAlyg&867Ec6KaNoICP!D
z<QU;NEB>ge%E#@k<8qS7hc8k&I=aLPkzb{d%?O@DLpCGFk7y=RosKM3rJN|0xFg0`
z3B!;$#_=B_-#0+nSCCp2i2M_J%E6nG{}v#MBDbIkK9M8nH3>c#&%=2PWKtYkO{MHD
zmJT8MW);iP=y%1+b&ZlAv?%wdB40v5nK&b^+)b$+!3PGa;GuLS6M3i0?CChkju-W(
zWZsIr=TgX4H1Qsq$*Hd?Ybz$N@;|GP-%5GAS5qPXApdPJ9!aCOVV8YKXSQLM_NuE|
z!f}ANR9D9LssDEL#|z!xEM6l~kDv^wabkI8J7UeJkSwHD(vU2a`P3#Aa;N0aKe*@i
z8cV5cHJWl5d+2EvT(?u?4isuRt=@s`O7~RR`HAZuJg{fi!<4%NkuR23k#C6lf~X&m
z`%Z*hM6GwCPc)$ZJ8{gKKo23bU0<R??olwM2dR)#C}bBxcHXMwavR5VMAR>72&+FI
zta9w7V7e{p$&|Var9Vwi+3J52RS-vux58nJi`|m^cVmcIU6r?EvWyY+SiA{{k>Ql4
zyd7us>qYI<QOWyC&)FvO#`TrlailmP^3Nz2;cU00&!eQq-w&dGN$z{lNJFXh9#~b9
z;fRUW_^Vh;75N%Xg4+BeCGNp)SxZ;gxW)`sfypJ5@ftDymCSq5#1^T(O=A5Z>Hz8l
zb*HIr%6q7&3q)N)PUL5cyaf6nw_3$4RX;ginaYWLDdp@%nO2kYKFhTbADN9E^MeV$
zI$-bi(xE?4K};?p|Bl?VQL!Wn%0`feG>KF9DKXp91W)~QvMnt&?+XXCPc75x<MeH2
To~5pH-ab`uJf_XFY_t3yw^jgs

delta 60876
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

diff --git a/str.h b/str.h
index 7810f57..a61290a 100644
--- a/str.h
+++ b/str.h
@@ -1,6 +1,6 @@
 #ifndef SORM_STR_H
 #define SORM_STR_H
-#include <rlib.h>
+#include "rlib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -47,4 +47,4 @@ char *sormstrc(sormstr_t *str) {
     return content;
 }
 
-#endif
\ No newline at end of file
+#endif