From 0dd35f4b86a78f9303e15a21be8684bd635a902f Mon Sep 17 00:00:00 2001
From: retoor <retoor@molodetz.nl>
Date: Sun, 8 Dec 2024 16:19:17 +0100
Subject: [PATCH] New build.

---
 Makefile |    7 +
 sormc.h  | 9053 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 tikker   |  Bin 0 -> 229432 bytes
 tikker.c |  113 +
 4 files changed, 9173 insertions(+)
 create mode 100644 Makefile
 create mode 100644 sormc.h
 create mode 100755 tikker
 create mode 100644 tikker.c

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..4472287
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,7 @@
+all: tikker run
+
+tikker: tikker.c
+	gcc tikker.c -Ofast -Wall -Wextra -pedantic -o tikker -lsqlite3
+
+run:
+	./tikker
diff --git a/sormc.h b/sormc.h
new file mode 100644
index 0000000..053bf65
--- /dev/null
+++ b/sormc.h
@@ -0,0 +1,9053 @@
+// RETOOR - Dec  5 2024
+#ifndef SORM_H
+#define SORM_H
+#ifndef SORM_STR_H
+#define SORM_STR_H
+// 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
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct sormstr_t {
+    char *content;
+    size_t length;
+    size_t buffer_size;
+    size_t size;
+} sormstr_t;
+
+sormstr_t *sormstrn(size_t buffer_size) {
+    sormstr_t *result = (sormstr_t *)malloc(sizeof(sormstr_t));
+    result->length = 0;
+    result->size = buffer_size;
+    result->buffer_size = buffer_size;
+    result->content = (char *)malloc(buffer_size);
+    result->content[0] = 0;
+    return result;
+}
+void sormstra(sormstr_t *str, const char *to_append) {
+    size_t required_new_length = str->length + strlen(to_append);
+    str->length += strlen(to_append);
+    if (required_new_length > str->size) {
+        str->size += required_new_length + str->buffer_size;
+        str->content = realloc(str->content, str->size + 1);
+    } else {
+        // printf("NO NDEED\n");
+    }
+    strcat(str->content, to_append);
+    str->content[str->length] = 0;
+}
+void sormstrd(sormstr_t *str) {
+    if (str->content) {
+        free(str->content);
+    }
+    free(str);
+}
+char *sormstrc(sormstr_t *str) {
+    // sorm str convert
+    char *content = str->content;
+    str->content = NULL;
+    sormstrd(str);
+    return content;
+}
+
+#endif
+
+#include <ctype.h>
+#include <sqlite3.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+sqlite3 *db;
+sqlite3_stmt *stmt;
+
+char *sorm_last_query = NULL;
+char *sorm_last_query_expanded = NULL;
+
+nsecs_t _sorm_query_start = 0;
+nsecs_t _sorm_query_end = 0;
+nsecs_t _sorm_query_duration = 0;
+
+nsecs_t _sorm_result_format_start = 0;
+nsecs_t _sorm_result_format_end = 0;
+nsecs_t _sorm_result_format_duration = 0;
+
+int64_t sorm_row_count = 0;
+
+typedef struct sorm_t {
+    sqlite3 *conn;
+    int current_row;
+    int current_column;
+    char *csv;
+    nsecs_t time_query_start;
+    nsecs_t time_query_end;
+    nsecs_t time_query_duration;
+    nsecs_t time_result_format_start;
+    nsecs_t time_result_format_end;
+    nsecs_t time_result_format_duration;
+} sorm_t;
+typedef char *sorm_pk;
+typedef char *sorm_int;
+typedef char *sorm_ptr;
+typedef unsigned char *sorm_str;
+typedef double sorm_double;
+typedef double sorm_float;
+typedef bool sorm_bool;
+
+int sormc(char *path);
+void sormd(int db);
+char *sormpt(char *sql, int number);
+unsigned int sormcq(char *sql, char *out);
+unsigned int sormpc(char *sql);
+sqlite3_stmt *sormb(sorm_t *db, char *sql, ...);
+sorm_ptr sormq(int db, char *sql, ...);
+char *sorm_csvc(int db, sqlite3_stmt *stmt);
+char *sorm_csvd(int db, sqlite3_stmt *stmt);
+char *sorm_csv(int db, sqlite3_stmt *stmt);
+
+typedef enum sorm_query_t {
+    SORM_UNKNOWN = 0,
+    SORM_SELECT = 1,
+    SORM_INSERT = 2,
+    SORM_UPDATE = 3,
+    SORM_DELETE = 4,
+    SORM_CREATE = 5
+} sorm_query_t;
+
+const int sorm_null = -1337;
+
+sorm_t **sorm_instances = NULL;
+int sorm_instance_count = 0;
+
+int sormc(char *path) {
+    // sorm connect
+    printf("HIERR\n");
+    sorm_instance_count++;
+    sorm_instance_count++;
+    sorm_instances = realloc(sorm_instances, sorm_instance_count * sizeof(sorm_t *) + sorm_instance_count * sizeof(sorm_t));
+
+    printf("HIERR\n");
+    sorm_t *db = &sorm_instances[sorm_instance_count - 1];
+
+    printf("HIERR\n");
+    db->conn = NULL;
+
+    printf("HIERR\n");
+    db->csv = NULL;
+    db->current_column = 0;
+    db->current_row = 0;
+    db->time_query_duration = 0;
+    db->time_query_end = 0;
+    db->time_query_start = 0;
+    db->time_result_format_duration = 0;
+    db->time_result_format_end = 0;
+    db->time_result_format_start = 0;
+
+    if (sqlite3_open(path, &db->conn)) {
+        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db->conn));
+        return 0;
+    }
+    printf("DONE!\n");
+    return sorm_instance_count;
+}
+sorm_t *sormg(int ptr) { return &sorm_instances[ptr - 1]; }
+
+char *sormgcsv(int ptr) {
+    /* sorm get csv*/
+    sorm_t *db = sormg(ptr);
+    return db->csv;
+}
+
+void sormd(int sorm) {
+    sorm_t *db = sormg(sorm);
+    if (sqlite3_close(db->conn)) {
+        fprintf(stderr, "Error closing database: %s\n", sqlite3_errmsg(db->conn));
+    }
+    if (sorm_last_query) {
+        free(sorm_last_query);
+        sorm_last_query = NULL;
+    }
+    if (sorm_last_query_expanded) {
+        free(sorm_last_query_expanded);
+        sorm_last_query_expanded = NULL;
+    }
+}
+
+char *sormpt(char *sql, int number) {
+    // param type
+    char *sqlp = sql;
+    char *result = NULL;
+    int index = 0;
+    while (*sqlp) {
+        if (*sqlp == '%' || *sqlp == '?') {
+            sqlp++;
+            switch (*sqlp) {
+            case 'f':
+                result = "double";
+                break;
+            case 's':
+                result = "text";
+                break;
+            case 'd':
+                result = "int";
+                break;
+            case 'b':
+                result = "blob";
+                break;
+            default:
+                result = "?";
+                break;
+            }
+            sqlp++;
+            index++;
+        }
+        if (index == number) {
+            return result;
+        }
+        if (*sqlp)
+            sqlp++;
+    }
+    if (number > index) {
+        printf("RETURNED\n");
+        return NULL;
+    }
+    return NULL;
+}
+
+unsigned int sormcq(char *sql, char *out) {
+    // clean query
+    // converts %s %i parameters to ?
+
+    unsigned int count = 0;
+    while (*sql) {
+        if (*sql != '%' && *sql != '?')
+            *out = *sql;
+        else {
+            count++;
+            sql++;
+            *out = '?';
+        }
+        out++;
+        sql++;
+    }
+    *out = 0;
+    return count;
+}
+
+unsigned int sormpc(char *sql) {
+
+    int number = 0;
+    while (sormpt(sql, number) != NULL)
+        number++;
+    printf("FOUND: %d\n", number);
+    return number;
+}
+
+char *sormcts(int column_type) {
+    if (column_type == SQLITE_INTEGER)
+        return "integer";
+    else if (column_type == SQLITE_TEXT)
+        return "text";
+    else if (column_type == SQLITE_FLOAT)
+        return "float";
+    else if (column_type == SQLITE_NULL)
+        return "null";
+    else if (column_type == SQLITE_BLOB)
+        return "blob";
+    return "?";
+}
+/*
+Execute 3.35s, Format: 36.77s
+Memory usage: 537 GB, 96.026 allocated, 96.024 freed, 2 in use.
+*/
+char *sorm_csvc(int db, sqlite3_stmt *stmt) {
+    sormstr_t *str = sormstrn(512);
+    unsigned int column_count = sqlite3_column_count(stmt);
+    for (int i = 0; i < column_count; i++) {
+        const char *column_name = sqlite3_column_name(stmt, i);
+        sormstra(str, column_name);
+        sormstra(str, "(");
+        char column_type[1000] = "";
+        sprintf(column_type, "%s", sormcts(sqlite3_column_type(stmt, i)));
+        sormstra(str, column_type);
+        sormstra(str, ")");
+
+        // if(i != column_count - 1)
+        sormstra(str, ";");
+    }
+    return sormstrc(str);
+}
+char *sorm_csvd(int sorm, sqlite3_stmt *stmt) {
+    sorm_t *db = sormg(sorm);
+    int rc = SQLITE_ROW;
+    int column_count = sqlite3_column_count(stmt);
+    /*
+    sormstrn(1)
+    Execute 3.41s, Format: 36.77s
+    Memory usage: 5 MB, 96.061 (re)allocated, 96.024 unqiue freed, 2 in use.
+    sormstrn(512)
+    Execute 3.68s, Format: 36.83s
+    Memory usage: 537 GB, 96.026 allocated, 96.024 freed, 2 in use.
+    sormstrn(256)
+    xecute 3.42s, Format: 37.33s
+    Memory usage: 6 MB, 96.052 (re)allocated, 96.024 unqiue freed, 2 in use.
+    */
+    sormstr_t *str = sormstrn(512);
+    while (rc == SQLITE_ROW) {
+        sorm_row_count++;
+        for (int field_index = 0; field_index < column_count; field_index++) {
+            if (sqlite3_column_type(stmt, field_index) == SQLITE_INTEGER) {
+                char temp[1000] = "";
+                sprintf(temp, "%lld", sqlite3_column_int64(stmt, field_index));
+                sormstra(str, temp);
+            } else if (sqlite3_column_type(stmt, field_index) == SQLITE_FLOAT) {
+                char temp[1000] = "";
+                sprintf(temp, "%f", sqlite3_column_double(stmt, field_index));
+                sormstra(str, temp);
+            } else if (sqlite3_column_type(stmt, field_index) == SQLITE3_TEXT) {
+                const char *temp = sqlite3_column_text(stmt, field_index);
+                sormstra(str, temp);
+            } else {
+                // exit(1);
+            }
+            //  if(field_index != column_count - 1)
+            sormstra(str, ";");
+        }
+        sormstra(str, "\n");
+        rc = sqlite3_step(stmt);
+    }
+    char *text = sormstrc(str);
+    if (*text)
+        if (text[strlen(text) - 1] == '\n')
+            text[strlen(text) - 1] = 0;
+    return strdup(text);
+}
+
+char *sorm_csv(int sorm, sqlite3_stmt *stmt) {
+    sorm_t *db = sormg(sorm);
+    sorm_row_count = 0;
+    char *column_names = sorm_csvc(sorm, stmt);
+    char *data = sorm_csvd(sorm, stmt);
+    char *result = (char *)malloc(strlen(column_names) + strlen(data) + 2);
+    result[0] = 0;
+    strcat(result, column_names);
+    if (*column_names)
+        strcat(result, "\n");
+    free(column_names);
+    strcat(result, data);
+    free(data);
+    return result;
+}
+
+sqlite3_stmt *sormb(sorm_t *db, char *sql, ...) {
+    // Bind parameters to statement and return amount of parameters
+    int rc = 0;
+    sqlite3_stmt *stmt;
+    va_list args;
+    va_start(args, sql);
+    unsigned int number = 0;
+    char *clean_query = (char *)malloc(strlen(sql) + 1);
+    unsigned int parameter_count = sormcq(sql, clean_query);
+    free(clean_query);
+
+    return stmt;
+}
+
+char *sormm(sorm_t *db) {
+    /* sormmemory */
+    return rmalloc_stats();
+}
+
+sorm_ptr sormq(int sorm, char *sql, ...) {
+    sorm_t *db = sormg(sorm);
+    if (db->csv) {
+        // free(db->csv);
+        // db->csv = NULL;
+    }
+    _sorm_query_start = nsecs();
+    db->time_query_start = nsecs();
+    va_list args;
+    va_start(args, sql);
+    sqlite3_stmt *stmt;
+    sorm_ptr result = NULL;
+    char *clean_query = malloc(strlen(sql) + 1);
+    unsigned int parameter_count = sormcq(sql, clean_query);
+    int rc = sqlite3_prepare_v2(db->conn, clean_query, -1, &stmt, 0);
+    if (rc != SQLITE_OK) {
+        fprintf(stderr, "%s\n", sqlite3_errmsg(db->conn));
+    }
+    free(clean_query);
+    int number = 0;
+    for (int i = 0; i < parameter_count; i++) {
+        number++;
+        char *column_type = sormpt(sql, number);
+        int arg_index = number - 1;
+        if (!strcmp(column_type, "int") || !strcmp(column_type, "integer") || !strcmp(column_type, "number")) {
+            rc = sqlite3_bind_int(stmt, number, va_arg(args, int));
+        } else if (!strcmp(column_type, "int64")) {
+            rc = sqlite3_bind_int64(stmt, number, va_arg(args, __uint64_t));
+        } else if (!strcmp(column_type, "double") || !strcmp(column_type, "dec") || !strcmp(column_type, "decimal") ||
+                   !strcmp(column_type, "float")) {
+            rc = sqlite3_bind_double(stmt, number, va_arg(args, double));
+        } else if (!strcmp(column_type, "blob")) {
+            size_t size = (size_t)va_arg(args, size_t);
+            unsigned char *data = va_arg(args, unsigned char *);
+            rc = sqlite3_bind_blob(stmt, number, data, size, SQLITE_STATIC);
+        } else if (!strcmp(column_type, "text") || !strcmp(column_type, "str") || !strcmp(column_type, "string")) {
+            unsigned char *data = va_arg(args, unsigned char *);
+            rc = sqlite3_bind_text(stmt, number, data, -1, SQLITE_STATIC);
+        }
+        if (rc != SQLITE_OK) {
+            fprintf(stderr, "Failed to bind parameters: %s\n", sqlite3_errmsg(db->conn));
+            result = NULL;
+        }
+    }
+    rc = sqlite3_step(stmt);
+    if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
+        fprintf(stderr, "Execution failed: %s\n", sqlite3_errmsg(db->conn));
+    } else if (rc == SQLITE_DONE) {
+        if (!sqlite3_strnicmp(sql, "SELECT", 6)) {
+            result = 0;
+        } else {
+            result = (sorm_ptr)sqlite3_last_insert_rowid(db->conn);
+        }
+    } else if (rc == SQLITE_ROW) {
+        result = sorm_csv(sorm, stmt);
+    }
+
+    else {
+        fprintf(stderr, "Execution failed: %s\n", sqlite3_errmsg(db->conn));
+    }
+    if (sorm_last_query) {
+        free(sorm_last_query);
+    }
+    if (sorm_last_query) {
+        free(sorm_last_query_expanded);
+    }
+    sorm_last_query = strdup(sqlite3_sql(stmt));
+    sorm_last_query_expanded = strdup(sqlite3_expanded_sql(stmt));
+    sqlite3_finalize(stmt);
+    _sorm_query_end = nsecs();
+    _sorm_query_duration = _sorm_query_end - _sorm_query_start;
+    db->time_query_end = nsecs();
+    db->time_query_duration = db->time_query_end - db->time_query_start;
+    db->csv = result;
+    return result;
+}
+
+char sormlc(char *sql) {
+    // returns last char
+    char last_char = 0;
+    while (*sql) {
+        if (*sql == ' ' || *sql == '\t' || *sql == '\n')
+            continue;
+
+        // printf("%c\n",*sql);
+        last_char = *sql;
+        sql++;
+    }
+    return last_char;
+}
+
+int sormlv(char *csv) {
+    size_t longest = 0;
+    while (*csv) {
+        char *found = strstr(csv, ";");
+        if (found) {
+            if (found - csv > longest)
+                longest = found - csv;
+            csv = csv + (found - csv) + 1;
+        } else {
+            break;
+        }
+    }
+    return longest;
+}
+
+sorm_query_t sormqt(char *sql) {
+    while (*sql && isspace(*sql))
+        sql++;
+    if (!sqlite3_strnicmp(sql, "select", 6))
+        return SORM_SELECT;
+    else if (!sqlite3_strnicmp(sql, "update", 6))
+        return SORM_UPDATE;
+    else if (!sqlite3_strnicmp(sql, "delete", 6))
+        return SORM_DELETE;
+    else if (!sqlite3_strnicmp(sql, "create", 6)) {
+        return SORM_CREATE;
+    } else {
+        return SORM_UNKNOWN;
+    }
+}
+
+char *sormrq(FILE *f) {
+
+    static char buffer[4097];
+    buffer[0] = 0;
+    char *bufferp = buffer;
+    char c;
+    bool in_string = false;
+    while ((c = fgetc(f)) != EOF && strlen(buffer) != sizeof(buffer) - 2) {
+        *bufferp = c;
+        if (c == '"') {
+            in_string = !in_string;
+        }
+        if (!in_string && c == ';') {
+            break;
+        }
+        bufferp++;
+        *bufferp = 0;
+    }
+    return strdup(buffer);
+}
+
+char *sormcsvn(char *csv) {
+    if (!csv || !*csv)
+        return NULL;
+    char *pos = strstr(csv, ";");
+    char *pos2 = strstr(csv, "\n");
+    if (pos2) {
+        if (pos > pos2) {
+            pos = pos2;
+        }
+        // pos = pos > pos2 ? pos2 : pos;
+    }
+    if (!pos || !*pos)
+        return strdup(csv);
+
+    int length = pos - csv;
+
+    char *result = malloc(length + 2);
+    strncpy(result, csv, length);
+    result[length] = 0;
+    // csv += strlen(result);
+    return result;
+}
+
+char *sormfmt(char *csv) {
+    _sorm_result_format_start = nsecs();
+    size_t longest = sormlv(csv);
+    char *field;
+    /*
+    sormstrn(1)
+    Execute 3.77s, Format: 36.40s
+    Memory usage: 6 MB, 96.055 (re)allocated, 96.024 unqiue freed, 2 in use.
+    sormstrn(longest);
+    Execute 3.27s, Format: 36.61s
+    Memory usage: 6 MB, 96.053 (re)allocated, 96.024 unqiue freed, 2 in use.
+    sormstrn(longest * 2);
+    xecute 3.42s, Format: 37.33s
+    Memory usage: 6 MB, 96.052 (re)allocated, 96.024 unqiue freed, 2 in use.
+    sormstrn(512);
+    Execute 3.11s, Format: 36.45s
+    Memory usage: 6 MB, 96.048 (re)allocated, 96.024 unqiue freed, 2 in use.
+    */
+    sormstr_t *str = sormstrn(longest + 2);
+    while (*csv && (field = sormcsvn(csv))) {
+        sormstra(str, field);
+        for (int i = 0; i < longest - strlen(field); i++)
+            sormstra(str, " ");
+
+        csv += strlen(field);
+        while (*csv == ';' || *csv == '\n') {
+            if (*csv == '\n')
+                sormstra(str, "\n");
+            csv++;
+        }
+        free(field);
+    }
+    _sorm_result_format_end = nsecs();
+    _sorm_result_format_duration = _sorm_result_format_end - _sorm_result_format_start;
+    return sormstrc(str);
+}
+
+void apply_colors(char *csv) {
+    char *end;
+
+    bool even = false;
+    while (*csv) {
+        printf("%s\n", csv);
+        end = strstr(csv, "\n");
+        char *line;
+        if (end) {
+            line = (char *)malloc(end - csv + 1024);
+            strncpy(line, csv, end - csv);
+        } else {
+            line = (char *)malloc(strlen(csv) + 1024);
+            strcpy(line, csv);
+        }
+        if (even) {
+            printf("%s", "\033[37m");
+        }
+        printf("%s\n", line);
+        free(line);
+        if (even) {
+            printf("%s", "\033[0m");
+        }
+        even = !even;
+        csv += end - csv;
+
+        if (*csv && *(csv + 1))
+            csv++;
+    }
+}
+
+void sormfmtd(char *csv) {
+    char *formatted = sormfmt(csv);
+    printf("%s\n", formatted);
+    free(formatted);
+}
+
+#endif
+
+
diff --git a/tikker b/tikker
new file mode 100755
index 0000000000000000000000000000000000000000..bae5334a79087e6e772eb751c462236fcb957988
GIT binary patch
literal 229432
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
P|7Io7+gcNDUAq4TWKW<h

