nomen-lang 0.0.6 → 0.0.7

package/test/fixtures/build/calc.test.c

@@ -0,0 +1,969 @@
+typedef struct { void* ptr; long len; } nomen_view;
+#pragma STDC FP_CONTRACT OFF
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "main.h"
+
+typedef struct Console
+{
+void *_vt;
+} Console;
+typedef struct Time
+{
+void *_vt;
+} Time;
+typedef struct Tester
+{
+void *_vt;
+unsigned char has_failed;
+long passed;
+long failed;
+long total_failed;
+char* current;
+unsigned long long started;
+unsigned char bench_pending;
+char* bench_label;
+long bench_samples;
+} Tester;
+typedef struct Math
+{
+void *_vt;
+} Math;
+typedef struct Buffer_int
+{
+void *_vt;
+unsigned long long data;
+long cap;
+} Buffer_int;
+typedef struct List_int
+{
+void *_vt;
+long length;
+struct Buffer_int items;
+} List_int;
+// Trait Stringable
+typedef struct Stringable
+{
+} Stringable;
+char* Stringable_to_string(struct Stringable *self)
+{
+struct Stringable _self = *self;
+char* _return_val = strdup("");
+return _return_val;
+;
+}
+
+// Trait Disposable
+typedef struct Disposable
+{
+} Disposable;
+void Disposable_dispose(struct Disposable *self)
+{
+struct Disposable _self = *self;
+Console_write("\nboom!");
+}
+
+// Trait Equatable
+typedef struct Equatable
+{
+} Equatable;
+
+// Trait Hashable
+typedef struct Hashable
+{
+} Hashable;
+unsigned long Hashable_hash(struct Hashable *self)
+{
+struct Hashable _self = *self;
+long _return_val = 0L;
+return _return_val;
+;
+}
+
+// Trait Viewable
+typedef struct Viewable
+{
+} Viewable;
+
+// Struct int
+char* int_to_string(long self)
+{
+int length = snprintf(NULL, 0, "%ld", self);
+char* str = malloc(length + 1);
+snprintf(str, length + 1, "%ld", self);
+return str;
+}
+long int_parse(char* s)
+{
+return atoi(s);
+}
+
+// Struct char
+char* char_to_string(char self)
+{
+int length = snprintf(NULL, 0, "%c", self);
+char* str = malloc(length + 1);
+snprintf(str, length + 1, "%c", self);
+return str;
+}
+
+// Struct bool
+char* bool_to_string(unsigned char self)
+{
+int length = snprintf(NULL, 0, "%s", self ? "true" : "false");
+char* str = malloc(length + 1);
+snprintf(str, length + 1, "%s", self ? "true" : "false");
+return str;
+}
+
+// Struct string
+char* string_to_string(char* self)
+{
+return strdup(self);
+}
+char string_at(char* self, long index)
+{
+return self[index];
+}
+nomen_view string_slice(char* self, long start, long end)
+{
+nomen_view _r;
+_r.ptr = (void*)(self + start);
+_r.len = (long)(end - start);
+return _r;
+}
+void string_set(char* *self, long index, char value)
+{
+(*self)[index] = value;
+}
+unsigned char string_eq(char* self, char* other)
+{
+return strcmp(self, other) == 0;
+}
+char* string_add(char* self, char* other)
+{
+int left_len = strlen(self);
+int right_len = strlen(other);
+char* result = malloc(left_len + right_len + 1);
+strcpy(result, self);
+strcat(result, other);
+return result;
+}
+char* string_mul(char* self, long count)
+{
+size_t str_len = strlen(self);
+size_t total = str_len * (size_t)count + 1;
+char* buf = malloc(total);
+char* p = buf;
+for (int i = 0; i < count; i++) {
+memcpy(p, self, str_len);
+p += str_len;
+}
+*p = 0;
+return buf;
+}
+
+// Struct Console
+struct Console Console_init()
+{
+struct Console _self;
+return _self;
+}
+void Console_write(char* line)
+{
+printf("%s", line);
+}
+void Console_write_line(char* line)
+{
+printf("%s\n", line);
+}
+char* Console_read_line()
+{
+int cap = 16;
+int len = 0;
+char *buf = (char*)malloc(cap);
+int c = getchar();
+while (c != EOF && c != '\n') {
+if (len + 2 > cap) {
+cap *= 2;
+buf = (char*)realloc(buf, cap);
+}
+buf[len++] = (char)c;
+c = getchar();
+}
+buf[len] = 0;
+return buf;
+char* _return_val = strdup("");
+return _return_val;
+;
+}
+char Console_read_char()
+{
+return (char)getchar();
+}
+char* Console_platform()
+{
+return strdup("macos");
+char* _return_val = strdup("");
+return _return_val;
+;
+}
+
+// Struct uint
+char* uint_to_string(unsigned long self)
+{
+int length = snprintf(NULL, 0, "%ld", self);
+char* str = malloc(length + 1);
+snprintf(str, length + 1, "%ld", self);
+return str;
+}
+
+// Struct int8
+char* int8_to_string(char self)
+{
+int length = snprintf(NULL, 0, "%d", self);
+char* str = malloc(length + 1);
+snprintf(str, length + 1, "%d", self);
+return str;
+}
+
+// Struct uint8
+char* uint8_to_string(unsigned char self)
+{
+int length = snprintf(NULL, 0, "%d", self);
+char* str = malloc(length + 1);
+snprintf(str, length + 1, "%d", self);
+return str;
+}
+
+// Struct float
+char* float_to_string(double self)
+{
+int length = snprintf(NULL, 0, "%f", self);
+char* str = malloc(length + 1);
+snprintf(str, length + 1, "%f", self);
+return str;
+}
+
+// Struct uint64
+char* uint64_to_string(unsigned long long self)
+{
+int length = snprintf(NULL, 0, "%llu", self);
+char* str = malloc(length + 1);
+snprintf(str, length + 1, "%llu", self);
+return str;
+}
+
+// Struct Time
+struct Time Time_init()
+{
+struct Time _self;
+return _self;
+}
+unsigned long long Time_now_ms()
+{
+struct timespec ts;
+clock_gettime(CLOCK_REALTIME, &ts);
+return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
+unsigned long long _return_val = 0L;
+return _return_val;
+;
+}
+unsigned long long Time_now_ns()
+{
+struct timespec ts;
+clock_gettime(CLOCK_REALTIME, &ts);
+return (uint64_t)ts.tv_sec * 1000000000 + (uint64_t)ts.tv_nsec;
+unsigned long long _return_val = 0L;
+return _return_val;
+;
+}
+unsigned long long Time_now_unix()
+{
+return (uint64_t)time(NULL);
+}
+void Time_sleep_ms(unsigned long long ms)
+{
+struct timespec ts;
+ts.tv_sec = ms / 1000;
+ts.tv_nsec = (long)(ms % 1000) * 1000000;
+nanosleep(&ts, NULL);
+}
+
+// Struct int64
+char* int64_to_string(long long self)
+{
+int length = snprintf(NULL, 0, "%lld", self);
+char* str = malloc(length + 1);
+snprintf(str, length + 1, "%lld", self);
+return str;
+}
+
+// Struct Tester
+struct Tester* Tester_init()
+{
+struct Tester* _self = malloc(sizeof(struct Tester));
+_self->has_failed = 0;
+_self->passed = 0L;
+_self->failed = 0L;
+_self->total_failed = 0L;
+_self->current = "";
+_self->started = 0L;
+_self->bench_pending = 0;
+_self->bench_label = "";
+_self->bench_samples = 1000L;
+return _self;
+}
+void Tester_begin_test(struct Tester *self, char* name)
+{
+self->has_failed = 0;
+self->passed = 0L;
+self->failed = 0L;
+self->current = name;
+char* _param_6 = string_add("\\nomen|start|", name);
+Console_write_line(_param_6);
+self->started = Time_now_ns();
+
+// Auto-free
+free(_param_6);
+}
+void Tester_end_test(struct Tester *self)
+{
+unsigned long long elapsed = (Time_now_ns() - self->started);
+char* _param_7 = int_to_string(self->passed);
+char* _param_8 = int_to_string(self->failed);
+char* _param_9 = uint64_to_string(elapsed);
+char* _param_10 = ({ char* _ltmp_1 = string_add("\\nomen|done|", self->current); char* _rtmp_1 = _string_interpolate_3("|%s|%s|%s", _param_7, _param_8, _param_9); char* _cres_1 = string_add(_ltmp_1, _rtmp_1); free(_ltmp_1); free(_rtmp_1); _cres_1; });
+Console_write_line(_param_10);
+
+// Auto-free
+free(_param_7);
+free(_param_8);
+free(_param_9);
+free(_param_10);
+}
+unsigned char Tester_any_failed(struct Tester *self)
+{
+struct Tester _self = *self;
+unsigned char _return_val = (self->total_failed > 0L);
+return _return_val;
+;
+}
+void Tester_expect(struct Tester *self, unsigned char condition, char* message)
+{
+if (self->has_failed) {
+return;
+;
+}
+if (condition) {
+self->passed += 1L;
+return;
+;
+}
+Tester_record_failure(self, message);
+}
+void Tester_fail(struct Tester *self, char* message)
+{
+if (self->has_failed) {
+return;
+;
+}
+Tester_record_failure(self, message);
+}
+void Tester_assert_int_string(struct Tester *self, long value, char* message)
+{
+unsigned char _param_11 = (value != 0);
+Tester_expect(self, _param_11, message);
+}
+void Tester_assert_uint_string(struct Tester *self, unsigned long value, char* message)
+{
+unsigned char _param_12 = (value != 0);
+Tester_expect(self, _param_12, message);
+}
+void Tester_assert_int64_string(struct Tester *self, long long value, char* message)
+{
+unsigned char _param_13 = (value != 0);
+Tester_expect(self, _param_13, message);
+}
+void Tester_assert_uint64_string(struct Tester *self, unsigned long long value, char* message)
+{
+unsigned char _param_14 = (value != 0);
+Tester_expect(self, _param_14, message);
+}
+void Tester_assert_int8_string(struct Tester *self, char value, char* message)
+{
+unsigned char _param_15 = (value != 0);
+Tester_expect(self, _param_15, message);
+}
+void Tester_assert_uint8_string(struct Tester *self, unsigned char value, char* message)
+{
+unsigned char _param_16 = (value != 0);
+Tester_expect(self, _param_16, message);
+}
+void Tester_assert_float_string(struct Tester *self, double value, char* message)
+{
+unsigned char _param_17 = (value != 0);
+Tester_expect(self, _param_17, message);
+}
+void Tester_assert_bool_string(struct Tester *self, unsigned char value, char* message)
+{
+unsigned char _param_18 = (value != 0);
+Tester_expect(self, _param_18, message);
+}
+void Tester_assert_char_string(struct Tester *self, char value, char* message)
+{
+unsigned char _param_19 = (value != 0);
+Tester_expect(self, _param_19, message);
+}
+void Tester_assert_string_string(struct Tester *self, char* value, char* message)
+{
+unsigned char _param_20 = (value != 0);
+Tester_expect(self, _param_20, message);
+}
+void Tester_bench(struct Tester *self, char* label, void* body)
+{
+if (self->has_failed) {
+return;
+;
+}
+self->bench_pending = 1;
+self->bench_label = label;
+self->bench_samples = 1000L;
+}
+void Tester_bench_n(struct Tester *self, char* label, void* body, long samples)
+{
+if (self->has_failed) {
+return;
+;
+}
+self->bench_pending = 1;
+self->bench_label = label;
+self->bench_samples = samples;
+}
+void Tester_record_bench(struct Tester *self, char* label, long n, long min, long median, long max, double mean, double stddev)
+{
+if (self->has_failed) {
+return;
+;
+}
+char* _param_21 = int_to_string(n);
+char* _param_22 = int_to_string(min);
+char* _param_23 = int_to_string(median);
+char* _param_24 = int_to_string(max);
+char* _param_25 = float_to_string(mean);
+char* _param_26 = float_to_string(stddev);
+char* _param_27 = ({ char* _ltmp_2 = string_add("\\nomen|bench|", label); char* _rtmp_2 = _string_interpolate_6("|%s|%s|%s|%s|%s|%s", _param_21, _param_22, _param_23, _param_24, _param_25, _param_26); char* _cres_2 = string_add(_ltmp_2, _rtmp_2); free(_ltmp_2); free(_rtmp_2); _cres_2; });
+Console_write_line(_param_27);
+
+// Auto-free
+free(_param_21);
+free(_param_22);
+free(_param_23);
+free(_param_24);
+free(_param_25);
+free(_param_26);
+free(_param_27);
+}
+void Tester_record_failure(struct Tester *self, char* message)
+{
+self->failed += 1L;
+self->total_failed += 1L;
+self->has_failed = 1;
+char* _param_28 = ({ char* _ltmp_3 = ({ char* _ltmp_4 = string_add("\\nomen|fail|", self->current); char* _rtmp_4 = "|"; char* _cres_4 = string_add(_ltmp_4, _rtmp_4); free(_ltmp_4); _cres_4; }); char* _rtmp_3 = message; char* _cres_3 = string_add(_ltmp_3, _rtmp_3); free(_ltmp_3); _cres_3; });
+Console_write_line(_param_28);
+
+// Auto-free
+free(_param_28);
+}
+void Tester_destroy(struct Tester *self)
+{
+}
+
+// Struct Math
+struct Math Math_init()
+{
+struct Math _self;
+return _self;
+}
+long Math_power(long base, long exp)
+{
+int result = 1;
+for (int i = 0; i < exp; i++) {
+result *= base;
+}
+return result;
+}
+double Math_sqrt(double x)
+{
+return sqrt(x);
+}
+double Math_log(double x)
+{
+return log(x);
+}
+
+// Struct Buffer_int
+struct Buffer_int Buffer_int_init()
+{
+struct Buffer_int _self;
+_self.data = 0L;
+_self.cap = 0L;
+return _self;
+}
+long Buffer_int_alloc(struct Buffer_int *self, long size)
+{
+self->cap = size;
+self->data = (unsigned long long)(unsigned int*)calloc(size, sizeof(unsigned int));
+return self->cap;
+}
+long Buffer_int_grow(struct Buffer_int *self, long needed)
+{
+if (self->cap >= needed) return self->cap;
+int new_cap = self->cap;
+if (new_cap == 0) new_cap = 8;
+while (new_cap < needed) new_cap *= 2;
+self->data = (unsigned long long)(unsigned int*)realloc((unsigned int*)(unsigned long long)self->data, new_cap * sizeof(unsigned int));
+memset((unsigned int*)(unsigned long long)self->data + self->cap, 0, (new_cap - self->cap) * sizeof(unsigned int));
+self->cap = new_cap;
+return self->cap;
+}
+void Buffer_int_zero(struct Buffer_int *self, long len)
+{
+memset((unsigned int*)(unsigned long long)self->data, 0, len * sizeof(unsigned int));
+}
+unsigned int Buffer_int_load(struct Buffer_int *self, long i)
+{
+struct Buffer_int _self = *self;
+return ((unsigned int*)(unsigned long long)self->data)[i];
+}
+void Buffer_int_store(struct Buffer_int *self, long i, unsigned int val)
+{
+((unsigned int*)(unsigned long long)self->data)[i] = val;
+}
+void Buffer_int_store_or(struct Buffer_int *self, long i, unsigned int val)
+{
+((unsigned int*)(unsigned long long)self->data)[i] |= val;
+}
+long Buffer_int_alloc_int(struct Buffer_int *self, long size)
+{
+self->cap = size;
+self->data = (unsigned long long)(long*)calloc(size, sizeof(long));
+return self->cap;
+}
+long Buffer_int_grow_int(struct Buffer_int *self, long needed)
+{
+if (self->cap >= needed) return self->cap;
+int new_cap = self->cap;
+if (new_cap == 0) new_cap = 4;
+while (new_cap < needed) new_cap *= 2;
+self->data = (unsigned long long)(long*)realloc((long*)(unsigned long long)self->data, new_cap * sizeof(long));
+memset((long*)(unsigned long long)self->data + self->cap, 0, (new_cap - self->cap) * sizeof(long));
+self->cap = new_cap;
+return self->cap;
+}
+long Buffer_int_load_int(struct Buffer_int *self, long i)
+{
+struct Buffer_int _self = *self;
+return ((long*)(unsigned long long)self->data)[i];
+}
+void Buffer_int_store_int(struct Buffer_int *self, long i, long val)
+{
+((long*)(unsigned long long)self->data)[i] = val;
+}
+long Buffer_int_move_int(struct Buffer_int *self, long i)
+{
+long *slots = (long*)(unsigned long long)self->data;
+long val = slots[i];
+slots[i] = 0;
+return val;
+}
+void Buffer_int_replace_int(struct Buffer_int *self, long i, long val)
+{
+((long*)(unsigned long long)self->data)[i] = val;
+}
+void Buffer_int_zero_int(struct Buffer_int *self, long len)
+{
+memset((long*)(unsigned long long)self->data, 0, len * sizeof(long));
+}
+long Buffer_int_alloc_T(struct Buffer_int *self, long size)
+{
+self->cap = size;
+self->data = (unsigned long long)(long*)calloc(size, 8);
+return self->cap;
+}
+long Buffer_int_grow_T(struct Buffer_int *self, long needed)
+{
+if (self->cap >= needed) return self->cap;
+int new_cap = self->cap;
+if (new_cap == 0) new_cap = 4;
+while (new_cap < needed) new_cap *= 2;
+self->data = (unsigned long long)(long*)realloc((long*)(unsigned long long)self->data, new_cap * 8);
+memset((char*)(unsigned long long)self->data + self->cap * 8, 0, (new_cap - self->cap) * 8);
+self->cap = new_cap;
+return self->cap;
+}
+long Buffer_int_load_T(struct Buffer_int *self, long i)
+{
+struct Buffer_int _self = *self;
+return ((long*)(unsigned long long)self->data)[i];
+}
+void Buffer_int_store_T(struct Buffer_int *self, long i, long val)
+{
+((long*)(unsigned long long)self->data)[i] = val;
+}
+nomen_view Buffer_int_slice(struct Buffer_int *self, long start, long end)
+{
+struct Buffer_int _self = *self;
+nomen_view _r;
+_r.ptr = (void*)((long*)(unsigned long long)self->data + start);
+_r.len = (long)(end - start);
+return _r;
+}
+void Buffer_int_zero_T(struct Buffer_int *self, long len)
+{
+memset((long*)(unsigned long long)self->data, 0, len * 8);
+}
+void Buffer_int_store_or_int(struct Buffer_int *self, long i, long val)
+{
+((long*)(unsigned long long)self->data)[i] |= val;
+}
+long Buffer_int_alloc_float(struct Buffer_int *self, long size)
+{
+self->cap = size;
+self->data = (unsigned long long)(double*)calloc(size, sizeof(double));
+return self->cap;
+}
+double Buffer_int_load_float(struct Buffer_int *self, long i)
+{
+struct Buffer_int _self = *self;
+return ((double*)(unsigned long long)self->data)[i];
+}
+void Buffer_int_store_float(struct Buffer_int *self, long i, double val)
+{
+((double*)(unsigned long long)self->data)[i] = val;
+}
+void Buffer_int_destroy(struct Buffer_int *self)
+{
+if (self->data) free((unsigned int*)(unsigned long long)self->data);
+self->data = 0;
+self->cap = 0;
+}
+
+// Struct List_int
+void *_List_int_Viewable_funcs[] = {};
+void *_List_int_destroy_funcs[] = {List_int_destroy};
+void *_List_int_traits[] = {&_List_int_destroy_funcs, NULL, NULL, NULL, NULL, &_List_int_Viewable_funcs};
+struct List_int List_int_init()
+{
+struct List_int _self;
+_self._vt = &_List_int_traits;
+_self.length = 0L;
+_self.items = Buffer_int_init();
+return _self;
+}
+void List_int_push(struct List_int *self, long value)
+{
+if ((self->length >= self->items.cap)) {
+long new_cap = 4L;
+long old_cap = self->items.cap;
+if ((old_cap >= 4L)) {
+new_cap = (old_cap * 2L);
+}
+Buffer_int_grow_int(&self->items, new_cap);
+}
+Buffer_int_store_int(&self->items, self->length, value);
+self->length += 1L;
+}
+long List_int_pop(struct List_int *self)
+{
+if ((self->length <= 0L)) {
+long _return_val = 0L;
+return _return_val;
+;
+}
+long idx = (self->length - 1L);
+self->length = idx;
+long _return_val = Buffer_int_move_int(&self->items, idx);
+return _return_val;
+;
+}
+long List_int_at(struct List_int *self, long i)
+{
+struct List_int _self = *self;
+long _return_val = Buffer_int_load_int(&self->items, i);
+return _return_val;
+;
+}
+nomen_view List_int_slice(struct List_int *self, long start, long end)
+{
+struct List_int _self = *self;
+nomen_view  _return_val = Buffer_int_slice(&self->items, start, end);
+return _return_val;
+;
+}
+void List_int_set(struct List_int *self, long i, long value)
+{
+long v = value;
+Buffer_int_replace_int(&self->items, i, v);
+}
+void List_int_destroy(struct List_int *self)
+{
+Buffer_int_destroy(&self->items);
+}
+
+// Func add
+long add(long a, long b)
+{
+long _return_val = (a + b);
+return _return_val;
+;
+}
+
+// Func mul
+long mul(long a, long b)
+{
+long _return_val = (a * b);
+return _return_val;
+;
+}
+
+// Func add_once
+void add_once()
+{
+long r = add(1L, 1L);
+}
+
+// Func test_add
+void test_add(struct Tester **t)
+{
+unsigned char _param_0 = (add(1L, 1L) == 2L);
+Tester_expect((*t), _param_0, "1 + 1 should be 2");
+unsigned char _param_1 = (add(2L, 3L) == 5L);
+Tester_expect((*t), _param_1, "2 + 3 should be 5");
+unsigned char _param_2 = (add(100L, 1L) == 101L);
+Tester_expect((*t), _param_2, "100 + 1 should be 101");
+}
+
+// Func test_mul
+void test_mul(struct Tester **t)
+{
+unsigned char _param_3 = (mul(2L, 2L) == 4L);
+Tester_expect((*t), _param_3, "2 * 2 should be 4");
+unsigned char _param_4 = (mul(3L, 3L) == 10L);
+Tester_expect((*t), _param_4, "3 * 3 should be 9 (this fails on purpose)");
+}
+
+// Func test_assert_not_null
+void test_assert_not_null(struct Tester **t)
+{
+long maybe = 42L;
+Tester_assert_int_string((*t), maybe, "maybe should hold a value");
+char* none = 0;
+Tester_assert_string_string((*t), none, "none should be null (this fails on purpose)");
+
+// Auto-free
+free(none);
+}
+
+// Func bench_add
+void bench_add(struct Tester **t)
+{
+Tester_bench((*t), "add", add_once);
+}
+
+// Func bench_loop_bench_add
+void bench_loop_bench_add(struct Tester **t)
+{
+long __w = 0L;
+while ((__w < 8L)) {
+add_once();
+__w += 1L;
+}
+struct List_int __samples = List_int_init();
+long __sum = 0L;
+double __sum_sq = 0.0;
+long __min = 0L;
+long __max = 0L;
+long __i = 0L;
+while ((__i < 1000L)) {
+unsigned long long __t0 = Time_now_ns();
+add_once();
+unsigned long long __t1 = Time_now_ns();
+long __dt = (long)((__t1 - __t0));
+List_int_push(&__samples, __dt);
+__sum += __dt;
+__sum_sq = (__sum_sq + (((double)__dt) * ((double)__dt)));
+if ((__i == 0L)) {
+__min = __dt;
+__max = __dt;
+}
+if ((__i > 0L)) {
+if ((__dt < __min)) {
+__min = __dt;
+}
+if ((__dt > __max)) {
+__max = __dt;
+}
+}
+__i += 1L;
+}
+long __n = __samples.length;
+if ((__n > 0L)) {
+double __fn = (double)__n;
+double __mean = (((double)__sum) / __fn);
+double __variance = ((__sum_sq / __fn) - (__mean * __mean));
+if ((__variance < 0.0)) {
+__variance = 0.0;
+}
+double __stddev = Math_sqrt(__variance);
+long __s = 1L;
+while ((__s < __n)) {
+if (((__s >= 0L) && (__s < __samples.length))) {
+long __v = List_int_at(&__samples, __s);
+long __j = __s;
+unsigned char __more = 1;
+while (__more) {
+long __pm1 = (__j - 1L);
+if (((__pm1 >= 0L) && (__pm1 < __samples.length))) {
+long __prev = List_int_at(&__samples, __pm1);
+if ((__prev > __v)) {
+if (((__j >= 0L) && (__j < __samples.length))) {
+List_int_set(&__samples, __j, __prev);
+}
+__j -= 1L;
+} else {
+__more = 0;
+}
+} else {
+__more = 0;
+}
+}
+if (((__j >= 0L) && (__j < __samples.length))) {
+List_int_set(&__samples, __j, __v);
+}
+}
+__s += 1L;
+}
+long __median = __min;
+long __hi = (__n / 2L);
+if (((__hi >= 0L) && (__hi < __samples.length))) {
+__median = List_int_at(&__samples, __hi);
+}
+if (((__n % 2L) == 0L)) {
+long __lo = ((__n / 2L) - 1L);
+if (((__lo >= 0L) && (__lo < __samples.length))) {
+if (((__hi >= 0L) && (__hi < __samples.length))) {
+long __a = List_int_at(&__samples, __lo);
+long __b = List_int_at(&__samples, __hi);
+__median = (((__a + __b)) / 2L);
+}
+}
+}
+char* _param_5 = (*t)->bench_label;
+Tester_record_bench((*t), _param_5, __n, __min, __median, __max, __mean, __stddev);
+}
+
+// Auto-free
+Buffer_int_destroy(&__samples.items);
+}
+
+// Func main
+int main()
+{
+struct Tester *t = Tester_init();
+Tester_begin_test(t, "test_add");
+test_add(&t);
+Tester_end_test(t);
+Tester_begin_test(t, "test_mul");
+test_mul(&t);
+Tester_end_test(t);
+Tester_begin_test(t, "test_assert_not_null");
+test_assert_not_null(&t);
+Tester_end_test(t);
+t->has_failed = 0;
+t->bench_pending = 0;
+bench_add(&t);
+if (t->bench_pending) {
+bench_loop_bench_add(&t);
+}
+
+// Auto-free
+Tester_destroy(t); free(t);
+return 0;
+}
+
+
+void **_get_trait_func(void **obj, int trait_index, int func_index)
+{
+    void **vt = *obj;
+    // Slot 0 of _<Struct>_traits is the destroy-funcs pointer (reserved so a
+    // trait-typed collection can dispatch destroy polymorphically). Real trait
+    // tables start at index 1, so shift trait_index by 1.
+    void **trait = *(vt + 1 + trait_index);
+    void **func = *(trait + func_index);
+    return func;
+}  
+void Stringable_destroy(void *obj)
+{
+    void **vt = *(void **)obj;
+    void **destroy_funcs = (void **)vt[0];
+    if (destroy_funcs) {
+        void (*destroy)(void *) = (void (*)(void *))*destroy_funcs;
+        if (destroy) destroy(obj);
+    }
+}
+void Disposable_destroy(void *obj)
+{
+    void **vt = *(void **)obj;
+    void **destroy_funcs = (void **)vt[0];
+    if (destroy_funcs) {
+        void (*destroy)(void *) = (void (*)(void *))*destroy_funcs;
+        if (destroy) destroy(obj);
+    }
+}
+void Equatable_destroy(void *obj)
+{
+    void **vt = *(void **)obj;
+    void **destroy_funcs = (void **)vt[0];
+    if (destroy_funcs) {
+        void (*destroy)(void *) = (void (*)(void *))*destroy_funcs;
+        if (destroy) destroy(obj);
+    }
+}
+void Hashable_destroy(void *obj)
+{
+    void **vt = *(void **)obj;
+    void **destroy_funcs = (void **)vt[0];
+    if (destroy_funcs) {
+        void (*destroy)(void *) = (void (*)(void *))*destroy_funcs;
+        if (destroy) destroy(obj);
+    }
+}
+void Viewable_destroy(void *obj)
+{
+    void **vt = *(void **)obj;
+    void **destroy_funcs = (void **)vt[0];
+    if (destroy_funcs) {
+        void (*destroy)(void *) = (void (*)(void *))*destroy_funcs;
+        if (destroy) destroy(obj);
+    }
+}
+char *_string_interpolate_3(char *pattern, char *arg1, char *arg2, char *arg3)
+{
+    int length = snprintf(NULL, 0, pattern, arg1, arg2, arg3);
+    char *str = malloc(length + 1);
+    snprintf(str, length + 1, pattern, arg1, arg2, arg3);
+    return str;
+}
+char *_string_interpolate_6(char *pattern, char *arg1, char *arg2, char *arg3, char *arg4, char *arg5, char *arg6)
+{
+    int length = snprintf(NULL, 0, pattern, arg1, arg2, arg3, arg4, arg5, arg6);
+    char *str = malloc(length + 1);
+    snprintf(str, length + 1, pattern, arg1, arg2, arg3, arg4, arg5, arg6);
+    return str;
+}