upd

genstd.py

@@ -0,0 +1,30 @@
+import os
+
+QIC = os.getenv("QIC", "qic")
+
+os.system(f"{QIC} -p qistd std.qi -o std.c")
+
+with open("std.c", "r") as f:
+  lines = f.readlines()
+  lines = map(lambda l: l.strip(), lines)
+  lines = filter(lambda l: len(l) > 0, lines)
+  lines = list(lines)
+
+os.remove("std.c")
+
+main_pos = lines.index("int main(int argc, char **argv) {")
+args_pos = lines.index("qi_decl_const(state, \"ARGS\", qi_make_list(state, args));")
+fin_pos = lines.index("qi_finalize();")
+
+decls = lines[1:main_pos]
+init = lines[args_pos+1:fin_pos-1]
+
+output = []
+output.extend(decls)
+output.append("static void qi_init_std(qi_state_t *state) {")
+output.extend(init)
+output.append("}")
+
+with open("qistd.c", "w") as f:
+  f.write("\n".join(output))
+  

qirt.c

@@ -1250,7 +1250,7 @@ void qi_fatal(qi_state_t *state, char *format, ...) {
   } else
     fputs("Runtime error: ", stderr);
   vfprintf(stderr, format, args);
-  fputs(".\n", stderr);
+  fputc('\n', stderr);
 
   va_end(args);
 
@@ -3977,6 +3977,8 @@ qi_value_t *qi_pseudomethod_file_rewind(qi_state_t *state, qi_size_t pargc,
   return qi_builtin_fseek(state, 3, new_pargs);
 }
 