literal 0
HcmV?d00001

diff --git a/tikker.c b/tikker.c
new file mode 100644
index 0000000..358647f
--- /dev/null
+++ b/tikker.c
@@ -0,0 +1,113 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <linux/input.h>
+#include <sys/ioctl.h>
+#include "sormc.h"
+
+#define MAX_DEVICES 32
+#define DEVICE_PATH "/dev/input/event"
+ 
+
+int is_keyboard(int fd) {
+    char device_name[256] = {0};
+    
+    if (ioctl(fd, EVIOCGNAME(sizeof(device_name)), device_name) < 0) {
+        return 0;
+    }
+
+    return strstr(device_name, "keyboard") != NULL;
+}
+
+int main() {
+
+
+    db = sormc("tikker.db");
+
+    sormq(db,"CREATE TABLE IF NOT EXISTS kevent (id INTEGER PRIMARY KEY AUTOINCREMENT, code,event,name,timestamp)");
+    
+    int keyboard_fds[MAX_DEVICES];
+    int num_keyboards = 0;
+    
+    for (int i = 0; i < MAX_DEVICES; i++) {
+        char device_path[32];
+        snprintf(device_path, sizeof(device_path), "%s%d", DEVICE_PATH, i);
+        
+        int fd = open(device_path, O_RDONLY);
+        if (fd < 0) {
+            continue;
+        }
+        
+        if (is_keyboard(fd)) {
+            keyboard_fds[num_keyboards++] = fd;
+            printf("Found keyboard: %s\n", device_path);
+        } else {
+            close(fd);
+        }
+    }
+
+    if (num_keyboards == 0) {
+        fprintf(stderr, "No keyboard found.\n");
+        return 1;
+    }
+
+    printf("Monitoring %d keyboards.\n", num_keyboards);
+
+    struct input_event ev;
+    fd_set read_fds;
+    
+    while (1) {
+        FD_ZERO(&read_fds);
+        int max_fd = -1;
+        
+        for (int i = 0; i < num_keyboards; i++) {
+            FD_SET(keyboard_fds[i], &read_fds);
+            if (keyboard_fds[i] > max_fd) {
+                max_fd = keyboard_fds[i];
+            }
+        }
+
+        if (select(max_fd + 1, &read_fds, NULL, NULL, NULL) < 0) {
+            perror("select error");
+            break;
+        }
+
+        for (int i = 0; i < num_keyboards; i++) {
+            if (FD_ISSET(keyboard_fds[i], &read_fds)) {
+                ssize_t bytes = read(keyboard_fds[i], &ev, sizeof(struct input_event));
+                
+                if (bytes == sizeof(struct input_event)) {
+                    if (ev.type == EV_KEY) {
+                        char key_name[256];
+                        ioctl(keyboard_fds[i], EVIOCGNAME(sizeof(key_name)), key_name);
+                        
+                        printf("Keyboard: %s, ", key_name);
+                        char * event_name = NULL;
+                        if(ev.value == 1){
+                            event_name = "PRESSED";
+                        }else if(ev.value == 0){
+                            event_name = "RELEASED";
+                        }else {
+                            event_name = "REPEATED";
+                        }
+
+                        sormq(db, "INSERT INTO kevent (code, event, name,timestamp) VALUES (%d, %s, %s, DATETIME('now'))",ev.code,event_name,key_name);
+                        printf("Event: %s, ", 
+                            ev.value == 1 ? "PRESSED" : 
+                            ev.value == 0 ? "RELEASED" : "REPEATED");
+                        printf("Key Code: %d\n", ev.code);
+                    }
+                }
+            }
+        }
+    }
+
+    // Cleanup
+    for (int i = 0; i < num_keyboards; i++) {
+        close(keyboard_fds[i]);
+    }
+
+    return 0;
+}