+#include "qistd.c"
+
 static void qi_state_setup(qi_state_t *state) {
   QI_HASH_SEED = time(NULL);
 
@@ -4140,6 +4142,8 @@ static void qi_state_setup(qi_state_t *state) {
   qi_add_pseudomethod(state, "function.call", 1, qi_pseudomethod_func_call);
 
   state->_debug_data = NULL;
+
+  qi_init_std(state);
 }
 
 static void _qi_state_init(qi_state_t **state, bool enable_debug) {

qistd.c

@@ -0,0 +1,2643 @@
+qi_value_t *__qistd0(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "l", qi_list_index(pargs, 0));
+return qi_index(state, qi_get(state, "l"), qi_make_number(state, 0));return state->nil;
+}
+inline static qi_list_t *__qistd2(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "l");
+qi_list_data(list, 1) = qi_make_number(state, 1);
+return list;
+}
+qi_value_t *__qistd1(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "l", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "slice"), __qistd2(state));return state->nil;
+}
+qi_value_t *__qistd3(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "x", qi_list_index(pargs, 0));
+qi_decl(state, "y", qi_list_index(pargs, 1));
+return (_qi_truthy(state, qi_lt(state, qi_get(state, "x"), qi_get(state, "y")))? qi_get(state, "x"): qi_get(state, "y"));return state->nil;
+}
+qi_value_t *__qistd4(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "x", qi_list_index(pargs, 0));
+qi_decl(state, "y", qi_list_index(pargs, 1));
+return (_qi_truthy(state, qi_gt(state, qi_get(state, "x"), qi_get(state, "y")))? qi_get(state, "x"): qi_get(state, "y"));return state->nil;
+}
+inline static qi_list_t *__qistd6(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd7(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(3);
+qi_list_data(list, 0) = qi_make_string(state, "list");
+qi_list_data(list, 1) = qi_make_string(state, "string");
+qi_list_data(list, 2) = qi_make_string(state, "bytes");
+return list;
+}
+inline static qi_list_t *__qistd8(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd10(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd11(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_index(state, qi_get(state, "x"), qi_get(state, "i"));
+return list;
+}
+inline static qi_list_t *__qistd12(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd13(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+inline static qi_list_t *__qistd14(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd15(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+qi_value_t *__qistd5(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "x", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_in(state, qi_call(state, qi_get(state, "type"), __qistd6(state)), qi_make_tuple(state, __qistd7(state))))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: list, string or bytes, but got: "), qi_call(state, qi_get(state, "type"), __qistd8(state))));}
+qi_decl(state, "r", qi_make_list(state, NULL));
+qi_decl(state, "i", qi_sub(state, qi_call(state, qi_get(state, "len"), __qistd10(state)), qi_make_number(state, 1)));
+while (_qi_truthy(state, qi_ge(state, qi_get(state, "i"), qi_make_number(state, 0)))) {
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd11(state)));__continue9:;
+qi_set(state, false, "i", qi_sub(state, qi_get(state, "i"), state->one));
+}
+__break9:;
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd12(state)), qi_make_string(state, "string")))) {
+return qi_call(state, qi_get(state, "list_join"), __qistd13(state));} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd14(state)), qi_make_string(state, "bytes")))) {
+return qi_call(state, qi_get(state, "bytes"), __qistd15(state));}}
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd17(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "arguments");
+return list;
+}
+inline static qi_list_t *__qistd18(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "arguments");
+return list;
+}
+inline static qi_list_t *__qistd19(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd20(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd21(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd22(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd23(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd24(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd26(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(3);
+qi_list_data(list, 0) = qi_get(state, "t");
+qi_list_data(list, 1) = qi_get(state, "f");
+qi_list_data(list, 2) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd25(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_call(state, qi_get(state, "range"), __qistd26(state));
+return list;
+}
+inline static qi_list_t *__qistd28(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_get(state, "i");
+return list;
+}
+qi_value_t *__qistd16(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 0));
+qi_decl(state, "s", state->nil);
+qi_decl(state, "t", state->nil);
+if (_qi_truthy(state, qi_ge(state, qi_call(state, qi_get(state, "len"), __qistd17(state)), qi_make_number(state, 3)))) {
+(void)(qi_set(state, false, "t", qi_index(state, qi_get(state, "arguments"), qi_make_number(state, 1))));
+(void)(qi_set(state, false, "s", qi_index(state, qi_get(state, "arguments"), qi_make_number(state, 2))));
+} else {
+if (_qi_truthy(state, qi_ge(state, qi_call(state, qi_get(state, "len"), __qistd18(state)), qi_make_number(state, 2)))) {
+(void)(qi_set(state, false, "t", qi_index(state, qi_get(state, "arguments"), qi_make_number(state, 1))));
+(void)(qi_set(state, false, "s", qi_make_number(state, 1)));
+} else {
+(void)(qi_set(state, false, "t", qi_get(state, "f")));
+(void)(qi_set(state, false, "f", qi_make_number(state, 0)));
+(void)(qi_set(state, false, "s", qi_make_number(state, 1)));
+}}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd19(state)), qi_make_string(state, "number")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: number, but got: "), qi_call(state, qi_get(state, "type"), __qistd20(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd21(state)), qi_make_string(state, "number")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: number, but got: "), qi_call(state, qi_get(state, "type"), __qistd22(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd23(state)), qi_make_string(state, "number")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected third argument to be: number, but got: "), qi_call(state, qi_get(state, "type"), __qistd24(state))));}
+if (_qi_truthy(state, qi_gt(state, qi_get(state, "f"), qi_get(state, "t")))) {
+return qi_call(state, qi_get(state, "reverse"), __qistd25(state));}
+qi_decl(state, "r", qi_make_list(state, NULL));
+qi_decl(state, "i", qi_get(state, "f"));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_get(state, "t")))) {
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd28(state)));__continue27:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), qi_get(state, "s")));
+}
+__break27:;
+return qi_get(state, "r");
+return state->nil;
+}
+qi_value_t *__qistd29(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "file", qi_list_index(pargs, 0));
+return qi_call(state, qi_index(state, qi_get(state, "file"), qi_make_string(state, "rewind")), NULL);return state->nil;
+}
+inline static qi_list_t *__qistd31(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "filename");
+qi_list_data(list, 1) = qi_make_string(state, "r");
+return list;
+}
+inline static qi_list_t *__qistd33(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "file");
+return list;
+}
+void __qistd32(qi_state_t *state) {
+(void)(qi_call(state, qi_get(state, "fclose"), __qistd33(state)));
+}
+inline static qi_list_t *__qistd35(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "file");
+qi_list_data(list, 1) = qi_negate(state, qi_make_number(state, 1));
+return list;
+}
+inline static qi_list_t *__qistd34(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_call(state, qi_get(state, "fread"), __qistd35(state));
+return list;
+}
+qi_value_t *__qistd30(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "filename", qi_list_index(pargs, 0));
+qi_decl_const(state, "file", qi_call(state, qi_get(state, "fopen"), __qistd31(state)));
+qi_add_defer(state, -1, __qistd32);
+return qi_call(state, qi_get(state, "str"), __qistd34(state));
+return state->nil;
+}
+inline static qi_list_t *__qistd37(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "filename");
+qi_list_data(list, 1) = qi_make_string(state, "w");
+return list;
+}
+inline static qi_list_t *__qistd39(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "file");
+return list;
+}
+void __qistd38(qi_state_t *state) {
+(void)(qi_call(state, qi_get(state, "fclose"), __qistd39(state)));
+}
+inline static qi_list_t *__qistd41(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "data");
+return list;
+}
+inline static qi_list_t *__qistd40(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "file");
+qi_list_data(list, 1) = qi_call(state, qi_get(state, "bytes"), __qistd41(state));
+return list;
+}
+qi_value_t *__qistd36(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "filename", qi_list_index(pargs, 0));
+qi_decl(state, "data", qi_list_index(pargs, 1));
+qi_decl_const(state, "file", qi_call(state, qi_get(state, "fopen"), __qistd37(state)));
+qi_add_defer(state, -1, __qistd38);
+(void)(qi_call(state, qi_get(state, "fwrite"), __qistd40(state)));
+return state->nil;
+}
+inline static qi_list_t *__qistd43(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "name");
+return list;
+}
+inline static qi_list_t *__qistd44(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "name");
+return list;
+}
+qi_value_t *__qistd42(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "name", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd43(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd44(state))));}
+bool b = qi_find(state, qi_get(state, "name")->value.string) != NULL;
+return qi_make_boolean(state, b);
+return state->nil;
+}
+inline static qi_list_t *__qistd47(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd48(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd50(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd51(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "l");
+qi_list_data(list, 1) = qi_get(state, "i");
+return list;
+}
+qi_value_t *__qistd45(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "first", pargc >= 3? qi_list_index(pargs, 2): qi_get(state, "false"));
+qi_decl(state, "l", qi_list_index(pargs, 0));
+qi_decl(state, "x", qi_list_index(pargs, 1));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd47(state)), qi_make_string(state, "list")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: list, but got: "), qi_call(state, qi_get(state, "type"), __qistd48(state))));}
+__label46:;
+qi_decl(state, "i", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd50(state))))) {
+if (_qi_truthy(state, qi_equals(state, qi_index(state, qi_get(state, "l"), qi_get(state, "i")), qi_get(state, "x")))) {
+(void)(qi_call(state, qi_get(state, "list_delete"), __qistd51(state)));
+if (_qi_truthy(state, qi_get(state, "first"))) {
+goto __break49;}
+goto __label46;
+}__continue49:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break49:;
+return state->nil;
+}
+inline static qi_list_t *__qistd53(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd54(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd55(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "arguments");
+return list;
+}
+inline static qi_list_t *__qistd56(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd57(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd60(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd61(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "x");
+return list;
+}
+qi_value_t *__qistd52(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "l", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd53(state)), qi_make_string(state, "list")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: list, but got: "), qi_call(state, qi_get(state, "type"), __qistd54(state))));}
+qi_decl(state, "r", state->empty_string);
+qi_decl(state, "s", state->nil);
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd55(state)), qi_make_number(state, 1)))) {
+(void)(qi_set(state, false, "s", state->empty_string));} else {
+(void)(qi_set(state, false, "s", qi_index(state, qi_get(state, "arguments"), qi_make_number(state, 1))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd56(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd57(state))));}
+qi_decl(state, "first", qi_get(state, "true"));
+qi_value_t *__qistd59 = qi_iter(state, qi_get(state, "l"));
+qi_decl(state, "x", state->nil);
+for (qi_size_t length = _qi_length(state, __qistd59), i = 0; i < length; i++) {
+qi_set(state, false, "x", qi_index(state, __qistd59, qi_make_number(state, i)));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd60(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected sequence item to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd61(state))));}
+if (_qi_truthy(state, qi_and(state, qi_not_equals(state, qi_get(state, "s"), state->empty_string), qi_not(state, qi_get(state, "first"))))) {
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_get(state, "s"))));}
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_get(state, "x"))));
+(void)(qi_set(state, false, "first", qi_get(state, "false")));
+__continue58:;
+}
+__break58:;
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd63(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd64(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd65(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "i");
+return list;
+}
+inline static qi_list_t *__qistd66(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "i");
+return list;
+}
+inline static qi_list_t *__qistd67(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "l");
+qi_list_data(list, 1) = qi_get(state, "i");
+return list;
+}
+qi_value_t *__qistd62(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "i", qi_list_index(pargs, 1));
+qi_decl(state, "l", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd63(state)), qi_make_string(state, "list")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: list, but got: "), qi_call(state, qi_get(state, "type"), __qistd64(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd65(state)), qi_make_string(state, "number")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: number, but got: "), qi_call(state, qi_get(state, "type"), __qistd66(state))));}
+qi_decl(state, "x", qi_index(state, qi_get(state, "l"), qi_get(state, "i")));
+(void)(qi_call(state, qi_get(state, "list_delete"), __qistd67(state)));
+return qi_get(state, "x");
+return state->nil;
+}
+qi_value_t *__qistd69(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "x", qi_list_index(pargs, 0));
+qi_decl(state, "y", qi_list_index(pargs, 1));
+return qi_gt(state, qi_get(state, "x"), qi_get(state, "y"));return state->nil;
+}
+inline static qi_list_t *__qistd70(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd71(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd72(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "cmp");
+return list;
+}
+inline static qi_list_t *__qistd73(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "cmp");
+return list;
+}
+inline static qi_list_t *__qistd74(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd75(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd78(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_index(state, qi_get(state, "l"), qi_get(state, "j"));
+qi_list_data(list, 1) = qi_index(state, qi_get(state, "l"), qi_add(state, qi_get(state, "j"), qi_make_number(state, 1)));
+return list;
+}
+qi_value_t *__qistd68(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "cmp", pargc >= 2? qi_list_index(pargs, 1): qi_make_function(state, "<anon>", 2, __qistd69, NULL));
+qi_decl(state, "l", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd70(state)), qi_make_string(state, "list")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: list, but got: "), qi_call(state, qi_get(state, "type"), __qistd71(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd72(state)), qi_make_string(state, "function")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: function, but got: "), qi_call(state, qi_get(state, "type"), __qistd73(state))));}
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd74(state)), qi_make_number(state, 0)))) {
+return qi_get(state, "l");}
+qi_decl(state, "z", qi_call(state, qi_get(state, "len"), __qistd75(state)));
+qi_decl(state, "i", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_sub(state, qi_get(state, "z"), qi_make_number(state, 1))))) {
+qi_decl(state, "j", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "j"), qi_sub(state, qi_sub(state, qi_get(state, "z"), qi_make_number(state, 1)), qi_get(state, "i"))))) {
+if (_qi_truthy(state, qi_call(state, qi_get(state, "cmp"), __qistd78(state)))) {
+qi_decl_const(state, "tmp", qi_index(state, qi_get(state, "l"), qi_get(state, "j")));
+(void)(qi_index_set(state, false, qi_get(state, "l"), qi_get(state, "j"), qi_index(state, qi_get(state, "l"), qi_add(state, qi_get(state, "j"), qi_make_number(state, 1)))));
+(void)(qi_index_set(state, false, qi_get(state, "l"), qi_add(state, qi_get(state, "j"), qi_make_number(state, 1)), qi_get(state, "tmp")));
+}__continue77:;
+qi_set(state, false, "j", qi_add(state, qi_get(state, "j"), state->one));
+}
+__break77:;
+__continue76:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break76:;
+return qi_get(state, "l");
+return state->nil;
+}
+qi_value_t *__qistd80(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "x", qi_list_index(pargs, 0));
+qi_decl(state, "y", qi_list_index(pargs, 1));
+return qi_gt(state, qi_get(state, "x"), qi_get(state, "y"));return state->nil;
+}
+inline static qi_list_t *__qistd81(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd82(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "l");
+qi_list_data(list, 1) = qi_get(state, "cmp");
+return list;
+}
+qi_value_t *__qistd79(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "cmp", pargc >= 2? qi_list_index(pargs, 1): qi_make_function(state, "<anon>", 2, __qistd80, NULL));
+qi_decl(state, "l", qi_list_index(pargs, 0));
+(void)(qi_set(state, false, "l", qi_call(state, qi_get(state, "list_copy"), __qistd81(state))));
+return qi_call(state, qi_get(state, "list_sort"), __qistd82(state));
+return state->nil;
+}
+inline static qi_list_t *__qistd84(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd85(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd86(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd87(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "l");
+qi_list_data(list, 1) = qi_make_number(state, 0);
+return list;
+}
+qi_value_t *__qistd83(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "l", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd84(state)), qi_make_string(state, "list")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: list, but got: "), qi_call(state, qi_get(state, "type"), __qistd85(state))));}
+if (_qi_truthy(state, qi_call(state, qi_get(state, "is_empty"), __qistd86(state)))) {
+qi_throw(state, qi_make_string(state, "shift from empty list"));}
+qi_decl(state, "a", qi_index(state, qi_get(state, "l"), qi_make_number(state, 0)));
+(void)(qi_call(state, qi_get(state, "list_delete"), __qistd87(state)));
+return qi_get(state, "a");
+return state->nil;
+}
+inline static qi_list_t *__qistd89(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(3);
+qi_list_data(list, 0) = qi_get(state, "l");
+qi_list_data(list, 1) = qi_make_number(state, 0);
+qi_list_data(list, 2) = qi_get(state, "x");
+return list;
+}
+qi_value_t *__qistd88(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "l", qi_list_index(pargs, 0));
+qi_decl(state, "x", qi_list_index(pargs, 1));
+(void)(qi_call(state, qi_get(state, "list_insert"), __qistd89(state)));
+return state->nil;
+}
+inline static qi_list_t *__qistd91(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd92(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(3);
+qi_list_data(list, 0) = qi_make_string(state, "list");
+qi_list_data(list, 1) = qi_make_string(state, "string");
+qi_list_data(list, 2) = qi_make_string(state, "bytes");
+return list;
+}
+inline static qi_list_t *__qistd93(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd94(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "arguments");
+return list;
+}
+inline static qi_list_t *__qistd95(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd96(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd97(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd99(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd100(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_index(state, qi_get(state, "l"), qi_get(state, "i"));
+return list;
+}
+inline static qi_list_t *__qistd101(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "arguments");
+return list;
+}
+inline static qi_list_t *__qistd102(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd103(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd104(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd105(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd106(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd107(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd109(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd110(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_index(state, qi_get(state, "l"), qi_get(state, "i"));
+return list;
+}
+inline static qi_list_t *__qistd111(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd112(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+inline static qi_list_t *__qistd113(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd114(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+qi_value_t *__qistd90(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "l", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_in(state, qi_call(state, qi_get(state, "type"), __qistd91(state)), qi_make_tuple(state, __qistd92(state))))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: list, string or bytes, but got: "), qi_call(state, qi_get(state, "type"), __qistd93(state))));}
+qi_decl(state, "r", qi_make_list(state, NULL));
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd94(state)), qi_make_number(state, 2)))) {
+qi_decl(state, "f", qi_index(state, qi_get(state, "arguments"), qi_make_number(state, 1)));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd95(state)), qi_make_string(state, "number")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: number, but got: "), qi_call(state, qi_get(state, "type"), __qistd96(state))));}
+if (_qi_truthy(state, qi_lt(state, qi_get(state, "f"), qi_make_number(state, 0)))) {
+(void)(qi_set(state, false, "f", qi_add(state, qi_get(state, "f"), qi_call(state, qi_get(state, "len"), __qistd97(state)))));}
+qi_decl(state, "i", qi_get(state, "f"));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd99(state))))) {
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd100(state)));__continue98:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break98:;
+} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd101(state)), qi_make_number(state, 3)))) {
+qi_decl(state, "f", qi_index(state, qi_get(state, "arguments"), qi_make_number(state, 1)));
+qi_decl(state, "t", qi_index(state, qi_get(state, "arguments"), qi_make_number(state, 2)));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd102(state)), qi_make_string(state, "number")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: number, but got: "), qi_call(state, qi_get(state, "type"), __qistd103(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd104(state)), qi_make_string(state, "number")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected third argument to be: number, but got: "), qi_call(state, qi_get(state, "type"), __qistd105(state))));}
+if (_qi_truthy(state, qi_lt(state, qi_get(state, "f"), qi_make_number(state, 0)))) {
+(void)(qi_set(state, false, "f", qi_add(state, qi_get(state, "f"), qi_call(state, qi_get(state, "len"), __qistd106(state)))));}
+if (_qi_truthy(state, qi_lt(state, qi_get(state, "t"), qi_make_number(state, 0)))) {
+(void)(qi_set(state, false, "t", qi_add(state, qi_get(state, "t"), qi_call(state, qi_get(state, "len"), __qistd107(state)))));}
+qi_decl(state, "i", qi_get(state, "f"));
+while (_qi_truthy(state, qi_and(state, qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd109(state))), qi_le(state, qi_get(state, "i"), qi_get(state, "t"))))) {
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd110(state)));__continue108:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break108:;
+}}
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd111(state)), qi_make_string(state, "string")))) {
+return qi_call(state, qi_get(state, "list_join"), __qistd112(state));} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd113(state)), qi_make_string(state, "bytes")))) {
+return qi_call(state, qi_get(state, "bytes"), __qistd114(state));}}
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd116(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd117(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd118(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd119(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "p");
+return list;
+}
+inline static qi_list_t *__qistd121(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "p");
+return list;
+}
+inline static qi_list_t *__qistd120(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(3);
+qi_list_data(list, 0) = qi_get(state, "s");
+qi_list_data(list, 1) = qi_make_number(state, 0);
+qi_list_data(list, 2) = qi_sub(state, qi_call(state, qi_get(state, "len"), __qistd121(state)), qi_make_number(state, 1));
+return list;
+}
+qi_value_t *__qistd115(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "p", qi_list_index(pargs, 1));
+qi_decl(state, "s", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd116(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd117(state))));}
+if (_qi_truthy(state, qi_lt(state, qi_call(state, qi_get(state, "len"), __qistd118(state)), qi_call(state, qi_get(state, "len"), __qistd119(state))))) {
+return qi_get(state, "false");}
+return qi_equals(state, qi_call(state, qi_get(state, "slice"), __qistd120(state)), qi_get(state, "p"));
+return state->nil;
+}
+inline static qi_list_t *__qistd123(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd124(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd125(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd126(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "p");
+return list;
+}
+inline static qi_list_t *__qistd128(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd129(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "p");
+return list;
+}
+inline static qi_list_t *__qistd127(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "s");
+qi_list_data(list, 1) = qi_sub(state, qi_call(state, qi_get(state, "len"), __qistd128(state)), qi_call(state, qi_get(state, "len"), __qistd129(state)));
+return list;
+}
+qi_value_t *__qistd122(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "p", qi_list_index(pargs, 1));
+qi_decl(state, "s", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd123(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd124(state))));}
+if (_qi_truthy(state, qi_lt(state, qi_call(state, qi_get(state, "len"), __qistd125(state)), qi_call(state, qi_get(state, "len"), __qistd126(state))))) {
+return qi_get(state, "false");}
+return qi_equals(state, qi_call(state, qi_get(state, "slice"), __qistd127(state)), qi_get(state, "p"));
+return state->nil;
+}
+inline static qi_list_t *__qistd131(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "arguments");
+return list;
+}
+inline static qi_list_t *__qistd132(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd133(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd134(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd135(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "d");
+return list;
+}
+inline static qi_list_t *__qistd136(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd138(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd140(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "d");
+return list;
+}
+inline static qi_list_t *__qistd139(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(3);
+qi_list_data(list, 0) = qi_get(state, "s");
+qi_list_data(list, 1) = qi_get(state, "i");
+qi_list_data(list, 2) = qi_sub(state, qi_add(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd140(state))), qi_make_number(state, 1));
+return list;
+}
+inline static qi_list_t *__qistd141(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd142(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "d");
+return list;
+}
+inline static qi_list_t *__qistd143(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_get(state, "t");
+return list;
+}
+qi_value_t *__qistd130(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "s", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_or(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd131(state)), qi_make_number(state, 1)), qi_equals(state, qi_index(state, qi_get(state, "arguments"), qi_make_number(state, 1)), state->empty_string)))) {
+return qi_call(state, qi_get(state, "list"), __qistd132(state));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd133(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be:!string, but got: "), qi_call(state, qi_get(state, "type"), __qistd134(state))));}
+qi_decl(state, "r", qi_make_list(state, NULL));
+qi_decl(state, "d", qi_index(state, qi_get(state, "arguments"), qi_make_number(state, 1)));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd135(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd136(state))));}
+qi_decl(state, "t", state->empty_string);
+qi_decl(state, "i", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd138(state))))) {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "slice"), __qistd139(state)), qi_get(state, "d")))) {
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd141(state)));
+(void)(qi_set(state, false, "t", state->empty_string));
+(void)(qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), qi_sub(state, qi_call(state, qi_get(state, "len"), __qistd142(state)), qi_make_number(state, 1)))));
+goto __continue137;
+}
+(void)(qi_set(state, false, "t", qi_add(state, qi_get(state, "t"), qi_index(state, qi_get(state, "s"), qi_get(state, "i")))));
+__continue137:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break137:;
+if (_qi_truthy(state, qi_not_equals(state, qi_get(state, "t"), state->empty_string))) {
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd143(state)));}
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd145(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd146(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd147(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "w");
+return list;
+}
+inline static qi_list_t *__qistd148(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "w");
+return list;
+}
+inline static qi_list_t *__qistd149(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "b");
+return list;
+}
+inline static qi_list_t *__qistd150(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "b");
+return list;
+}
+inline static qi_list_t *__qistd152(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd154(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "w");
+return list;
+}
+inline static qi_list_t *__qistd153(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(3);
+qi_list_data(list, 0) = qi_get(state, "s");
+qi_list_data(list, 1) = qi_get(state, "i");
+qi_list_data(list, 2) = qi_sub(state, qi_add(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd154(state))), qi_make_number(state, 1));
+return list;
+}
+inline static qi_list_t *__qistd155(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "w");
+return list;
+}
+qi_value_t *__qistd144(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "b", qi_list_index(pargs, 2));
+qi_decl(state, "s", qi_list_index(pargs, 0));
+qi_decl(state, "w", qi_list_index(pargs, 1));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd145(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd146(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd147(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd148(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd149(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected third argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd150(state))));}
+qi_decl(state, "r", state->empty_string);
+qi_decl(state, "i", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd152(state))))) {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "slice"), __qistd153(state)), qi_get(state, "w")))) {
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_get(state, "b"))));
+(void)(qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), qi_sub(state, qi_call(state, qi_get(state, "len"), __qistd155(state)), qi_make_number(state, 1)))));
+goto __continue151;
+}
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_index(state, qi_get(state, "s"), qi_get(state, "i")))));
+__continue151:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break151:;
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd157(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd158(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd161(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_get(state, "k");
+return list;
+}
+qi_value_t *__qistd156(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "t", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd157(state)), qi_make_string(state, "table")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: table, but got: "), qi_call(state, qi_get(state, "type"), __qistd158(state))));}
+qi_decl(state, "r", qi_make_list(state, NULL));
+qi_value_t *__qistd160 = qi_iter(state, qi_get(state, "t"));
+qi_decl(state, "k", state->nil);
+for (qi_size_t length = _qi_length(state, __qistd160), i = 0; i < length; i++) {
+qi_set(state, false, "k", qi_index(state, __qistd160, qi_make_number(state, i)));
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd161(state)));__continue159:;
+}
+__break159:;
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd163(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd164(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd167(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_index(state, qi_get(state, "t"), qi_get(state, "k"));
+return list;
+}
+qi_value_t *__qistd162(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "t", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd163(state)), qi_make_string(state, "table")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: table, but got: "), qi_call(state, qi_get(state, "type"), __qistd164(state))));}
+qi_decl(state, "r", qi_make_list(state, NULL));
+qi_value_t *__qistd166 = qi_iter(state, qi_get(state, "t"));
+qi_decl(state, "k", state->nil);
+for (qi_size_t length = _qi_length(state, __qistd166), i = 0; i < length; i++) {
+qi_set(state, false, "k", qi_index(state, __qistd166, qi_make_number(state, i)));
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd167(state)));__continue165:;
+}
+__break165:;
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd169(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd170(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd171(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd172(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(4);
+qi_list_data(list, 0) = qi_make_string(state, "list");
+qi_list_data(list, 1) = qi_make_string(state, "tuple");
+qi_list_data(list, 2) = qi_make_string(state, "string");
+qi_list_data(list, 3) = qi_make_string(state, "bytes");
+return list;
+}
+inline static qi_list_t *__qistd173(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd174(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd177(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "xs");
+qi_list_data(list, 1) = qi_make_number(state, 1);
+return list;
+}
+inline static qi_list_t *__qistd178(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd179(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd180(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+inline static qi_list_t *__qistd181(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd182(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+inline static qi_list_t *__qistd183(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd184(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+qi_value_t *__qistd168(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 0));
+qi_decl(state, "xs", qi_list_index(pargs, 1));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd169(state)), qi_make_string(state, "function")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: function, but got: "), qi_call(state, qi_get(state, "type"), __qistd170(state))));}
+if (_qi_truthy(state, qi_not_in(state, qi_call(state, qi_get(state, "type"), __qistd171(state)), qi_make_tuple(state, __qistd172(state))))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: list, tuple, string or bytes, but got: "), qi_call(state, qi_get(state, "type"), __qistd173(state))));}
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd174(state)), qi_make_number(state, 0)))) {
+qi_throw(state, qi_make_string(state, "cannot reduce empty list"));}
+(void)(qi_set(state, false, "r", qi_index(state, qi_get(state, "xs"), qi_make_number(state, 0))));
+qi_value_t *__qistd176 = qi_iter(state, qi_call(state, qi_get(state, "slice"), __qistd177(state)));
+qi_decl(state, "x", state->nil);
+for (qi_size_t length = _qi_length(state, __qistd176), i = 0; i < length; i++) {
+qi_set(state, false, "x", qi_index(state, __qistd176, qi_make_number(state, i)));
+(void)(qi_set(state, false, "r", qi_call(state, qi_get(state, "f"), __qistd178(state))));__continue175:;
+}
+__break175:;
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd179(state)), qi_make_string(state, "tuple")))) {
+return qi_call(state, qi_get(state, "tuple"), __qistd180(state));} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd181(state)), qi_make_string(state, "string")))) {
+return qi_call(state, qi_get(state, "list_join"), __qistd182(state));} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd183(state)), qi_make_string(state, "bytes")))) {
+return qi_call(state, qi_get(state, "bytes"), __qistd184(state));}}}
+return qi_get(state, "r");
+return state->nil;
+}
+qi_value_t *__qistd187(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "x", qi_list_index(pargs, 0));
+qi_decl(state, "y", qi_list_index(pargs, 1));
+return qi_add(state, qi_get(state, "x"), qi_get(state, "y"));return state->nil;
+}
+inline static qi_list_t *__qistd186(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_function(state, "<anon>", 2, __qistd187, NULL);
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd185(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "reduce"), __qistd186(state));return state->nil;
+}
+qi_value_t *__qistd190(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "x", qi_list_index(pargs, 0));
+qi_decl(state, "y", qi_list_index(pargs, 1));
+return qi_mul(state, qi_get(state, "x"), qi_get(state, "y"));return state->nil;
+}
+inline static qi_list_t *__qistd189(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_function(state, "<anon>", 2, __qistd190, NULL);
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd188(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "reduce"), __qistd189(state));return state->nil;
+}
+inline static qi_list_t *__qistd192(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd193(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd194(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd195(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(4);
+qi_list_data(list, 0) = qi_make_string(state, "list");
+qi_list_data(list, 1) = qi_make_string(state, "tuple");
+qi_list_data(list, 2) = qi_make_string(state, "string");
+qi_list_data(list, 3) = qi_make_string(state, "bytes");
+return list;
+}
+inline static qi_list_t *__qistd196(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd197(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd201(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd200(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_call(state, qi_get(state, "f"), __qistd201(state));
+return list;
+}
+inline static qi_list_t *__qistd202(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd203(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+inline static qi_list_t *__qistd204(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd205(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+inline static qi_list_t *__qistd206(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd207(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+qi_value_t *__qistd191(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 0));
+qi_decl(state, "xs", qi_list_index(pargs, 1));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd192(state)), qi_make_string(state, "function")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: function, but got: "), qi_call(state, qi_get(state, "type"), __qistd193(state))));}
+if (_qi_truthy(state, qi_not_in(state, qi_call(state, qi_get(state, "type"), __qistd194(state)), qi_make_tuple(state, __qistd195(state))))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: list, tuple, string or bytes, but got: "), qi_call(state, qi_get(state, "type"), __qistd196(state))));}
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd197(state)), qi_make_number(state, 0)))) {
+return qi_get(state, "xs");}
+qi_decl(state, "r", qi_make_list(state, NULL));
+qi_value_t *__qistd199 = qi_iter(state, qi_get(state, "xs"));
+qi_decl(state, "x", state->nil);
+for (qi_size_t length = _qi_length(state, __qistd199), i = 0; i < length; i++) {
+qi_set(state, false, "x", qi_index(state, __qistd199, qi_make_number(state, i)));
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd200(state)));__continue198:;
+}
+__break198:;
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd202(state)), qi_make_string(state, "tuple")))) {
+return qi_call(state, qi_get(state, "tuple"), __qistd203(state));} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd204(state)), qi_make_string(state, "string")))) {
+return qi_call(state, qi_get(state, "list_join"), __qistd205(state));} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd206(state)), qi_make_string(state, "bytes")))) {
+return qi_call(state, qi_get(state, "bytes"), __qistd207(state));}}}
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd209(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd210(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "f");
+return list;
+}
+inline static qi_list_t *__qistd211(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd212(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(4);
+qi_list_data(list, 0) = qi_make_string(state, "list");
+qi_list_data(list, 1) = qi_make_string(state, "tuple");
+qi_list_data(list, 2) = qi_make_string(state, "string");
+qi_list_data(list, 3) = qi_make_string(state, "bytes");
+return list;
+}
+inline static qi_list_t *__qistd213(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd214(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd217(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd218(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_get(state, "x");
+return list;
+}
+inline static qi_list_t *__qistd219(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd220(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+inline static qi_list_t *__qistd221(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd222(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+inline static qi_list_t *__qistd223(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "xs");
+return list;
+}
+inline static qi_list_t *__qistd224(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "r");
+return list;
+}
+qi_value_t *__qistd208(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 0));
+qi_decl(state, "xs", qi_list_index(pargs, 1));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd209(state)), qi_make_string(state, "function")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: function, but got: "), qi_call(state, qi_get(state, "type"), __qistd210(state))));}
+if (_qi_truthy(state, qi_not_in(state, qi_call(state, qi_get(state, "type"), __qistd211(state)), qi_make_tuple(state, __qistd212(state))))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: list, tuple, string or bytes, but got: "), qi_call(state, qi_get(state, "type"), __qistd213(state))));}
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd214(state)), qi_make_number(state, 0)))) {
+return qi_get(state, "xs");}
+qi_decl(state, "r", qi_make_list(state, NULL));
+qi_value_t *__qistd216 = qi_iter(state, qi_get(state, "xs"));
+qi_decl(state, "x", state->nil);
+for (qi_size_t length = _qi_length(state, __qistd216), i = 0; i < length; i++) {
+qi_set(state, false, "x", qi_index(state, __qistd216, qi_make_number(state, i)));
+if (_qi_truthy(state, qi_call(state, qi_get(state, "f"), __qistd217(state)))) {
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd218(state)));}__continue215:;
+}
+__break215:;
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd219(state)), qi_make_string(state, "tuple")))) {
+return qi_call(state, qi_get(state, "tuple"), __qistd220(state));} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd221(state)), qi_make_string(state, "string")))) {
+return qi_call(state, qi_get(state, "list_join"), __qistd222(state));} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd223(state)), qi_make_string(state, "bytes")))) {
+return qi_call(state, qi_get(state, "bytes"), __qistd224(state));}}}
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd226(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd227(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd228(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "w");
+return list;
+}
+inline static qi_list_t *__qistd229(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "w");
+return list;
+}
+inline static qi_list_t *__qistd231(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd232(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "w");
+return list;
+}
+inline static qi_list_t *__qistd234(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "w");
+return list;
+}
+inline static qi_list_t *__qistd233(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(3);
+qi_list_data(list, 0) = qi_get(state, "s");
+qi_list_data(list, 1) = qi_get(state, "i");
+qi_list_data(list, 2) = qi_sub(state, qi_add(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd234(state))), qi_make_number(state, 1));
+return list;
+}
+qi_value_t *__qistd225(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "s", qi_list_index(pargs, 0));
+qi_decl(state, "w", qi_list_index(pargs, 1));
+if (_qi_truthy(state, qi_or(state, qi_equals(state, qi_get(state, "s"), state->empty_string), qi_equals(state, qi_get(state, "w"), state->empty_string)))) {
+return qi_negate(state, qi_make_number(state, 1));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd226(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd227(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd228(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd229(state))));}
+qi_decl(state, "i", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd231(state))))) {
+if (_qi_truthy(state, qi_and(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd232(state)), qi_make_number(state, 1)), qi_equals(state, qi_index(state, qi_get(state, "s"), qi_get(state, "i")), qi_get(state, "w"))))) {
+return qi_get(state, "i");} else {
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "slice"), __qistd233(state)), qi_get(state, "w")))) {
+return qi_get(state, "i");}}__continue230:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break230:;
+return qi_negate(state, qi_make_number(state, 1));
+return state->nil;
+}
+inline static qi_list_t *__qistd236(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd237(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd238(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "cs");
+return list;
+}
+inline static qi_list_t *__qistd239(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "cs");
+return list;
+}
+inline static qi_list_t *__qistd241(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd242(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "s");
+qi_list_data(list, 1) = qi_get(state, "i");
+return list;
+}
+qi_value_t *__qistd235(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "s", qi_list_index(pargs, 0));
+qi_decl(state, "cs", pargc >= 2? qi_list_index(pargs, 1): qi_make_string(state, " \t\n\r\x0b\x0c"));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd236(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd237(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd238(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd239(state))));}
+if (_qi_truthy(state, qi_equals(state, qi_get(state, "s"), state->empty_string))) {
+return qi_get(state, "s");}
+qi_decl(state, "i", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_and(state, qi_in(state, qi_index(state, qi_get(state, "s"), qi_get(state, "i")), qi_get(state, "cs")), qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd241(state)))))) {
+__continue240:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break240:;
+return qi_call(state, qi_get(state, "slice"), __qistd242(state));
+return state->nil;
+}
+inline static qi_list_t *__qistd244(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd245(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd246(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "cs");
+return list;
+}
+inline static qi_list_t *__qistd247(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "cs");
+return list;
+}
+inline static qi_list_t *__qistd249(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd251(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd250(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(3);
+qi_list_data(list, 0) = qi_get(state, "s");
+qi_list_data(list, 1) = qi_make_number(state, 0);
+qi_list_data(list, 2) = qi_sub(state, qi_sub(state, qi_call(state, qi_get(state, "len"), __qistd251(state)), qi_get(state, "k")), qi_make_number(state, 1));
+return list;
+}
+qi_value_t *__qistd243(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "s", qi_list_index(pargs, 0));
+qi_decl(state, "cs", pargc >= 2? qi_list_index(pargs, 1): qi_make_string(state, " \t\n\r\x0b\x0c"));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd244(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd245(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd246(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd247(state))));}
+if (_qi_truthy(state, qi_equals(state, qi_get(state, "s"), state->empty_string))) {
+return qi_get(state, "s");}
+qi_decl(state, "i", qi_sub(state, qi_call(state, qi_get(state, "len"), __qistd249(state)), qi_make_number(state, 1)));
+qi_decl(state, "k", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_and(state, qi_in(state, qi_index(state, qi_get(state, "s"), qi_get(state, "i")), qi_get(state, "cs")), qi_ge(state, qi_get(state, "i"), qi_make_number(state, 0))))) {
+(void)(qi_set(state, false, "i", qi_sub(state, qi_get(state, "i"), state->one)));__continue248:;
+qi_set(state, false, "k", qi_add(state, qi_get(state, "k"), state->one));
+}
+__break248:;
+return qi_call(state, qi_get(state, "slice"), __qistd250(state));
+return state->nil;
+}
+inline static qi_list_t *__qistd253(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd254(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd255(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "cs");
+return list;
+}
+inline static qi_list_t *__qistd256(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "cs");
+return list;
+}
+inline static qi_list_t *__qistd258(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "s");
+qi_list_data(list, 1) = qi_get(state, "cs");
+return list;
+}
+inline static qi_list_t *__qistd257(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_call(state, qi_get(state, "str_rstrip"), __qistd258(state));
+qi_list_data(list, 1) = qi_get(state, "cs");
+return list;
+}
+qi_value_t *__qistd252(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "s", qi_list_index(pargs, 0));
+qi_decl(state, "cs", pargc >= 2? qi_list_index(pargs, 1): qi_make_string(state, " \t\n\r\x0b\x0c"));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd253(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd254(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd255(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd256(state))));}
+return qi_call(state, qi_get(state, "str_lstrip"), __qistd257(state));
+return state->nil;
+}
+inline static qi_list_t *__qistd260(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd261(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "t");
+return list;
+}
+inline static qi_list_t *__qistd262(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "k");
+return list;
+}
+inline static qi_list_t *__qistd263(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "k");
+return list;
+}
+qi_value_t *__qistd259(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "d", pargc >= 3? qi_list_index(pargs, 2): qi_get(state, "nil"));
+qi_decl(state, "k", qi_list_index(pargs, 1));
+qi_decl(state, "t", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd260(state)), qi_make_string(state, "table")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: table, but got: "), qi_call(state, qi_get(state, "type"), __qistd261(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd262(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd263(state))));}
+if (_qi_truthy(state, qi_not_in(state, qi_get(state, "k"), qi_get(state, "t")))) {
+return qi_get(state, "d");}
+return qi_index(state, qi_get(state, "t"), qi_get(state, "k"));
+return state->nil;
+}
+inline static qi_list_t *__qistd265(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "len");
+qi_list_data(list, 1) = qi_get(state, "arguments");
+return list;
+}
+inline static qi_list_t *__qistd266(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "min");
+qi_list_data(list, 1) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd270(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "t");
+qi_list_data(list, 1) = qi_index(state, qi_get(state, "xs"), qi_get(state, "i"));
+return list;
+}
+inline static qi_list_t *__qistd271(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "r");
+qi_list_data(list, 1) = qi_get(state, "t");
+return list;
+}
+qi_value_t *__qistd264(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+if (_qi_truthy(state, qi_not(state, qi_get(state, "arguments")))) {
+return qi_make_list(state, NULL);}
+qi_decl(state, "l", qi_call(state, qi_get(state, "map"), __qistd265(state)));
+(void)(qi_set(state, false, "l", qi_call(state, qi_get(state, "reduce"), __qistd266(state))));
+qi_decl(state, "r", qi_make_list(state, NULL));
+qi_decl(state, "i", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_get(state, "l")))) {
+qi_decl(state, "t", qi_make_list(state, NULL));
+qi_value_t *__qistd269 = qi_iter(state, qi_get(state, "arguments"));
+qi_decl(state, "xs", state->nil);
+for (qi_size_t length = _qi_length(state, __qistd269), i = 0; i < length; i++) {
+qi_set(state, false, "xs", qi_index(state, __qistd269, qi_make_number(state, i)));
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd270(state)));__continue268:;
+}
+__break268:;
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd271(state)));
+__continue267:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break267:;
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd273(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd275(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd276(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd274(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_call(state, qi_get(state, "table_keys"), __qistd275(state));
+qi_list_data(list, 1) = qi_call(state, qi_get(state, "table_values"), __qistd276(state));
+return list;
+}
+inline static qi_list_t *__qistd279(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd278(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_call(state, qi_get(state, "len"), __qistd279(state));
+return list;
+}
+inline static qi_list_t *__qistd277(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_call(state, qi_get(state, "range"), __qistd278(state));
+qi_list_data(list, 1) = qi_get(state, "l");
+return list;
+}
+qi_value_t *__qistd272(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "l", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "type"), __qistd273(state)), qi_make_string(state, "table")))) {
+return qi_call(state, qi_get(state, "zip"), __qistd274(state));} else {
+return qi_call(state, qi_get(state, "zip"), __qistd277(state));}return state->nil;
+}
+inline static qi_list_t *__qistd281(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd282(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "c");
+return list;
+}
+inline static qi_list_t *__qistd286(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "c");
+return list;
+}
+inline static qi_list_t *__qistd285(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_sub(state, qi_call(state, qi_get(state, "ord"), __qistd286(state)), qi_make_number(state, 32));
+return list;
+}
+qi_value_t *__qistd284(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "c", qi_list_index(pargs, 0));
+return (_qi_truthy(state, qi_and(state, qi_ge(state, qi_get(state, "c"), qi_make_string(state, "a")), qi_le(state, qi_get(state, "c"), qi_make_string(state, "z"))))? qi_call(state, qi_get(state, "chr"), __qistd285(state)): qi_get(state, "c"));return state->nil;
+}
+inline static qi_list_t *__qistd283(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_function(state, "<anon>", 1, __qistd284, NULL);
+qi_list_data(list, 1) = qi_get(state, "s");
+return list;
+}
+qi_value_t *__qistd280(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "s", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd281(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd282(state))));}
+return qi_call(state, qi_get(state, "map"), __qistd283(state));
+return state->nil;
+}
+inline static qi_list_t *__qistd288(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd289(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "c");
+return list;
+}
+inline static qi_list_t *__qistd293(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "c");
+return list;
+}
+inline static qi_list_t *__qistd292(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_add(state, qi_call(state, qi_get(state, "ord"), __qistd293(state)), qi_make_number(state, 32));
+return list;
+}
+qi_value_t *__qistd291(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "c", qi_list_index(pargs, 0));
+return (_qi_truthy(state, qi_and(state, qi_ge(state, qi_get(state, "c"), qi_make_string(state, "A")), qi_le(state, qi_get(state, "c"), qi_make_string(state, "Z"))))? qi_call(state, qi_get(state, "chr"), __qistd292(state)): qi_get(state, "c"));return state->nil;
+}
+inline static qi_list_t *__qistd290(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_function(state, "<anon>", 1, __qistd291, NULL);
+qi_list_data(list, 1) = qi_get(state, "s");
+return list;
+}
+qi_value_t *__qistd287(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "s", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd288(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd289(state))));}
+return qi_call(state, qi_get(state, "map"), __qistd290(state));
+return state->nil;
+}
+inline static qi_list_t *__qistd296(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "p");
+return list;
+}
+inline static qi_list_t *__qistd295(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "p");
+qi_list_data(list, 1) = qi_add(state, qi_call(state, qi_get(state, "get_meta_table"), __qistd296(state)), qi_get(state, "t"));
+return list;
+}
+inline static qi_list_t *__qistd297(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_table(state, NULL);
+qi_list_data(list, 1) = qi_get(state, "t");
+return list;
+}
+qi_value_t *__qistd294(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "p", pargc >= 2? qi_list_index(pargs, 1): qi_get(state, "nil"));
+qi_decl(state, "t", qi_list_index(pargs, 0));
+return (_qi_truthy(state, qi_not_is(state, qi_get(state, "p"), qi_get(state, "nil")))? qi_call(state, qi_get(state, "set_meta_table"), __qistd295(state)): qi_call(state, qi_get(state, "set_meta_table"), __qistd297(state)));return state->nil;
+}
+inline static qi_list_t *__qistd299(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "o");
+return list;
+}
+qi_value_t *__qistd298(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "o", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "has_meta_table"), __qistd299(state));return state->nil;
+}
+qi_value_t *__qistd303(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "this", qi_list_index(pargs, 0));
+return qi_get(state, "n");return state->nil;
+}
+inline static qi_table_t *__qistd304(qi_state_t *state) {
+qi_table_t *table = qi_table_make();
+qi_table_set(table, "n", qi_get(state, "n"));
+return table;
+}
+qi_value_t *__qistd305(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "this", qi_list_index(pargs, 0));
+return qi_add(state, qi_add(state, qi_make_string(state, "<class "), qi_get(state, "n")), qi_make_string(state, ">"));return state->nil;
+}
+inline static qi_table_t *__qistd306(qi_state_t *state) {
+qi_table_t *table = qi_table_make();
+qi_table_set(table, "n", qi_get(state, "n"));
+return table;
+}
+inline static qi_list_t *__qistd310(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_index(state, qi_get(state, "this"), qi_make_string(state, "super"));
+qi_list_data(list, 1) = qi_get(state, "other");
+return list;
+}
+inline static qi_list_t *__qistd311(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_index(state, qi_get(state, "this"), qi_make_string(state, "super"));
+return list;
+}
+inline static qi_list_t *__qistd312(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "t");
+qi_list_data(list, 1) = qi_get(state, "mt");
+return list;
+}
+inline static qi_list_t *__qistd314(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "obj");
+return list;
+}
+inline static qi_list_t *__qistd313(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_index(state, qi_get(state, "mt"), qi_make_string(state, "constructor"));
+qi_list_data(list, 1) = qi_add(state, qi_make_list(state, __qistd314(state)), qi_get(state, "pargs"));
+return list;
+}
+qi_value_t *__qistd307(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "pargs", qi_list_index(pargs, 1));
+qi_decl(state, "this", qi_list_index(pargs, 0));
+qi_decl(state, "t", qi_make_table(state, NULL));
+qi_decl(state, "mt", qi_make_table(state, NULL));
+qi_value_t *__qistd309 = qi_iter(state, qi_get(state, "p"));
+qi_decl(state, "other", state->nil);
+for (qi_size_t length = _qi_length(state, __qistd309), i = 0; i < length; i++) {
+qi_set(state, false, "other", qi_index(state, __qistd309, qi_make_number(state, i)));
+(void)(qi_set(state, false, "t", qi_add(state, qi_get(state, "t"), qi_index(state, qi_get(state, "other"), qi_make_string(state, "t")))));
+(void)(qi_set(state, false, "mt", qi_add(state, qi_get(state, "mt"), qi_index(state, qi_get(state, "other"), qi_make_string(state, "mt")))));
+(void)(qi_call(state, qi_get(state, "list_push"), __qistd310(state)));
+__continue308:;
+}
+__break308:;
+if (_qi_truthy(state, qi_equals(state, qi_call(state, qi_get(state, "len"), __qistd311(state)), qi_make_number(state, 1)))) {
+(void)(qi_index_set(state, false, qi_get(state, "this"), qi_make_string(state, "super"), qi_index(state, qi_index(state, qi_get(state, "this"), qi_make_string(state, "super")), qi_make_number(state, 0))));}
+(void)(qi_set(state, false, "t", qi_add(state, qi_get(state, "t"), qi_index(state, qi_get(state, "this"), qi_make_string(state, "t")))));
+(void)(qi_set(state, false, "mt", qi_add(state, qi_get(state, "mt"), qi_index(state, qi_get(state, "this"), qi_make_string(state, "mt")))));
+(void)(qi_index_set(state, false, qi_get(state, "t"), qi_make_string(state, "super"), qi_index(state, qi_get(state, "this"), qi_make_string(state, "super"))));
+(void)(qi_set(state, false, "obj", qi_call(state, qi_get(state, "set_meta_table"), __qistd312(state))));
+if (_qi_truthy(state, qi_in(state, qi_make_string(state, "constructor"), qi_get(state, "mt")))) {
+(void)(qi_call(state, qi_get(state, "func_call"), __qistd313(state)));}
+return qi_get(state, "obj");
+return state->nil;
+}
+inline static qi_table_t *__qistd315(qi_state_t *state) {
+qi_table_t *table = qi_table_make();
+qi_table_set(table, "p", qi_get(state, "p"));
+return table;
+}
+inline static qi_table_t *__qistd302(qi_state_t *state) {
+qi_table_t *table = qi_table_make();
+qi_table_set(table, "__type", qi_make_function(state, "<anon>", 1, __qistd303, __qistd304(state)));
+qi_table_set(table, "mt", qi_get(state, "mt"));
+qi_table_set(table, "super", qi_make_list(state, NULL));
+qi_table_set(table, "t", qi_get(state, "t"));
+qi_table_set(table, "__str", qi_make_function(state, "<anon>", 1, __qistd305, __qistd306(state)));
+qi_table_set(table, "__call", qi_make_function(state, "<anon>", 2, __qistd307, __qistd315(state)));
+return table;
+}
+inline static qi_list_t *__qistd301(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_add(state, qi_get(state, "st"), qi_make_table(state, __qistd302(state)));
+return list;
+}
+qi_value_t *__qistd300(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "mt", qi_list_index(pargs, 3));
+qi_decl(state, "st", qi_list_index(pargs, 4));
+qi_decl(state, "n", qi_list_index(pargs, 0));
+qi_decl(state, "p", qi_list_index(pargs, 1));
+qi_decl(state, "t", qi_list_index(pargs, 2));
+return qi_call(state, qi_get(state, "Object"), __qistd301(state));return state->nil;
+}
+inline static qi_list_t *__qistd317(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd318(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd320(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd324(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd325(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_index(state, qi_get(state, "arguments"), qi_set(state, false, "n", qi_add(state, qi_get(state, "n"), state->one)));
+return list;
+}
+qi_value_t *__qistd316(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "s", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd317(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd318(state))));}
+qi_decl(state, "r", state->empty_string);
+qi_decl(state, "n", qi_make_number(state, 1));
+qi_decl(state, "i", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd320(state))))) {
+qi_value_t *__qistd322 = qi_index(state, qi_get(state, "s"), qi_get(state, "i"));
+if (_qi_equals(state, __qistd322, qi_make_string(state, "_"))) goto __qistd323;
+goto __default321;
+__qistd323:;
+if (_qi_truthy(state, qi_and(state, qi_lt(state, qi_add(state, qi_get(state, "i"), qi_make_number(state, 1)), qi_call(state, qi_get(state, "len"), __qistd324(state))), qi_equals(state, qi_index(state, qi_get(state, "s"), qi_add(state, qi_get(state, "i"), qi_make_number(state, 1))), qi_make_string(state, "_"))))) {
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_make_string(state, "_"))));
+(void)(qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one)));
+goto __continue319;
+}
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_call(state, qi_get(state, "repr"), __qistd325(state)))));
+goto __break321;
+__default321:;
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_index(state, qi_get(state, "s"), qi_get(state, "i")))));
+__break321:;
+__continue319:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break319:;
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd327(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd328(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd329(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd330(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "l");
+return list;
+}
+inline static qi_list_t *__qistd332(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd331(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "str_format");
+qi_list_data(list, 1) = qi_add(state, qi_make_list(state, __qistd332(state)), qi_get(state, "l"));
+return list;
+}
+qi_value_t *__qistd326(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "l", qi_list_index(pargs, 1));
+qi_decl(state, "s", qi_list_index(pargs, 0));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd327(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd328(state))));}
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd329(state)), qi_make_string(state, "list")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected second argument to be: list, but got: "), qi_call(state, qi_get(state, "type"), __qistd330(state))));}
+return qi_call(state, qi_get(state, "func_call"), __qistd331(state));
+return state->nil;
+}
+inline static qi_list_t *__qistd334(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd335(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd337(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd341(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd343(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd344(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "s");
+return list;
+}
+inline static qi_list_t *__qistd345(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_index(state, qi_get(state, "t"), qi_get(state, "k"));
+return list;
+}
+qi_value_t *__qistd333(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "s", qi_list_index(pargs, 0));
+qi_decl(state, "t", qi_list_index(pargs, 1));
+if (_qi_truthy(state, qi_not_equals(state, qi_call(state, qi_get(state, "type"), __qistd334(state)), qi_make_string(state, "string")))) {
+qi_throw(state, qi_add(state, qi_make_string(state, "expected first argument to be: string, but got: "), qi_call(state, qi_get(state, "type"), __qistd335(state))));}
+qi_decl(state, "r", state->empty_string);
+qi_decl(state, "n", qi_make_number(state, 1));
+qi_decl(state, "i", qi_make_number(state, 0));
+while (_qi_truthy(state, qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd337(state))))) {
+qi_value_t *__qistd339 = qi_index(state, qi_get(state, "s"), qi_get(state, "i"));
+if (_qi_equals(state, __qistd339, qi_make_string(state, "{"))) goto __qistd340;
+goto __default338;
+__qistd340:;
+if (_qi_truthy(state, qi_and(state, qi_lt(state, qi_add(state, qi_get(state, "i"), qi_make_number(state, 1)), qi_call(state, qi_get(state, "len"), __qistd341(state))), qi_equals(state, qi_index(state, qi_get(state, "s"), qi_add(state, qi_get(state, "i"), qi_make_number(state, 1))), qi_make_string(state, "{"))))) {
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_make_string(state, "{"))));
+(void)(qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one)));
+goto __continue336;
+}
+qi_decl(state, "k", state->empty_string);
+(void)(qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one)));
+while (_qi_truthy(state, qi_and(state, qi_lt(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd343(state))), qi_not_equals(state, qi_index(state, qi_get(state, "s"), qi_get(state, "i")), qi_make_string(state, "}"))))) {
+(void)(qi_set(state, false, "k", qi_add(state, qi_get(state, "k"), qi_index(state, qi_get(state, "s"), qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one))))));__continue342:;
+}
+__break342:;
+if (_qi_truthy(state, qi_or(state, qi_ge(state, qi_get(state, "i"), qi_call(state, qi_get(state, "len"), __qistd344(state))), qi_not_equals(state, qi_index(state, qi_get(state, "s"), qi_get(state, "i")), qi_make_string(state, "}"))))) {
+qi_throw(state, qi_make_string(state, "unmatched { in format specifier"));}
+if (_qi_truthy(state, qi_not(state, qi_get(state, "k")))) {
+qi_throw(state, qi_make_string(state, "empty format key"));}
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_call(state, qi_get(state, "repr"), __qistd345(state)))));
+goto __break338;
+__default338:;
+(void)(qi_set(state, false, "r", qi_add(state, qi_get(state, "r"), qi_index(state, qi_get(state, "s"), qi_get(state, "i")))));
+__break338:;
+__continue336:;
+qi_set(state, false, "i", qi_add(state, qi_get(state, "i"), state->one));
+}
+__break336:;
+return qi_get(state, "r");
+return state->nil;
+}
+inline static qi_list_t *__qistd348(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "STDIN");
+return list;
+}
+inline static qi_list_t *__qistd347(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_call(state, qi_get(state, "fgetc"), __qistd348(state));
+return list;
+}
+qi_value_t *__qistd346(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+return qi_call(state, qi_get(state, "chr"), __qistd347(state));return state->nil;
+}
+inline static qi_list_t *__qistd350(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "STDOUT");
+qi_list_data(list, 1) = qi_get(state, "c");
+return list;
+}
+qi_value_t *__qistd349(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "c", qi_list_index(pargs, 0));
+(void)(qi_call(state, qi_get(state, "fputc"), __qistd350(state)));return state->nil;
+}
+inline static qi_list_t *__qistd352(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "STDIN");
+qi_list_data(list, 1) = qi_make_number(state, 256);
+return list;
+}
+qi_value_t *__qistd351(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+return qi_call(state, qi_get(state, "fgets"), __qistd352(state));return state->nil;
+}
+inline static qi_list_t *__qistd354(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(1);
+qi_list_data(list, 0) = qi_get(state, "arguments");
+return list;
+}
+inline static qi_list_t *__qistd355(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "print");
+qi_list_data(list, 1) = qi_get(state, "arguments");
+return list;
+}
+inline static qi_list_t *__qistd356(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_call(state, qi_get(state, "getline"), NULL);
+qi_list_data(list, 1) = qi_make_string(state, "\n\r");
+return list;
+}
+qi_value_t *__qistd353(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+if (_qi_truthy(state, qi_gt(state, qi_call(state, qi_get(state, "len"), __qistd354(state)), qi_make_number(state, 0)))) {
+(void)(qi_call(state, qi_get(state, "func_call"), __qistd355(state)));}
+return qi_call(state, qi_get(state, "str_rstrip"), __qistd356(state));
+return state->nil;
+}
+inline static qi_list_t *__qistd358(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "path");
+qi_list_data(list, 1) = qi_get(state, "mode");
+return list;
+}
+qi_value_t *__qistd357(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "mode", pargc >= 2? qi_list_index(pargs, 1): qi_make_string(state, "r"));
+qi_decl(state, "path", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "fopen"), __qistd358(state));return state->nil;
+}
+qi_value_t *__qistd359(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "cond", qi_list_index(pargs, 0));
+qi_decl(state, "msg", pargc >= 2? qi_list_index(pargs, 1): qi_make_string(state, "assertion failed"));
+if (_qi_truthy(state, qi_not(state, qi_get(state, "cond")))) {
+qi_throw(state, qi_get(state, "msg"));}return state->nil;
+}
+inline static qi_list_t *__qistd360(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.reverse");
+qi_list_data(list, 1) = qi_get(state, "reverse");
+return list;
+}
+inline static qi_list_t *__qistd361(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.reverse");
+qi_list_data(list, 1) = qi_get(state, "reverse");
+return list;
+}
+inline static qi_list_t *__qistd362(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "bytes.reverse");
+qi_list_data(list, 1) = qi_get(state, "reverse");
+return list;
+}
+inline static qi_list_t *__qistd363(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.remove");
+qi_list_data(list, 1) = qi_get(state, "list_remove");
+return list;
+}
+inline static qi_list_t *__qistd364(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.join");
+qi_list_data(list, 1) = qi_get(state, "list_join");
+return list;
+}
+inline static qi_list_t *__qistd365(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.popAt");
+qi_list_data(list, 1) = qi_get(state, "list_pop_at");
+return list;
+}
+inline static qi_list_t *__qistd366(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.sort");
+qi_list_data(list, 1) = qi_get(state, "list_sort");
+return list;
+}
+inline static qi_list_t *__qistd367(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.sorted");
+qi_list_data(list, 1) = qi_get(state, "list_sorted");
+return list;
+}
+inline static qi_list_t *__qistd368(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.shift");
+qi_list_data(list, 1) = qi_get(state, "list_shift");
+return list;
+}
+inline static qi_list_t *__qistd369(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.unshift");
+qi_list_data(list, 1) = qi_get(state, "list_unshift");
+return list;
+}
+inline static qi_list_t *__qistd370(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.slice");
+qi_list_data(list, 1) = qi_get(state, "slice");
+return list;
+}
+inline static qi_list_t *__qistd371(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.slice");
+qi_list_data(list, 1) = qi_get(state, "slice");
+return list;
+}
+inline static qi_list_t *__qistd372(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "bytes.slice");
+qi_list_data(list, 1) = qi_get(state, "slice");
+return list;
+}
+inline static qi_list_t *__qistd373(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.startsWith");
+qi_list_data(list, 1) = qi_get(state, "str_startswith");
+return list;
+}
+inline static qi_list_t *__qistd374(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.endsWith");
+qi_list_data(list, 1) = qi_get(state, "str_endswith");
+return list;
+}
+inline static qi_list_t *__qistd375(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.split");
+qi_list_data(list, 1) = qi_get(state, "str_split");
+return list;
+}
+inline static qi_list_t *__qistd376(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.replace");
+qi_list_data(list, 1) = qi_get(state, "str_replace");
+return list;
+}
+inline static qi_list_t *__qistd377(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "table.keys");
+qi_list_data(list, 1) = qi_get(state, "table_keys");
+return list;
+}
+inline static qi_list_t *__qistd378(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "table.values");
+qi_list_data(list, 1) = qi_get(state, "table_values");
+return list;
+}
+inline static qi_list_t *__qistd381(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd380(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "reduce"), __qistd381(state));return state->nil;
+}
+inline static qi_list_t *__qistd379(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.reduce");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd380, NULL);
+return list;
+}
+inline static qi_list_t *__qistd384(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd383(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "reduce"), __qistd384(state));return state->nil;
+}
+inline static qi_list_t *__qistd382(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "tuple.reduce");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd383, NULL);
+return list;
+}
+inline static qi_list_t *__qistd387(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd386(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "reduce"), __qistd387(state));return state->nil;
+}
+inline static qi_list_t *__qistd385(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.reduce");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd386, NULL);
+return list;
+}
+inline static qi_list_t *__qistd390(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd389(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "reduce"), __qistd390(state));return state->nil;
+}
+inline static qi_list_t *__qistd388(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "bytes.reduce");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd389, NULL);
+return list;
+}
+inline static qi_list_t *__qistd391(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.sum");
+qi_list_data(list, 1) = qi_get(state, "sum");
+return list;
+}
+inline static qi_list_t *__qistd392(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "tuple.sum");
+qi_list_data(list, 1) = qi_get(state, "sum");
+return list;
+}
+inline static qi_list_t *__qistd393(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.product");
+qi_list_data(list, 1) = qi_get(state, "product");
+return list;
+}
+inline static qi_list_t *__qistd394(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "tuple.product");
+qi_list_data(list, 1) = qi_get(state, "product");
+return list;
+}
+inline static qi_list_t *__qistd397(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd396(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "map"), __qistd397(state));return state->nil;
+}
+inline static qi_list_t *__qistd395(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.map");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd396, NULL);
+return list;
+}
+inline static qi_list_t *__qistd400(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd399(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "map"), __qistd400(state));return state->nil;
+}
+inline static qi_list_t *__qistd398(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "tuple.map");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd399, NULL);
+return list;
+}
+inline static qi_list_t *__qistd403(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd402(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "map"), __qistd403(state));return state->nil;
+}
+inline static qi_list_t *__qistd401(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.map");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd402, NULL);
+return list;
+}
+inline static qi_list_t *__qistd406(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd405(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "map"), __qistd406(state));return state->nil;
+}
+inline static qi_list_t *__qistd404(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "bytes.map");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd405, NULL);
+return list;
+}
+inline static qi_list_t *__qistd409(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd408(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "filter"), __qistd409(state));return state->nil;
+}
+inline static qi_list_t *__qistd407(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "list.filter");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd408, NULL);
+return list;
+}
+inline static qi_list_t *__qistd412(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd411(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "filter"), __qistd412(state));return state->nil;
+}
+inline static qi_list_t *__qistd410(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "tuple.filter");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd411, NULL);
+return list;
+}
+inline static qi_list_t *__qistd415(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd414(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "filter"), __qistd415(state));return state->nil;
+}
+inline static qi_list_t *__qistd413(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.filter");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd414, NULL);
+return list;
+}
+inline static qi_list_t *__qistd418(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_get(state, "f");
+qi_list_data(list, 1) = qi_get(state, "xs");
+return list;
+}
+qi_value_t *__qistd417(qi_state_t *state, qi_size_t pargc, qi_list_t *pargs) {
+qi_decl(state, "f", qi_list_index(pargs, 1));
+qi_decl(state, "xs", qi_list_index(pargs, 0));
+return qi_call(state, qi_get(state, "filter"), __qistd418(state));return state->nil;
+}
+inline static qi_list_t *__qistd416(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "bytes.filter");
+qi_list_data(list, 1) = qi_make_function(state, "<anon>", 2, __qistd417, NULL);
+return list;
+}
+inline static qi_list_t *__qistd419(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.index");
+qi_list_data(list, 1) = qi_get(state, "str_index");
+return list;
+}
+inline static qi_list_t *__qistd420(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.lstrip");
+qi_list_data(list, 1) = qi_get(state, "str_lstrip");
+return list;
+}
+inline static qi_list_t *__qistd421(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.rstrip");
+qi_list_data(list, 1) = qi_get(state, "str_rstrip");
+return list;
+}
+inline static qi_list_t *__qistd422(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.strip");
+qi_list_data(list, 1) = qi_get(state, "str_strip");
+return list;
+}
+inline static qi_list_t *__qistd423(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "table.get");
+qi_list_data(list, 1) = qi_get(state, "table_get");
+return list;
+}
+inline static qi_list_t *__qistd424(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.toupper");
+qi_list_data(list, 1) = qi_get(state, "str_toupper");
+return list;
+}
+inline static qi_list_t *__qistd425(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.tolower");
+qi_list_data(list, 1) = qi_get(state, "str_tolower");
+return list;
+}
+inline static qi_list_t *__qistd426(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.format");
+qi_list_data(list, 1) = qi_get(state, "format");
+return list;
+}
+inline static qi_list_t *__qistd427(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.formatl");
+qi_list_data(list, 1) = qi_get(state, "formatl");
+return list;
+}
+inline static qi_list_t *__qistd428(qi_state_t *state) {
+qi_list_t *list = qi_list_make_n(2);
+qi_list_data(list, 0) = qi_make_string(state, "string.formatd");
+qi_list_data(list, 1) = qi_get(state, "formatd");
+return list;
+}
+static void qi_init_std(qi_state_t *state) {
+qi_set(state, false, "head", qi_make_function(state, "head", 1, __qistd0, NULL));
+qi_set(state, false, "tail", qi_make_function(state, "tail", 1, __qistd1, NULL));
+qi_set(state, false, "min", qi_make_function(state, "min", 2, __qistd3, NULL));
+qi_set(state, false, "max", qi_make_function(state, "max", 2, __qistd4, NULL));
+qi_set(state, false, "reverse", qi_make_function(state, "reverse", 1, __qistd5, NULL));
+qi_set(state, false, "range", qi_make_function(state, "range", 1, __qistd16, NULL));
+qi_set(state, false, "frewind", qi_make_function(state, "frewind", 1, __qistd29, NULL));
+qi_set(state, false, "file_read", qi_make_function(state, "file_read", 1, __qistd30, NULL));
+qi_set(state, false, "file_write", qi_make_function(state, "file_write", 2, __qistd36, NULL));
+qi_set(state, false, "is_defined", qi_make_function(state, "is_defined", 1, __qistd42, NULL));
+qi_set(state, false, "list_remove", qi_make_function(state, "list_remove", 2, __qistd45, NULL));
+qi_set(state, false, "list_join", qi_make_function(state, "list_join", 1, __qistd52, NULL));
+qi_set(state, false, "list_pop_at", qi_make_function(state, "list_pop_at", 2, __qistd62, NULL));
+qi_set(state, false, "list_sort", qi_make_function(state, "list_sort", 1, __qistd68, NULL));
+qi_set(state, false, "list_sorted", qi_make_function(state, "list_sorted", 1, __qistd79, NULL));
+qi_set(state, false, "list_shift", qi_make_function(state, "list_shift", 1, __qistd83, NULL));
+qi_set(state, false, "list_unshift", qi_make_function(state, "list_unshift", 2, __qistd88, NULL));
+qi_set(state, false, "slice", qi_make_function(state, "slice", 1, __qistd90, NULL));
+qi_set(state, false, "str_startswith", qi_make_function(state, "str_startswith", 2, __qistd115, NULL));
+qi_set(state, false, "str_endswith", qi_make_function(state, "str_endswith", 2, __qistd122, NULL));
+qi_set(state, false, "str_split", qi_make_function(state, "str_split", 1, __qistd130, NULL));
+qi_set(state, false, "str_replace", qi_make_function(state, "str_replace", 3, __qistd144, NULL));
+qi_set(state, false, "table_keys", qi_make_function(state, "table_keys", 1, __qistd156, NULL));
+qi_set(state, false, "table_values", qi_make_function(state, "table_values", 1, __qistd162, NULL));
+qi_set(state, false, "reduce", qi_make_function(state, "reduce", 2, __qistd168, NULL));
+qi_set(state, false, "sum", qi_make_function(state, "sum", 1, __qistd185, NULL));
+qi_set(state, false, "product", qi_make_function(state, "product", 1, __qistd188, NULL));
+qi_set(state, false, "map", qi_make_function(state, "map", 2, __qistd191, NULL));
+qi_set(state, false, "filter", qi_make_function(state, "filter", 2, __qistd208, NULL));
+qi_set(state, false, "str_index", qi_make_function(state, "str_index", 2, __qistd225, NULL));
+qi_set(state, false, "str_lstrip", qi_make_function(state, "str_lstrip", 1, __qistd235, NULL));
+qi_set(state, false, "str_rstrip", qi_make_function(state, "str_rstrip", 1, __qistd243, NULL));
+qi_set(state, false, "str_strip", qi_make_function(state, "str_strip", 1, __qistd252, NULL));
+qi_set(state, false, "table_get", qi_make_function(state, "table_get", 2, __qistd259, NULL));
+qi_set(state, false, "zip", qi_make_function(state, "zip", 0, __qistd264, NULL));
+qi_set(state, false, "enumerate", qi_make_function(state, "enumerate", 1, __qistd272, NULL));
+qi_set(state, false, "str_toupper", qi_make_function(state, "str_toupper", 1, __qistd280, NULL));
+qi_set(state, false, "str_tolower", qi_make_function(state, "str_tolower", 1, __qistd287, NULL));
+qi_set(state, false, "Object", qi_make_function(state, "Object", 1, __qistd294, NULL));
+qi_set(state, false, "is_object", qi_make_function(state, "is_object", 1, __qistd298, NULL));
+qi_set(state, false, "__class_wrapper", qi_make_function(state, "__class_wrapper", 5, __qistd300, NULL));
+qi_set(state, false, "format", qi_make_function(state, "format", 1, __qistd316, NULL));
+qi_set(state, false, "formatl", qi_make_function(state, "formatl", 2, __qistd326, NULL));
+qi_set(state, false, "formatd", qi_make_function(state, "formatd", 2, __qistd333, NULL));
+qi_set(state, false, "getch", qi_make_function(state, "getch", 0, __qistd346, NULL));
+qi_set(state, false, "putch", qi_make_function(state, "putch", 1, __qistd349, NULL));
+qi_set(state, false, "getline", qi_make_function(state, "getline", 0, __qistd351, NULL));
+qi_set(state, false, "input", qi_make_function(state, "input", 0, __qistd353, NULL));
+qi_set(state, false, "open", qi_make_function(state, "open", 1, __qistd357, NULL));
+qi_set(state, false, "assert", qi_make_function(state, "assert", 1, __qistd359, NULL));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd360(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd361(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd362(state)));
+qi_decl_const(state, "SEEK_END", qi_make_number(state, 2));
+qi_decl_const(state, "SEEK_CUR", qi_make_number(state, 1));
+qi_decl_const(state, "SEEK_SET", qi_make_number(state, 0));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd363(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd364(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd365(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd366(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd367(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd368(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd369(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd370(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd371(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd372(state)));
+qi_decl_const(state, "__slice", qi_get(state, "slice"));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd373(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd374(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd375(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd376(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd377(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd378(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd379(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd382(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd385(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd388(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd391(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd392(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd393(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd394(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd395(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd398(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd401(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd404(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd407(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd410(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd413(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd416(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd419(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd420(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd421(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd422(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd423(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd424(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd425(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd426(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd427(state)));
+(void)(qi_call(state, qi_get(state, "set_pseudomethod"), __qistd428(state)));
+}

std.qi

@@ -0,0 +1,520 @@
+func head(l): return l[0]
+func tail(l): return slice(l, 1)
+func min(x, y): x < y? x: y
+func max(x, y): x > y? x: y
+func reverse(x) {
+  if type(x) !in ("list", "string", "bytes")
+    throw "expected first argument to be: list, string or bytes, but got: " + type(x)
+  var r = []
+  for var i = len(x)-1; i >= 0; i--
+    list_push(r, x[i])
+  if type(x) == "string"
+    return list_join(r)
+  elif type(x) == "bytes"
+    return bytes(r)
+  return r
+}
+set_pseudomethod("list.reverse", reverse)
+set_pseudomethod("string.reverse", reverse)
+set_pseudomethod("bytes.reverse", reverse)
+func range(f) {
+  var t, s
+  if len(arguments) >= 3 {
+    t = arguments[1]
+    s = arguments[2]
+  } elif len(arguments) >= 2 {
+    t = arguments[1]
+    s = 1
+  } else {
+    t = f
+    f = 0
+    s = 1
+  }
+  if type(f) != "number"
+    throw "expected first argument to be: number, but got: " + type(f)
+  if type(t) != "number"
+    throw "expected second argument to be: number, but got: " + type(t)
+  if type(s) != "number"
+    throw "expected third argument to be: number, but got: " + type(s)
+  if f > t
+    return reverse(range(t, f, s))
+  var r = []
+  for var i = f; i < t; i += s
+    list_push(r, i)
+  return r
+}
+let SEEK_SET = 0, SEEK_CUR = 1, SEEK_END = 2
+func frewind(file)
+  return file.rewind()
+func file_read(filename) {
+  let file = fopen(filename, "r")
+  defer fclose(file)
+  return str(fread(file, -1))
+}
+func file_write(filename, data) {
+  let file = fopen(filename, "w")
+  defer fclose(file)
+  fwrite(file, bytes(data))
+}
+func is_defined(name) {
+  if type(name) != "string"
+    throw "expected first argument to be: string, but got: " + type(name)
+  inline `bool b = qi_find(state, qi_get(state, "name")->value.string) != NULL`
+  inline `return qi_make_boolean(state, b)`
+}
+func list_remove(l, x, first=false) {
+  if type(l) != "list"
+    throw "expected first argument to be: list, but got: " + type(l)
+  repeat:
+  for var i = 0; i < len(l); i++
+    if l[i] == x {
+      list_delete(l, i)
+      if first
+        break
+      goto repeat
+    }
+}
+set_pseudomethod("list.remove", list_remove)
+func list_join(l) {
+  if type(l) != "list"
+    throw "expected first argument to be: list, but got: " + type(l)
+  var r = ""
+  var s
+  if len(arguments) == 1
+    s = ""
+  else
+    s = arguments[1]
+  if type(s) != "string"
+    throw "expected second argument to be: string, but got: " + type(s)
+  var first = true
+  for var x of l {
+    if type(x) != "string"
+      throw "expected sequence item to be: string, but got: " + type(x)
+    if s != "" && !first
+      r += s
+    r += x
+    first = false
+  }
+  return r
+}
+set_pseudomethod("list.join", list_join)
+func list_pop_at(l, i) {
+  if type(l) != "list"
+    throw "expected first argument to be: list, but got: " + type(l)
+  if type(i) != "number"
+    throw "expected second argument to be: number, but got: " + type(i)
+  var x = l[i]
+  list_delete(l, i)
+  return x
+}
+set_pseudomethod("list.popAt", list_pop_at)
+func list_sort(l, cmp=func (x, y): x > y) {
+  if type(l) != "list"
+    throw "expected first argument to be: list, but got: " + type(l)
+  if type(cmp) != "function"
+    throw "expected second argument to be: function, but got: " + type(cmp)
+  if len(l) == 0
+    return l
+  var z = len(l)
+  for var i = 0; i < z - 1; i++
+    for var j = 0; j < z - 1 - i; j++
+      if cmp(l[j], l[j+1]) {
+        let tmp = l[j]
+        l[j] = l[j+1]
+        l[j+1] = tmp
+      }
+  return l
+}
+func list_sorted(l, cmp=func (x, y): x > y) {
+  l = list_copy(l)
+  return list_sort(l, cmp)
+}
+set_pseudomethod("list.sort", list_sort)
+set_pseudomethod("list.sorted", list_sorted)
+func list_shift(l) {
+  if type(l) != "list"
+    throw "expected first argument to be: list, but got: " + type(l)
+  if is_empty(l)
+    throw "shift from empty list"
+  var a = l[0]
+  list_delete(l, 0)
+  return a
+}
+func list_unshift(l, x) {
+  list_insert(l, 0, x)
+}
+set_pseudomethod("list.shift", list_shift)
+set_pseudomethod("list.unshift", list_unshift)
+func slice(l) {
+  if type(l) !in ("list", "string", "bytes")
+    throw "expected first argument to be: list, string or bytes, but got: " + type(l)
+  var r = []
+  if len(arguments) == 2 {
+    var f = arguments[1]
+    if type(f) != "number"
+      throw "expected second argument to be: number, but got: " + type(f)
+    if f < 0
+      f += len(l)
+    for var i = f; i < len(l); i++
+      list_push(r, l[i])
+  } elif len(arguments) == 3 {
+    var f = arguments[1], t = arguments[2]
+    if type(f) != "number"
+      throw "expected second argument to be: number, but got: " + type(f)
+    if type(t) != "number"
+      throw "expected third argument to be: number, but got: " + type(t)
+    if f < 0
+      f += len(l)
+    if t < 0
+      t += len(l)
+    for var i = f; i < len(l) && i <= t; i++
+      list_push(r, l[i])
+  }
+  if type(l) == "string"
+    return list_join(r)
+  elif type(l) == "bytes"
+    return bytes(r)
+  return r
+}
+set_pseudomethod("list.slice", slice)
+set_pseudomethod("string.slice", slice)
+set_pseudomethod("bytes.slice", slice)
+let __slice = slice;
+func str_startswith(s, p) {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  if len(s) < len(p)
+    return false
+  return slice(s, 0, len(p)-1) == p
+}
+set_pseudomethod("string.startsWith", str_startswith)
+func str_endswith(s, p) {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  if len(s) < len(p)
+    return false
+  return slice(s, len(s) - len(p)) == p
+}
+set_pseudomethod("string.endsWith", str_endswith)
+func str_split(s) {
+  if len(arguments) == 1 || arguments[1] == ""
+    return list(s)
+  if type(s) != "string"
+    throw "expected first argument to be:!string, but got: " + type(s)
+  var r = []
+  var d = arguments[1]
+  if type(d) != "string"
+    throw "expected second argument to be: string, but got: " + type(s)
+  var t = ""
+  for var i = 0; i < len(s); i++ {
+    if slice(s, i, i+len(d)-1) == d {
+      list_push(r, t)
+      t = ""
+      i += len(d)-1
+      continue
+    }
+    t += s[i]
+  }
+  if t != ""
+    list_push(r, t)
+  return r
+}
+set_pseudomethod("string.split", str_split)
+func str_replace(s, w, b) {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  if type(w) != "string"
+    throw "expected second argument to be: string, but got: " + type(w)
+  if type(b) != "string"
+    throw "expected third argument to be: string, but got: " + type(b)
+  var r = ""
+  for var i = 0; i < len(s); i++ {
+    if slice(s, i, i+len(w)-1) == w {
+      r += b
+      i += len(w)-1
+      continue
+    }
+    r += s[i]
+  }
+  return r
+}
+set_pseudomethod("string.replace", str_replace)
+func table_keys(t) {
+  if type(t) != "table"
+    throw "expected first argument to be: table, but got: " + type(t)
+  var r = []
+  for var k of t
+    list_push(r, k)
+  return r
+}
+set_pseudomethod("table.keys", table_keys)
+func table_values(t) {
+  if type(t) != "table"
+    throw "expected first argument to be: table, but got: " + type(t)
+  var r = []
+  for var k of t
+    list_push(r, t[k])
+  return r
+}
+set_pseudomethod("table.values", table_values)
+func reduce(f, xs) {
+  if type(f) != "function"
+    throw "expected first argument to be: function, but got: " + type(f)
+  if type(xs) !in ("list", "tuple", "string", "bytes")
+    throw "expected second argument to be: list, tuple, string or bytes, but got: " + type(xs)
+  if len(xs) == 0
+    throw "cannot reduce empty list"
+  r = xs[0]
+  for var x of slice(xs, 1)
+    r = f(r, x)
+  if type(xs) == "tuple"
+    return tuple(r)
+  elif type(xs) == "string"
+    return list_join(r)
+  elif type(xs) == "bytes"
+    return bytes(r)
+  return r
+}
+set_pseudomethod("list.reduce", func (xs, f): reduce(f, xs))
+set_pseudomethod("tuple.reduce", func (xs, f): reduce(f, xs))
+set_pseudomethod("string.reduce", func (xs, f): reduce(f, xs))
+set_pseudomethod("bytes.reduce", func (xs, f): reduce(f, xs))
+func sum(xs)
+  return reduce(func (x, y): x + y, xs)
+set_pseudomethod("list.sum", sum)
+set_pseudomethod("tuple.sum", sum)
+func product(xs)
+  return reduce(func (x, y): x * y, xs)
+set_pseudomethod("list.product", product)
+set_pseudomethod("tuple.product", product)
+func map(f, xs) {
+  if type(f) != "function"
+    throw "expected first argument to be: function, but got: " + type(f)
+  if type(xs) !in ("list", "tuple", "string", "bytes")
+    throw "expected second argument to be: list, tuple, string or bytes, but got: " + type(xs)
+  if len(xs) == 0
+    return xs
+  var r = []
+  for var x of xs
+    list_push(r, f(x))
+  if type(xs) == "tuple"
+    return tuple(r)
+  elif type(xs) == "string"
+    return list_join(r)
+  elif type(xs) == "bytes"
+    return bytes(r)
+  return r
+}
+set_pseudomethod("list.map", func (xs, f): map(f, xs))
+set_pseudomethod("tuple.map", func (xs, f): map(f, xs))
+set_pseudomethod("string.map", func (xs, f): map(f, xs))
+set_pseudomethod("bytes.map", func (xs, f): map(f, xs))
+func filter(f, xs) {
+  if type(f) != "function"
+    throw "expected first argument to be: function, but got: " + type(f)
+  if type(xs) !in ("list", "tuple", "string", "bytes")
+    throw "expected second argument to be: list, tuple, string or bytes, but got: " + type(xs)
+  if len(xs) == 0
+    return xs
+  var r = []
+  for var x of xs
+    if f(x)
+      list_push(r, x)
+  if type(xs) == "tuple"
+    return tuple(r)
+  elif type(xs) == "string"
+    return list_join(r)
+  elif type(xs) == "bytes"
+    return bytes(r)
+  return r
+}
+set_pseudomethod("list.filter", func (xs, f): filter(f, xs))
+set_pseudomethod("tuple.filter", func (xs, f): filter(f, xs))
+set_pseudomethod("string.filter", func (xs, f): filter(f, xs))
+set_pseudomethod("bytes.filter", func (xs, f): filter(f, xs))
+func str_index(s, w) {
+  if s == "" || w == ""
+    return -1
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  if type(w) != "string"
+    throw "expected second argument to be: string, but got: " + type(w)
+  for var i = 0; i < len(s); i++
+    if len(w) == 1 && s[i] == w
+      return i
+    elif slice(s, i, i+len(w)-1) == w
+      return i
+  return -1
+}
+set_pseudomethod("string.index", str_index)
+func str_lstrip(s, cs=" \t\n\r\x0b\x0c") {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  if type(cs) != "string"
+    throw "expected second argument to be: string, but got: " + type(cs)
+  if s == ""
+    return s
+  for var i = 0; s[i] in cs && i < len(s); i++
+    pass
+  return slice(s, i)
+}
+set_pseudomethod("string.lstrip", str_lstrip)
+func str_rstrip(s, cs=" \t\n\r\x0b\x0c") {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  if type(cs) != "string"
+    throw "expected second argument to be: string, but got: " + type(cs)
+  if s == ""
+    return s
+  for var k = 0, i = len(s)-1; s[i] in cs && i >= 0; k++
+    i--
+  return slice(s, 0, len(s)-k-1)
+}
+set_pseudomethod("string.rstrip", str_rstrip)
+func str_strip(s, cs=" \t\n\r\x0b\x0c") {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  if type(cs) != "string"
+    throw "expected second argument to be: string, but got: " + type(cs)
+  return str_lstrip(str_rstrip(s, cs), cs)
+}
+set_pseudomethod("string.strip", str_strip)
+func table_get(t, k, d=nil) {
+  if type(t) != "table"
+    throw "expected first argument to be: table, but got: " + type(t)
+  if type(k) != "string"
+    throw "expected second argument to be: string, but got: " + type(k)
+  if k !in t
+    return d
+  return t[k]
+}
+set_pseudomethod("table.get", table_get)
+func zip() {
+  if !arguments
+    return []
+  var l = map(len, arguments)
+  l = reduce(min, l)
+  var r = []
+  for var i = 0; i < l; i++ {
+    var t = []
+    for var xs of arguments
+      list_push(t, xs[i])
+    list_push(r, t)
+  }
+  return r
+}
+func enumerate(l)
+  if type(l) == "table"
+    return zip(table_keys(l), table_values(l))
+  else
+    return zip(range(len(l)), l)
+func str_toupper(s) {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(c)
+  return map(func (c): c >= 'a' && c <= 'z'? chr(ord(c) - 32): c, s)
+}
+set_pseudomethod("string.toupper", str_toupper)
+func str_tolower(s) {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(c)
+  return map(func (c): c >= 'A' && c <= 'Z'? chr(ord(c) + 32): c, s)
+}
+set_pseudomethod("string.tolower", str_tolower)
+func Object(t, p=nil): return p !is nil? set_meta_table(p, get_meta_table(p) + t): set_meta_table({}, t)
+func is_object(o): return has_meta_table(o)
+func __class_wrapper(n, p, t, mt, st): return Object(st + {
+    t: t,
+    mt: mt,
+    super: [],
+    __type: func (this) use (n): return n,
+    __str: func (this) use (n): return "<class " + n + ">",
+    __call: func (this, pargs) use (p) {
+        var t = {}
+        var mt = {}
+        for var other of p {
+            t += other.t
+            mt += other.mt
+            list_push(this.super, other)
+        }
+        if len(this.super) == 1
+          this.super = this.super[0]
+        t += this.t
+        mt += this.mt
+        t.super = this.super
+        obj = set_meta_table(t, mt)
+        if "constructor" in mt
+          func_call(mt.constructor, [obj] + pargs)
+        return obj
+    }
+})
+func format(s) {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  var r = ""
+  var n = 1
+  for var i = 0; i < len(s); i++
+    switch s[i] {
+      case '_'
+        if i+1 < len(s) && s[i+1] == '_' {
+          r += '_'
+          i++
+          continue
+        }
+        r += repr(arguments[n++])
+        break
+      default
+        r += s[i]
+    }
+  return r
+}
+set_pseudomethod("string.format", format)
+func formatl(s, l) {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  if type(l) != "list"
+    throw "expected second argument to be: list, but got: " + type(l)
+  return func_call(str_format, [s] + l)
+}
+set_pseudomethod("string.formatl", formatl)
+func formatd(s, t) {
+  if type(s) != "string"
+    throw "expected first argument to be: string, but got: " + type(s)
+  var r = ""
+  var n = 1
+  for var i = 0; i < len(s); i++
+    switch s[i] {
+      case '{'
+        if i+1 < len(s) && s[i+1] == '{' {
+          r += '{'
+          i++
+          continue
+        }
+        var k = ''
+        i++
+        for i < len(s) && s[i] != '}'
+          k += s[i++]
+        if i >= len(s) || s[i] != '}'
+          throw "unmatched { in format specifier"
+        if !k
+          throw "empty format key"
+        r += repr(t[k])
+        break
+      default
+        r += s[i]
+    }
+  return r
+}
+set_pseudomethod("string.formatd", formatd)
+func getch() return chr(fgetc(STDIN))
+func putch(c) fputc(STDOUT, c)
+func getline()
+  return fgets(STDIN, 256)
+func input() {
+  if len(arguments) > 0
+    func_call(print, arguments)
+  return str_rstrip(getline(), "\n\r")
+}
+func open(path, mode="r"): fopen(path, mode)
+func assert(cond, msg="assertion failed")
+  if !cond
+    throw msg