#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "runtime.h"

// Labels:
// 0 fetch
// 1 nothing
// 2 die
// 3 just
// 4 root_path
// 5 analyze
// 6 emit
// 7 cons
// 8 sym
// 9 equal
// 10 clip
// 11 length
// 12 id
// 13 tuple
// 14 reverse
// 15 concat
// 16 ignore
// 17 var
// 18 left
// 19 right
// 20 name
// 21 precedence
// 22 associativity
// 23 for_each
// 24 let
// 25 func
// 26 nil
// 27 app
// 28 append
// 29 prim
// 30 num
// 31 do
// 32 block
// 33 value
// 34 default
// 35 labeled
// 36 str
// 37 is_digit
// 38 is_letter
// 39 is_lower
// 40 is_upper
// 41 list
// 42 switch
// 43 match
// 44 or
// 45 and
// 46 not
// 47 false
// 48 true
// 49 if
// 50 cond
// 51 goto
// 52 package
// 53 module
// 54 chain
// 55 eof
// 56 insert
// 57 imports
// 58 path
// 59 MAP
// 60 compare
// 61 G
// 62 reduce
// 63 empty
// 64 strongly_connected_components
// 65 fold
// 66 token
// 67 whitespace
// 68 SET
// 69 filter
// 70 search
// 71 file_open
// 72 file_read_all
// 73 file_close
// 74 text
// 75 tokens
// 76 tree
// 77 vertex
// 78 neighbors
// 79 depth
// 80 closure
// 81 init
// 82 functions
// 83 nontail
// 84 jump
// 85 pop_vars
// 86 tail
// 87 alloc_tuple
// 88 swap
// 89 push
// 90 jump_if_false
// 91 no_push
// 92 push_and_jump
// 93 open_tuple
// 94 stack
// 95 pop_frame
// 96 label
// 97 labeled_empty_tuple
// 98 jump_if_true
// 99 halt
// 100 tailcall
// 101 entry
// 102 alloc_closure
// 103 call
// 104 push_frame
// 105 alloc_module
// 106 self
// 107 free
// 108 const
// 109 map
// 110 less
// 111 greater
// 112 list_insertion
// 113 constants
// 114 packages
// 115 zip
// 116 tuple_fetch
// 117 module_fetch
// 118 label_names
// 119 module_indexes
// 120 nil_label
// 121 cons_label
// 122 package_env_store
// 123 init_code
// 124 function_code
// 125 reverse_append
// 126 last
// 127 show
// 128 for_each_numbered
// 129 file_write
// 130 prim_arity
// 131 file_create
// 132 print_line
// 133 two
// 134 no_split
// 135 split
// 136 one
// 137 root
// 138 item_key
// 139 zero
// 140 union
// 141 read
// 142 join

uint16_t module_indices[] = {
    4, UINT16_MAX,
    5, UINT16_MAX,
    20, 21, 22, UINT16_MAX,
    57, 58, 74, 75, 76, UINT16_MAX,
    61, UINT16_MAX,
    77, 78, UINT16_MAX,
    64, UINT16_MAX,
    37, 38, 39, 40, UINT16_MAX,
    20, 79, UINT16_MAX,
    57, 58, 81, 82, UINT16_MAX,
    113, 114, UINT16_MAX,
    113, 114, 118, 119, 120, 121, UINT16_MAX,
    113, 114, 118, 119, 120, 121, 123, 124, UINT16_MAX,
    112, UINT16_MAX,
    6, UINT16_MAX,
    130, UINT16_MAX,
    59, 68, UINT16_MAX,
    79, 137, UINT16_MAX,
    41, 56, 60, 63, 70, 138, UINT16_MAX,
    41, 56, 60, 63, 70, 140, UINT16_MAX,
    60, 127, 141, UINT16_MAX,
    0, 9, 10, 11, 15, 28, 60, 142, UINT16_MAX,
    132, UINT16_MAX,
    2, 71, 72, 73, 129, 131, UINT16_MAX,
    0, 11, 14, 15, 23, 28, 62, 65, 69, 109, 115, 125, 126, 128, UINT16_MAX,
};

void *
run_machine(int argc, const char *argv[])
{
    struct value *stack;
    struct heap heap;
    struct value *closure_env;
    struct value *constant_env;
    struct value *package_env;
    struct value c;
    struct value a;
    uint32_t fp;
    uint32_t sp;

entry_0:
    heap.size = 256*1024*1024;
    heap.values = malloc(sizeof(struct value) * heap.size);
    heap.top = 0;
    stack = malloc(sizeof(struct value) * 4096);
    fp = 0;
    sp = 0;
    constant_env = malloc(283 * sizeof(struct value));
    package_env = malloc(15 * sizeof(struct value));
    constant_env[0] = alloc_string(&heap, "Usage error.");
    constant_env[1] = alloc_prim(&heap, 1, prim_die);
    constant_env[2] = alloc_prim(&heap, 2, prim_add);
    constant_env[3] = alloc_prim(&heap, 1, prim_negate);
    constant_env[4] = alloc_string(&heap, "Malformed tuple pattern.");
    constant_env[5] = alloc_prim(&heap, 2, prim_cons);
    constant_env[6] = alloc_string(&heap, "_");
    constant_env[7] = alloc_string(&heap, "}");
    constant_env[8] = alloc_string(&heap, "Malformed Let binder.");
    constant_env[9] = alloc_string(&heap, ".");
    constant_env[10] = alloc_string(&heap, "Expected identifier.");
    constant_env[11] = alloc_string(&heap, "Token is not ");
    constant_env[12] = alloc_string(&heap, " token but got ");
    constant_env[13] = alloc_string(&heap, "Expected ");
    constant_env[14] = alloc_string(&heap, "Malformed parameter list.");
    constant_env[15] = alloc_string(&heap, "{");
    constant_env[16] = alloc_string(&heap, "apply");
    constant_env[17] = alloc_string(&heap, "*");
    constant_env[18] = alloc_string(&heap, "multiply");
    constant_env[19] = alloc_string(&heap, "+");
    constant_env[20] = alloc_string(&heap, "add");
    constant_env[21] = alloc_string(&heap, "<");
    constant_env[22] = alloc_string(&heap, "less");
    constant_env[23] = alloc_string(&heap, "=");
    constant_env[24] = alloc_string(&heap, "less_or_equal");
    constant_env[25] = alloc_string(&heap, ">");
    constant_env[26] = alloc_string(&heap, "greater");
    constant_env[27] = alloc_string(&heap, "greater_or_equal");
    constant_env[28] = alloc_string(&heap, "equal");
    constant_env[29] = alloc_string(&heap, ":");
    constant_env[30] = alloc_string(&heap, "cons");
    constant_env[31] = alloc_string(&heap, "Unrecognized binary operator \":\".");
    constant_env[32] = alloc_string(&heap, "!");
    constant_env[33] = alloc_string(&heap, "ref_store");
    constant_env[34] = alloc_string(&heap, "$");
    constant_env[35] = alloc_string(&heap, ")");
    constant_env[36] = alloc_string(&heap, "Malformed Define binder.");
    constant_env[37] = alloc_string(&heap, "Expected . in Let binder.");
    constant_env[38] = alloc_prim(&heap, 2, prim_less);
    constant_env[39] = alloc_string(&heap, "Malformed function application expression.");
    constant_env[40] = alloc_string(&heap, "Let");
    constant_env[41] = alloc_string(&heap, "Define");
    constant_env[42] = alloc_string(&heap, "Do");
    constant_env[43] = alloc_string(&heap, "In");
    constant_env[44] = alloc_string(&heap, "Malformed block body.");
    constant_env[45] = alloc_string(&heap, "Malformed Switch pattern.");
    constant_env[46] = alloc_string(&heap, "-");
    constant_env[47] = alloc_string(&heap, "Malformed Match pattern.");
    constant_env[48] = alloc_string(&heap, "`");
    constant_env[49] = alloc_prim(&heap, 2, prim_equal);
    constant_env[50] = alloc_string(&heap, "Expected quotation mark to begin character literal.");
    constant_env[51] = alloc_string(&heap, "Character literal contains newline character.");
    constant_env[52] = alloc_string(&heap, "Empty character literal.");
    constant_env[53] = alloc_string(&heap, "Invalid character escape sequence.");
    constant_env[54] = alloc_string(&heap, "Expected quotation mark to end character literal.");
    constant_env[55] = alloc_string(&heap, "String literal contains newline.");
    constant_env[56] = alloc_string(&heap, "Expected quotation mark to begin string literal.");
    constant_env[57] = alloc_prim(&heap, 2, prim_multiply);
    constant_env[58] = alloc_string(&heap, "Malformed Switch expression.");
    constant_env[59] = alloc_string(&heap, "|");
    constant_env[60] = alloc_string(&heap, ";");
    constant_env[61] = alloc_string(&heap, "Malformed Match expression.");
    constant_env[62] = alloc_string(&heap, "Malformed Cond expression.");
    constant_env[63] = alloc_string(&heap, "]");
    constant_env[64] = alloc_string(&heap, "No parse.");
    constant_env[65] = alloc_string(&heap, "Block");
    constant_env[66] = alloc_string(&heap, "Begin");
    constant_env[67] = alloc_string(&heap, "Expected Define form in Begin expression.");
    constant_env[68] = alloc_string(&heap, "Func");
    constant_env[69] = alloc_string(&heap, "Switch");
    constant_env[70] = alloc_string(&heap, "Match");
    constant_env[71] = alloc_string(&heap, "Or");
    constant_env[72] = alloc_string(&heap, "And");
    constant_env[73] = alloc_string(&heap, "Not");
    constant_env[74] = alloc_string(&heap, "False");
    constant_env[75] = alloc_string(&heap, "True");
    constant_env[76] = alloc_string(&heap, "When");
    constant_env[77] = alloc_string(&heap, "If");
    constant_env[78] = alloc_string(&heap, "Cond");
    constant_env[79] = alloc_string(&heap, "Goto");
    constant_env[80] = alloc_string(&heap, "Goto expression is not an application.");
    constant_env[81] = alloc_string(&heap, "Package");
    constant_env[82] = alloc_string(&heap, "Prim");
    constant_env[83] = alloc_string(&heap, "[");
    constant_env[84] = alloc_string(&heap, "Malformed module expression.");
    constant_env[85] = alloc_string(&heap, "(");
    constant_env[86] = alloc_string(&heap, "?");
    constant_env[87] = alloc_string(&heap, "ref_fetch");
    constant_env[88] = alloc_string(&heap, "&");
    constant_env[89] = alloc_string(&heap, "ref_new");
    constant_env[90] = alloc_string(&heap, "negate");
    constant_env[91] = alloc_string(&heap, "Malformed file block.");
    constant_env[92] = alloc_string(&heap, "Where");
    constant_env[93] = alloc_prim(&heap, 2, prim_greater);
    constant_env[94] = alloc_string(&heap, "There is a circular dependency among the packages.");
    constant_env[95] = alloc_string(&heap, ".84");
    constant_env[96] = alloc_prim(&heap, 2, prim_less_or_equal);
    constant_env[97] = alloc_string(&heap, "\" is not bound.");
    constant_env[98] = alloc_string(&heap, "Variable \"");
    constant_env[99] = alloc_string(&heap, "Goto used in nontail position.");
    constant_env[100] = alloc_string(&heap, "Package not found.");
    constant_env[101] = alloc_string(&heap, "Unexpected constant.");
    constant_env[102] = alloc_prim(&heap, 1, prim_ref_fetch);
    constant_env[103] = alloc_prim(&heap, 2, prim_ref_store);
    constant_env[104] = alloc_prim(&heap, 1, prim_ref_new);
    constant_env[105] = alloc_string(&heap, "Invalid label in module expression.");
    constant_env[106] = alloc_string(&heap, "Label sorting bug in module expr.");
    constant_env[107] = alloc_string(&heap, "nil");
    constant_env[108] = alloc_string(&heap, "place_variables: Unexpected unbound variable.");
    constant_env[109] = alloc_string(&heap, "No packages.");
    constant_env[110] = alloc_string(&heap, ", ");
    constant_env[111] = alloc_string(&heap, "    closure_store(&heap, a, ");
    constant_env[112] = alloc_string(&heap, "Place not implemented.");
    constant_env[113] = alloc_string(&heap, "c");
    constant_env[114] = alloc_string(&heap, "closure_env[");
    constant_env[115] = alloc_string(&heap, "var(");
    constant_env[116] = alloc_string(&heap, ");\n");
    constant_env[117] = alloc_string(&heap, ";\n");
    constant_env[118] = alloc_string(&heap, "        goto block_");
    constant_env[119] = alloc_string(&heap, ":\n");
    constant_env[120] = alloc_string(&heap, "    case ");
    constant_env[121] = alloc_string(&heap, "        sp += ");
    constant_env[122] = alloc_string(&heap, "        open_tuple(&heap, &stack[sp], a, ");
    constant_env[123] = alloc_string(&heap, "        a = remove_label(&heap, a);\n");
    constant_env[124] = alloc_string(&heap, "        push_var(a);\n");
    constant_env[125] = alloc_string(&heap, "Unknown instruction.");
    constant_env[126] = alloc_string(&heap, "    a = tuple_fetch(&heap, a, ");
    constant_env[127] = alloc_string(&heap, "    a = module_fetch(&heap, a, ");
    constant_env[128] = alloc_string(&heap, " - &&entry_0);\n");
    constant_env[129] = alloc_string(&heap, "&&entry_");
    constant_env[130] = alloc_string(&heap, "    a = alloc_closure(&heap, ");
    constant_env[131] = alloc_string(&heap, "    a = number(");
    constant_env[132] = alloc_string(&heap, "    a = c;\n");
    constant_env[133] = alloc_string(&heap, "];\n");
    constant_env[134] = alloc_string(&heap, "    a = closure_env[");
    constant_env[135] = alloc_string(&heap, "    a = var(");
    constant_env[136] = alloc_string(&heap, "    goto enter;\n");
    constant_env[137] = alloc_string(&heap, "    sp = fp + ");
    constant_env[138] = alloc_string(&heap, "*sizeof(struct value));\n");
    constant_env[139] = alloc_string(&heap, "    memmove(stack+fp+3, stack+sp-");
    constant_env[140] = alloc_string(&heap, "    fp = sp - ");
    constant_env[141] = alloc_string(&heap, "entry_");
    constant_env[142] = alloc_string(&heap, "    goto pop_frame;\n");
    constant_env[143] = alloc_string(&heap, "    push_frame(block_");
    constant_env[144] = alloc_string(&heap, "    switch (value_label(&heap, a)) {\n");
    constant_env[145] = alloc_string(&heap, "    default:\n");
    constant_env[146] = alloc_string(&heap, "        halt();\n");
    constant_env[147] = alloc_string(&heap, "    }\n");
    constant_env[148] = alloc_string(&heap, "    switch (value_unbox_int32(a)) {\n");
    constant_env[149] = alloc_string(&heap, "    halt();\n");
    constant_env[150] = alloc_string(&heap, ", a);\n");
    constant_env[151] = alloc_string(&heap, "    a = alloc_labeled_value(&heap, ");
    constant_env[152] = alloc_string(&heap, "    a = labeled_empty_tuple(");
    constant_env[153] = alloc_string(&heap, "    if (a.bits == true_value.bits) goto block_");
    constant_env[154] = alloc_string(&heap, "    if (a.bits == false_value.bits) goto block_");
    constant_env[155] = alloc_string(&heap, "    goto block_");
    constant_env[156] = alloc_string(&heap, "block_");
    constant_env[157] = alloc_string(&heap, "    a = (a.bits == true_value.bits) ? false_value : true_value;\n");
    constant_env[158] = alloc_string(&heap, "    a = false_value;\n");
    constant_env[159] = alloc_string(&heap, "    a = true_value;\n");
    constant_env[160] = alloc_string(&heap, "    pop_vars(");
    constant_env[161] = alloc_string(&heap, "], ");
    constant_env[162] = alloc_string(&heap, "&stack[sp-");
    constant_env[163] = alloc_string(&heap, "    a = alloc_module(&heap, ");
    constant_env[164] = alloc_string(&heap, "    a = empty_tuple;\n");
    constant_env[165] = alloc_string(&heap, "    a = alloc_tuple(&heap, &stack[sp-");
    constant_env[166] = alloc_string(&heap, "    stack[sp-2] = a;\n");
    constant_env[167] = alloc_string(&heap, "    stack[sp-1] = stack[sp-2];\n");
    constant_env[168] = alloc_string(&heap, "    a = stack[sp-1];\n");
    constant_env[169] = alloc_string(&heap, "] = a;\n");
    constant_env[170] = alloc_string(&heap, "    package_env[");
    constant_env[171] = alloc_string(&heap, "    a = package_env[");
    constant_env[172] = alloc_string(&heap, "    a = constant_env[");
    constant_env[173] = alloc_string(&heap, "    sp += ");
    constant_env[174] = alloc_string(&heap, "    open_tuple(&heap, &stack[sp], a, ");
    constant_env[175] = alloc_string(&heap, "    push_var(a);\n");
    constant_env[176] = alloc_string(&heap, "\n");
    constant_env[177] = alloc_string(&heap, " ");
    constant_env[178] = alloc_string(&heap, "// ");
    constant_env[179] = alloc_string(&heap, "    ");
    constant_env[180] = alloc_string(&heap, "UINT16_MAX,\n");
    constant_env[181] = alloc_string(&heap, ", prim_");
    constant_env[182] = alloc_string(&heap, "] = alloc_prim(&heap, ");
    constant_env[183] = alloc_string(&heap, "    constant_env[");
    constant_env[184] = alloc_string(&heap, "] = alloc_string(&heap, ");
    constant_env[185] = alloc_string(&heap, ", var(");
    constant_env[186] = alloc_string(&heap, "prim_");
    constant_env[187] = alloc_string(&heap, "(&heap");
    constant_env[188] = alloc_string(&heap, "    a = prim_");
    constant_env[189] = alloc_string(&heap, ".c");
    constant_env[190] = alloc_string(&heap, "#include <stdint.h>\n");
    constant_env[191] = alloc_string(&heap, "#include <stdio.h>\n");
    constant_env[192] = alloc_string(&heap, "#include <stdlib.h>\n");
    constant_env[193] = alloc_string(&heap, "#include <string.h>\n");
    constant_env[194] = alloc_string(&heap, "#include \"runtime.h\"\n");
    constant_env[195] = alloc_string(&heap, "// Labels:\n");
    constant_env[196] = alloc_string(&heap, "uint16_t module_indices[] = {\n");
    constant_env[197] = alloc_string(&heap, "};\n");
    constant_env[198] = alloc_string(&heap, "void *\n");
    constant_env[199] = alloc_string(&heap, "run_machine(int argc, const char *argv[])\n");
    constant_env[200] = alloc_string(&heap, "{\n");
    constant_env[201] = alloc_string(&heap, "    struct value *stack;\n");
    constant_env[202] = alloc_string(&heap, "    struct heap heap;\n");
    constant_env[203] = alloc_string(&heap, "    struct value *closure_env;\n");
    constant_env[204] = alloc_string(&heap, "    struct value *constant_env;\n");
    constant_env[205] = alloc_string(&heap, "    struct value *package_env;\n");
    constant_env[206] = alloc_string(&heap, "    struct value c;\n");
    constant_env[207] = alloc_string(&heap, "    struct value a;\n");
    constant_env[208] = alloc_string(&heap, "    uint32_t fp;\n");
    constant_env[209] = alloc_string(&heap, "    uint32_t sp;\n");
    constant_env[210] = alloc_string(&heap, "entry_0:\n");
    constant_env[211] = alloc_string(&heap, "    heap.size = 256*1024*1024;\n");
    constant_env[212] = alloc_string(&heap, "    heap.values = malloc(sizeof(struct value) * heap.size);\n");
    constant_env[213] = alloc_string(&heap, "    heap.top = 0;\n");
    constant_env[214] = alloc_string(&heap, "    stack = malloc(sizeof(struct value) * 4096);\n");
    constant_env[215] = alloc_string(&heap, "    fp = 0;\n");
    constant_env[216] = alloc_string(&heap, "    sp = 0;\n");
    constant_env[217] = alloc_string(&heap, " * sizeof(struct value));\n");
    constant_env[218] = alloc_string(&heap, "    constant_env = malloc(");
    constant_env[219] = alloc_string(&heap, "    package_env = malloc(");
    constant_env[220] = alloc_string(&heap, "    push_frame(return_from_main);\n");
    constant_env[221] = alloc_string(&heap, "    for (int i = argc-1; i >= 0; i--) {\n");
    constant_env[222] = alloc_string(&heap, "        struct value values[2] = {alloc_string(&heap, argv[i]), a};\n");
    constant_env[223] = alloc_string(&heap, "        a = alloc_tuple(&heap, values, 2);\n");
    constant_env[224] = alloc_string(&heap, "        a = alloc_labeled_value(&heap, ");
    constant_env[225] = alloc_string(&heap, "    fp = sp - 4;\n");
    constant_env[226] = alloc_string(&heap, "return_from_main:\n");
    constant_env[227] = alloc_string(&heap, "    free(heap.values);\n");
    constant_env[228] = alloc_string(&heap, "    free(stack);\n");
    constant_env[229] = alloc_string(&heap, "    free(constant_env);\n");
    constant_env[230] = alloc_string(&heap, "    free(package_env);\n");
    constant_env[231] = alloc_string(&heap, "    return NULL;\n");
    constant_env[232] = alloc_string(&heap, "    pop_vars(2);\n");
    constant_env[233] = alloc_string(&heap, "    a = alloc_tuple(&heap, &stack[sp-2], 2);\n");
    constant_env[234] = alloc_string(&heap, "    a = var(1);\n");
    constant_env[235] = alloc_string(&heap, "    a = var(0);\n");
    constant_env[236] = alloc_string(&heap, "prim_cons:\n");
    constant_env[237] = alloc_string(&heap, "enter:\n");
    constant_env[238] = alloc_string(&heap, "    {\n");
    constant_env[239] = alloc_string(&heap, "        c = a;\n");
    constant_env[240] = alloc_string(&heap, "        if (!has_tag(c, TAG_CLOSURE)) halt;\n");
    constant_env[241] = alloc_string(&heap, "        struct closure *closure = (struct closure *)address(&heap, c);\n");
    constant_env[242] = alloc_string(&heap, "        if (closure->num_params != sp - (fp + 3)) halt();\n");
    constant_env[243] = alloc_string(&heap, "        closure_env = closure->free_values;\n");
    constant_env[244] = alloc_string(&heap, "        goto *(&&entry_0 + closure->code_offset);\n");
    constant_env[245] = alloc_string(&heap, "pop_frame:\n");
    constant_env[246] = alloc_string(&heap, "        struct value *frame = &stack[fp];\n");
    constant_env[247] = alloc_string(&heap, "        sp = fp;\n");
    constant_env[248] = alloc_string(&heap, "        c = frame[0];\n");
    constant_env[249] = alloc_string(&heap, "        fp = frame[1].bits;\n");
    constant_env[250] = alloc_string(&heap, "        goto *(&&entry_0 + (int32_t)frame[2].bits);\n");
    constant_env[251] = alloc_string(&heap, "}\n");
    constant_env[252] = alloc_string(&heap, "show_integer");
    constant_env[253] = alloc_string(&heap, "print_line");
    constant_env[254] = alloc_string(&heap, "string_clip");
    constant_env[255] = alloc_string(&heap, "string_append");
    constant_env[256] = alloc_string(&heap, "string_compare");
    constant_env[257] = alloc_string(&heap, "string_equal");
    constant_env[258] = alloc_string(&heap, "string_fetch");
    constant_env[259] = alloc_string(&heap, "string_length");
    constant_env[260] = alloc_string(&heap, "file_write");
    constant_env[261] = alloc_string(&heap, "file_read_all");
    constant_env[262] = alloc_string(&heap, "file_close");
    constant_env[263] = alloc_string(&heap, "file_open");
    constant_env[264] = alloc_string(&heap, "file_create");
    constant_env[265] = alloc_string(&heap, "die");
    constant_env[266] = alloc_string(&heap, "\".");
    constant_env[267] = alloc_string(&heap, "No such primitive \"");
    constant_env[268] = alloc_prim(&heap, 1, prim_show_integer);
    constant_env[269] = alloc_prim(&heap, 2, prim_greater_or_equal);
    constant_env[270] = alloc_prim(&heap, 2, prim_string_append);
    constant_env[271] = alloc_prim(&heap, 2, prim_string_equal);
    constant_env[272] = alloc_prim(&heap, 1, prim_string_length);
    constant_env[273] = alloc_prim(&heap, 2, prim_string_fetch);
    constant_env[274] = alloc_prim(&heap, 3, prim_string_clip);
    constant_env[275] = alloc_string(&heap, "");
    constant_env[276] = alloc_prim(&heap, 2, prim_string_compare);
    constant_env[277] = alloc_prim(&heap, 1, prim_print_line);
    constant_env[278] = alloc_prim(&heap, 1, prim_file_create);
    constant_env[279] = alloc_prim(&heap, 1, prim_file_open);
    constant_env[280] = alloc_prim(&heap, 1, prim_file_close);
    constant_env[281] = alloc_prim(&heap, 2, prim_file_write);
    constant_env[282] = alloc_prim(&heap, 1, prim_file_read_all);
    push_frame(return_from_main);
    a = alloc_closure(&heap, 3, 0, &&entry_253 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 3, 0, &&entry_255 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_257 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_259 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_261 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_262 - &&entry_0);
    closure_store(&heap, a, 0, var(4));
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_263 - &&entry_0);
    closure_store(&heap, a, 0, var(5));
    closure_store(&heap, a, 1, var(4));
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_272 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_269 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_270 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    closure_store(&heap, a, 1, var(1));
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_267 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_265 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_274 - &&entry_0);
    closure_store(&heap, a, 0, var(5));
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_276 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-14], 14, 101);
    pop_vars(14);
    pop_vars(7);
    package_env[0] = a;
    a = constant_env[1];
    push_var(a);
    a = constant_env[279];
    push_var(a);
    a = constant_env[282];
    push_var(a);
    a = constant_env[280];
    push_var(a);
    a = constant_env[281];
    push_var(a);
    a = constant_env[278];
    push_var(a);
    a = alloc_module(&heap, &stack[sp-6], 6, 94);
    pop_vars(6);
    package_env[1] = a;
    a = constant_env[277];
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 92);
    pop_vars(1);
    package_env[2] = a;
    a = package_env[0];
    push_var(a);
    a = constant_env[270];
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_248 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    push_var(a);
    a = constant_env[273];
    push_var(a);
    a = constant_env[271];
    push_var(a);
    a = constant_env[274];
    push_var(a);
    a = constant_env[272];
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_251 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_250 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(2));
    push_var(a);
    a = alloc_module(&heap, &stack[sp-8], 8, 83);
    pop_vars(8);
    pop_vars(3);
    package_env[3] = a;
    a = package_env[3];
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_247 - &&entry_0);
    push_var(a);
    a = constant_env[268];
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_246 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    push_var(a);
    a = alloc_module(&heap, &stack[sp-3], 3, 79);
    pop_vars(3);
    pop_vars(1);
    package_env[4] = a;
    a = package_env[2];
    push_var(a);
    a = package_env[0];
    push_var(a);
    a = package_env[4];
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_233 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(0));
    closure_store(&heap, a, 2, var(2));
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_240 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_241 - &&entry_0);
    closure_store(&heap, a, 0, var(4));
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_244 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(4));
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 59);
    pop_vars(2);
    pop_vars(5);
    package_env[5] = a;
    a = package_env[0];
    push_var(a);
    a = package_env[5];
    push_var(a);
    a = package_env[3];
    push_var(a);
    push_frame(block_1);
    a = var(2);
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_228 - &&entry_0);
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 59);
    fp = sp - 5;
    goto enter;
block_1:
    push_var(a);
    a = constant_env[1];
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_230 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(3));
    push_var(a);
    push_frame(block_0);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[252];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[253];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[30];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[28];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[27];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[26];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[24];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[22];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[20];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[18];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[33];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[87];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[89];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[90];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[254];
    push_var(a);
    a = number(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[255];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[256];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[257];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[258];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[259];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[260];
    push_var(a);
    a = number(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[261];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[262];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[263];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[264];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[265];
    push_var(a);
    a = number(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(5);
    fp = sp - 4;
    goto enter;
block_0:
    pop_vars(1);
    push_var(a);
    a = alloc_closure(&heap, 1, 4, &&entry_231 - &&entry_0);
    closure_store(&heap, a, 0, var(3));
    closure_store(&heap, a, 1, var(2));
    closure_store(&heap, a, 2, var(4));
    closure_store(&heap, a, 3, var(5));
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 57);
    pop_vars(1);
    pop_vars(6);
    package_env[6] = a;
    a = package_env[0];
    push_var(a);
    a = package_env[1];
    push_var(a);
    a = package_env[6];
    push_var(a);
    a = package_env[5];
    push_var(a);
    a = package_env[2];
    push_var(a);
    a = package_env[3];
    push_var(a);
    a = package_env[4];
    push_var(a);
    a = constant_env[1];
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_212 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_213 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(7));
    push_var(a);
    a = alloc_closure(&heap, 3, 3, &&entry_218 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(6));
    closure_store(&heap, a, 2, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 8, &&entry_227 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(2));
    closure_store(&heap, a, 3, var(5));
    closure_store(&heap, a, 4, var(6));
    closure_store(&heap, a, 5, var(8));
    closure_store(&heap, a, 6, var(10));
    closure_store(&heap, a, 7, var(9));
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 55);
    pop_vars(1);
    pop_vars(12);
    package_env[7] = a;
    a = package_env[0];
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_210 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 53);
    pop_vars(1);
    pop_vars(1);
    package_env[8] = a;
    a = package_env[0];
    push_var(a);
    a = package_env[5];
    push_var(a);
    a = package_env[8];
    push_var(a);
    a = package_env[2];
    push_var(a);
    a = package_env[3];
    push_var(a);
    a = package_env[4];
    push_var(a);
    a = constant_env[1];
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_119 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_120 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 4, 3, &&entry_137 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(8));
    closure_store(&heap, a, 2, var(6));
    push_var(a);
    a = alloc_closure(&heap, 1, 4, &&entry_148 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(4));
    closure_store(&heap, a, 3, var(6));
    push_var(a);
    a = alloc_closure(&heap, 1, 6, &&entry_162 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(2));
    closure_store(&heap, a, 3, var(4));
    closure_store(&heap, a, 4, var(5));
    closure_store(&heap, a, 5, var(6));
    push_var(a);
    a = alloc_closure(&heap, 1, 6, &&entry_181 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(2));
    closure_store(&heap, a, 3, var(4));
    closure_store(&heap, a, 4, var(5));
    closure_store(&heap, a, 5, var(6));
    push_var(a);
    a = alloc_closure(&heap, 1, 5, &&entry_202 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(4));
    closure_store(&heap, a, 3, var(7));
    closure_store(&heap, a, 4, var(6));
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_206 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(9));
    push_var(a);
    a = alloc_closure(&heap, 1, 5, &&entry_207 - &&entry_0);
    closure_store(&heap, a, 0, var(11));
    closure_store(&heap, a, 1, var(12));
    closure_store(&heap, a, 2, var(14));
    closure_store(&heap, a, 3, var(10));
    closure_store(&heap, a, 4, var(13));
    push_var(a);
    a = var(15);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 2);
    pop_vars(1);
    pop_vars(16);
    package_env[9] = a;
    a = package_env[0];
    push_var(a);
    a = package_env[5];
    push_var(a);
    a = package_env[2];
    push_var(a);
    a = package_env[3];
    push_var(a);
    a = constant_env[1];
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_86 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_87 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 1, 6, &&entry_105 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(3));
    closure_store(&heap, a, 3, var(6));
    closure_store(&heap, a, 4, var(4));
    closure_store(&heap, a, 5, var(5));
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_116 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_118 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(7));
    closure_store(&heap, a, 2, var(8));
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 2);
    pop_vars(1);
    pop_vars(10);
    package_env[10] = a;
    a = alloc_closure(&heap, 1, 0, &&entry_82 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_83 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_85 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_84 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(0));
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(0);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-4], 4, 21);
    pop_vars(4);
    pop_vars(2);
    package_env[11] = a;
    a = package_env[0];
    push_var(a);
    a = package_env[1];
    push_var(a);
    a = package_env[5];
    push_var(a);
    a = package_env[2];
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 2);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_81 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(2));
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 14);
    pop_vars(1);
    pop_vars(6);
    package_env[12] = a;
    a = package_env[11];
    push_var(a);
    a = package_env[12];
    push_var(a);
    a = package_env[0];
    push_var(a);
    a = package_env[1];
    push_var(a);
    a = package_env[5];
    push_var(a);
    a = package_env[2];
    push_var(a);
    a = package_env[3];
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_3 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_4 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    push_var(a);
    a = constant_env[1];
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_5 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    push_var(a);
    a = alloc_closure(&heap, 1, 4, &&entry_7 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(9));
    closure_store(&heap, a, 2, var(8));
    closure_store(&heap, a, 3, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 4, &&entry_9 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(6));
    closure_store(&heap, a, 2, var(9));
    closure_store(&heap, a, 3, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_10 - &&entry_0);
    closure_store(&heap, a, 0, var(9));
    closure_store(&heap, a, 1, var(7));
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_11 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    closure_store(&heap, a, 1, var(9));
    closure_store(&heap, a, 2, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 5, &&entry_13 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(6));
    closure_store(&heap, a, 2, var(9));
    closure_store(&heap, a, 3, var(11));
    closure_store(&heap, a, 4, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_14 - &&entry_0);
    closure_store(&heap, a, 0, var(9));
    closure_store(&heap, a, 1, var(8));
    closure_store(&heap, a, 2, var(7));
    push_var(a);
    a = alloc_closure(&heap, 3, 4, &&entry_16 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(9));
    closure_store(&heap, a, 2, var(13));
    closure_store(&heap, a, 3, var(15));
    push_var(a);
    a = alloc_closure(&heap, 3, 6, &&entry_17 - &&entry_0);
    closure_store(&heap, a, 0, var(9));
    closure_store(&heap, a, 1, var(8));
    closure_store(&heap, a, 2, var(13));
    closure_store(&heap, a, 3, var(15));
    closure_store(&heap, a, 4, var(11));
    closure_store(&heap, a, 5, var(7));
    push_var(a);
    a = alloc_closure(&heap, 2, 6, &&entry_21 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(6));
    closure_store(&heap, a, 2, var(9));
    closure_store(&heap, a, 3, var(8));
    closure_store(&heap, a, 4, var(16));
    closure_store(&heap, a, 5, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_23 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(8));
    closure_store(&heap, a, 2, var(7));
    push_var(a);
    a = alloc_closure(&heap, 3, 4, &&entry_25 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    closure_store(&heap, a, 1, var(17));
    closure_store(&heap, a, 2, var(18));
    closure_store(&heap, a, 3, var(7));
    push_var(a);
    a = alloc_closure(&heap, 2, 4, &&entry_27 - &&entry_0);
    closure_store(&heap, a, 0, var(9));
    closure_store(&heap, a, 1, var(8));
    closure_store(&heap, a, 2, var(21));
    closure_store(&heap, a, 3, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_28 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    closure_store(&heap, a, 1, var(9));
    closure_store(&heap, a, 2, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 5, &&entry_30 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(9));
    closure_store(&heap, a, 2, var(8));
    closure_store(&heap, a, 3, var(13));
    closure_store(&heap, a, 4, var(7));
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_33 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_34 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    closure_store(&heap, a, 1, var(9));
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_36 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    closure_store(&heap, a, 1, var(9));
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_38 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(6));
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_40 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(6));
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_41 - &&entry_0);
    closure_store(&heap, a, 0, var(6));
    push_var(a);
    a = alloc_closure(&heap, 1, 15, &&entry_49 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(6));
    closure_store(&heap, a, 2, var(9));
    closure_store(&heap, a, 3, var(8));
    closure_store(&heap, a, 4, var(19));
    closure_store(&heap, a, 5, var(21));
    closure_store(&heap, a, 6, var(22));
    closure_store(&heap, a, 7, var(20));
    closure_store(&heap, a, 8, var(17));
    closure_store(&heap, a, 9, var(13));
    closure_store(&heap, a, 10, var(24));
    closure_store(&heap, a, 11, var(15));
    closure_store(&heap, a, 12, var(23));
    closure_store(&heap, a, 13, var(7));
    closure_store(&heap, a, 14, var(10));
    push_var(a);
    a = alloc_closure(&heap, 2, 7, &&entry_50 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(6));
    closure_store(&heap, a, 2, var(30));
    closure_store(&heap, a, 3, var(26));
    closure_store(&heap, a, 4, var(28));
    closure_store(&heap, a, 5, var(27));
    closure_store(&heap, a, 6, var(29));
    push_var(a);
    a = alloc_closure(&heap, 1, 7, &&entry_52 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(6));
    closure_store(&heap, a, 2, var(9));
    closure_store(&heap, a, 3, var(21));
    closure_store(&heap, a, 4, var(22));
    closure_store(&heap, a, 5, var(31));
    closure_store(&heap, a, 6, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 5, &&entry_56 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(2));
    closure_store(&heap, a, 2, var(4));
    closure_store(&heap, a, 3, var(6));
    closure_store(&heap, a, 4, var(9));
    push_var(a);
    a = alloc_closure(&heap, 1, 4, &&entry_58 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(6));
    closure_store(&heap, a, 2, var(32));
    closure_store(&heap, a, 3, var(25));
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_59 - &&entry_0);
    closure_store(&heap, a, 0, var(33));
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_67 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(4));
    closure_store(&heap, a, 2, var(6));
    push_var(a);
    a = alloc_closure(&heap, 1, 8, &&entry_72 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(3));
    closure_store(&heap, a, 2, var(4));
    closure_store(&heap, a, 3, var(6));
    closure_store(&heap, a, 4, var(37));
    closure_store(&heap, a, 5, var(36));
    closure_store(&heap, a, 6, var(35));
    closure_store(&heap, a, 7, var(34));
    push_var(a);
    a = var(38);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 2);
    pop_vars(1);
    pop_vars(39);
    package_env[13] = a;
    a = package_env[0];
    push_var(a);
    a = package_env[1];
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_1 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    push_var(a);
    a = package_env[7];
    push_var(a);
    a = package_env[9];
    push_var(a);
    a = package_env[10];
    push_var(a);
    a = package_env[13];
    push_var(a);
    a = alloc_closure(&heap, 1, 5, &&entry_2 - &&entry_0);
    closure_store(&heap, a, 0, var(3));
    closure_store(&heap, a, 1, var(4));
    closure_store(&heap, a, 2, var(5));
    closure_store(&heap, a, 3, var(6));
    closure_store(&heap, a, 4, var(2));
    push_var(a);
    a = var(7);
    pop_vars(8);
    package_env[14] = a;
    a = labeled_empty_tuple(26);
    for (int i = argc-1; i >= 0; i--) {
        struct value values[2] = {alloc_string(&heap, argv[i]), a};
        a = alloc_tuple(&heap, values, 2);
        a = alloc_labeled_value(&heap, 7, a);
    }
    push_var(a);
    a = package_env[14];
    fp = sp - 4;
    goto enter;
return_from_main:
    free(heap.values);
    free(stack);
    free(constant_env);
    free(package_env);
    return NULL;
entry_276:
    push_frame(block_2244);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(1);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_275 - &&entry_0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_2244:
    goto pop_frame;
entry_275:
    a = var(1);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
entry_274:
    a = alloc_closure(&heap, 3, 1, &&entry_273 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    push_var(a);
    push_frame(block_2243);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    fp = sp - 6;
    goto enter;
block_2243:
    goto pop_frame;
entry_273:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2242;
    case 26:
        goto block_2237;
    default:
        halt();
    }
block_2242:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2241;
    case 26:
        goto block_2239;
    default:
        halt();
    }
block_2241:
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    push_frame(block_2240);
    a = var(3);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2240:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-3, 3*sizeof(struct value));
    sp = fp + 6;
    goto enter;
block_2239:
    push_frame(block_2238);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_2238:
    goto pop_frame;
block_2237:
    push_frame(block_2236);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_2236:
    goto pop_frame;
entry_272:
    push_frame(block_2235);
    a = var(1);
    push_var(a);
    a = number(0);
    push_var(a);
    a = constant_env[38];
    fp = sp - 5;
    goto enter;
block_2235:
    if (a.bits == false_value.bits) goto block_2233;
    a = labeled_empty_tuple(1);
    goto pop_frame;
block_2233:
    a = alloc_closure(&heap, 2, 0, &&entry_271 - &&entry_0);
    push_var(a);
    push_frame(block_2234);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    fp = sp - 5;
    goto enter;
block_2234:
    goto pop_frame;
entry_271:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2232;
    case 26:
        goto block_2227;
    default:
        halt();
    }
block_2232:
    push_frame(block_2231);
    a = var(1);
    push_var(a);
    a = number(0);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_2231:
    if (a.bits == false_value.bits) goto block_2228;
    a = var(2);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
block_2228:
    a = var(3);
    push_var(a);
    push_frame(block_2229);
    a = var(1);
    push_var(a);
    push_frame(block_2230);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2230:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2229:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_2227:
    a = labeled_empty_tuple(1);
    goto pop_frame;
entry_270:
    push_frame(block_2226);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = closure_env[0];
    push_var(a);
    a = closure_env[1];
    fp = sp - 6;
    goto enter;
block_2226:
    goto pop_frame;
entry_269:
    push_frame(block_2225);
    a = var(0);
    push_var(a);
    a = number(0);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_268 - &&entry_0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_2225:
    goto pop_frame;
entry_268:
    push_frame(block_2224);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2224:
    goto pop_frame;
entry_267:
    push_frame(block_2223);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_266 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_2223:
    goto pop_frame;
entry_266:
    push_frame(block_2222);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_2222:
    if (a.bits == false_value.bits) goto block_2220;
    push_frame(block_2221);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2221:
    goto pop_frame;
block_2220:
    a = var(1);
    goto pop_frame;
entry_265:
    push_frame(block_2219);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_264 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_2219:
    goto pop_frame;
entry_264:
    push_frame(block_2217);
    push_frame(block_2218);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_2218:
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2217:
    goto pop_frame;
entry_263:
    push_frame(block_2215);
    push_frame(block_2216);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_2216:
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_2215:
    goto pop_frame;
entry_262:
    push_frame(block_2214);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2214:
    goto pop_frame;
entry_261:
    push_frame(block_2213);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_260 - &&entry_0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_2213:
    goto pop_frame;
entry_260:
    push_frame(block_2212);
    a = var(1);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2212:
    goto pop_frame;
entry_259:
    a = alloc_closure(&heap, 2, 1, &&entry_258 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    push_var(a);
    push_frame(block_2211);
    a = number(0);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(2);
    fp = sp - 5;
    goto enter;
block_2211:
    goto pop_frame;
entry_258:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_2210;
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2209;
    default:
        halt();
    }
block_2210:
    a = empty_tuple;
    goto pop_frame;
block_2209:
    push_frame(block_2208);
    a = var(0);
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2208:
    push_frame(block_2207);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2207:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
entry_257:
    a = alloc_closure(&heap, 1, 1, &&entry_256 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    push_var(a);
    push_frame(block_2206);
    a = var(0);
    push_var(a);
    a = var(2);
    fp = sp - 4;
    goto enter;
block_2206:
    goto pop_frame;
entry_256:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_2205;
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2204;
    default:
        halt();
    }
block_2205:
    a = empty_tuple;
    goto pop_frame;
block_2204:
    push_frame(block_2203);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_2203:
    a = var(2);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
entry_255:
    a = alloc_closure(&heap, 2, 1, &&entry_254 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    push_var(a);
    push_frame(block_2202);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    fp = sp - 5;
    goto enter;
block_2202:
    goto pop_frame;
entry_254:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_2201;
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2200;
    default:
        halt();
    }
block_2201:
    a = var(1);
    goto pop_frame;
block_2200:
    a = var(3);
    push_var(a);
    push_frame(block_2199);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2199:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
entry_253:
    a = alloc_closure(&heap, 1, 2, &&entry_252 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, var(1));
    push_var(a);
    push_frame(block_2198);
    a = var(0);
    push_var(a);
    a = var(3);
    fp = sp - 4;
    goto enter;
block_2198:
    goto pop_frame;
entry_252:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_2197;
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2196;
    default:
        halt();
    }
block_2197:
    a = closure_env[1];
    goto pop_frame;
block_2196:
    push_frame(block_2194);
    a = var(1);
    push_var(a);
    push_frame(block_2195);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_2195:
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2194:
    goto pop_frame;
entry_251:
    push_frame(block_2193);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[276];
    fp = sp - 5;
    goto enter;
block_2193:
    switch (value_unbox_int32(a)) {
    case 1:
        goto block_2192;
    case 0:
        goto block_2191;
    default:
        goto block_2190;
    }
block_2192:
    a = labeled_empty_tuple(111);
    goto pop_frame;
block_2191:
    a = labeled_empty_tuple(9);
    goto pop_frame;
block_2190:
    a = labeled_empty_tuple(110);
    goto pop_frame;
entry_250:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_2189;
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2188;
    default:
        halt();
    }
block_2189:
    a = constant_env[275];
    goto pop_frame;
block_2188:
    push_frame(block_2187);
    a = var(3);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_249 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_2187:
    push_var(a);
    push_frame(block_2185);
    push_frame(block_2186);
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2186:
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_2185:
    goto pop_frame;
entry_249:
    push_frame(block_2183);
    a = closure_env[0];
    push_var(a);
    push_frame(block_2184);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2184:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2183:
    goto pop_frame;
entry_248:
    push_frame(block_2182);
    a = var(0);
    push_var(a);
    a = constant_env[275];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_2182:
    goto pop_frame;
entry_247:
block_2181:
    push_frame(block_2180);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[38];
    fp = sp - 5;
    goto enter;
block_2180:
    if (a.bits == false_value.bits) goto block_2179;
    a = labeled_empty_tuple(110);
    goto pop_frame;
block_2179:
    push_frame(block_2178);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[93];
    fp = sp - 5;
    goto enter;
block_2178:
    if (a.bits == false_value.bits) goto block_2177;
    a = labeled_empty_tuple(111);
    goto pop_frame;
block_2177:
    a = true_value;
    if (a.bits == false_value.bits) goto block_2176;
    a = labeled_empty_tuple(9);
    goto pop_frame;
block_2176:
    halt();
entry_246:
    push_frame(block_2175);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_2175:
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_245 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(0));
    push_var(a);
    push_frame(block_2174);
    a = number(0);
    push_var(a);
    a = number(0);
    push_var(a);
    a = var(2);
    fp = sp - 5;
    goto enter;
block_2174:
    goto pop_frame;
entry_245:
block_2173:
    push_frame(block_2172);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_2172:
    if (a.bits == false_value.bits) goto block_2171;
    a = var(1);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
block_2171:
    a = true_value;
    if (a.bits == false_value.bits) goto block_2160;
    push_frame(block_2170);
    a = closure_env[2];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_2170:
    push_var(a);
    push_frame(block_2169);
    a = var(2);
    push_var(a);
    a = number(48);
    push_var(a);
    a = constant_env[269];
    fp = sp - 5;
    goto enter;
block_2169:
    if (a.bits == false_value.bits) goto block_2167;
    push_frame(block_2168);
    a = var(2);
    push_var(a);
    a = number(57);
    push_var(a);
    a = constant_env[96];
    fp = sp - 5;
    goto enter;
block_2168:
block_2167:
    if (a.bits == false_value.bits) goto block_2161;
    push_frame(block_2166);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2166:
    push_var(a);
    push_frame(block_2162);
    push_frame(block_2164);
    push_frame(block_2165);
    a = number(10);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[57];
    fp = sp - 5;
    goto enter;
block_2165:
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2164:
    push_var(a);
    push_frame(block_2163);
    a = number(48);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2163:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2162:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_2161:
    a = labeled_empty_tuple(1);
    goto pop_frame;
block_2160:
    halt();
entry_244:
    a = alloc_closure(&heap, 1, 0, &&entry_242 - &&entry_0);
    push_var(a);
    push_frame(block_2159);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_2159:
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_243 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(2));
    push_var(a);
    a = var(2);
    a = module_fetch(&heap, a, 41);
    push_var(a);
    a = var(2);
    a = module_fetch(&heap, a, 56);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(2);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = var(2);
    a = module_fetch(&heap, a, 70);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-6], 6, 72);
    pop_vars(6);
    goto pop_frame;
entry_243:
    push_frame(block_2157);
    push_frame(block_2158);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 41);
    fp = sp - 4;
    goto enter;
block_2158:
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 56);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_2157:
    goto pop_frame;
entry_242:
    a = var(0);
    goto pop_frame;
entry_241:
    push_frame(block_2156);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2156:
    goto pop_frame;
entry_240:
    a = alloc_closure(&heap, 1, 0, &&entry_239 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_235 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    push_var(a);
    a = var(0);
    push_var(a);
    a = number(0);
    push_var(a);
    a = labeled_empty_tuple(139);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 62);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_237 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-6], 6, 65);
    pop_vars(6);
    goto pop_frame;
entry_239:
    a = alloc_closure(&heap, 3, 0, &&entry_238 - &&entry_0);
    push_var(a);
    push_frame(block_2155);
    a = var(0);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = number(0);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_2155:
    if (a.bits == false_value.bits) goto block_2153;
    a = labeled_empty_tuple(26);
    goto pop_frame;
block_2153:
    push_frame(block_2154);
    a = var(0);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 137);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    fp = sp - 6;
    goto enter;
block_2154:
    goto pop_frame;
entry_238:
    push_frame(block_2152);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_2152:
    if (a.bits == false_value.bits) goto block_2132;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 136:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_2151;
    case 133:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2149;
    default:
        halt();
    }
block_2151:
    push_frame(block_2150);
    a = var(3);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2150:
    goto pop_frame;
block_2149:
    push_frame(block_2147);
    a = var(3);
    push_var(a);
    push_frame(block_2148);
    a = var(4);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2148:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2147:
    goto pop_frame;
block_2132:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 136:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_2146;
    case 133:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 5);
        sp += 5;
        goto block_2140;
    default:
        halt();
    }
block_2146:
    push_frame(block_2144);
    a = var(0);
    push_var(a);
    push_frame(block_2145);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2145:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2144:
    push_var(a);
    push_frame(block_2141);
    a = var(6);
    push_var(a);
    a = var(3);
    push_var(a);
    push_frame(block_2142);
    a = var(4);
    push_var(a);
    push_frame(block_2143);
    a = var(6);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_2143:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2142:
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_2141:
    goto pop_frame;
block_2140:
    push_frame(block_2138);
    a = var(0);
    push_var(a);
    push_frame(block_2139);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2139:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2138:
    push_var(a);
    push_frame(block_2135);
    a = var(8);
    push_var(a);
    a = var(5);
    push_var(a);
    push_frame(block_2136);
    a = var(6);
    push_var(a);
    push_frame(block_2137);
    a = var(8);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_2137:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2136:
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_2135:
    push_var(a);
    push_frame(block_2133);
    a = var(8);
    push_var(a);
    a = var(3);
    push_var(a);
    push_frame(block_2134);
    a = var(4);
    push_var(a);
    a = var(9);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_2134:
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_2133:
    goto pop_frame;
entry_237:
    a = alloc_closure(&heap, 2, 3, &&entry_236 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, var(1));
    push_var(a);
    push_frame(block_2131);
    a = var(0);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = number(0);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_2131:
    if (a.bits == false_value.bits) goto block_2129;
    a = labeled_empty_tuple(1);
    goto pop_frame;
block_2129:
    push_frame(block_2130);
    a = var(0);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 137);
    push_var(a);
    a = var(2);
    fp = sp - 5;
    goto enter;
block_2130:
    goto pop_frame;
entry_236:
    push_frame(block_2128);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_2128:
    if (a.bits == false_value.bits) goto block_2086;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 136:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_2127;
    case 133:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2122;
    default:
        halt();
    }
block_2127:
    push_frame(block_2125);
    a = closure_env[2];
    push_var(a);
    push_frame(block_2126);
    a = var(2);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_2126:
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2125:
    switch (value_label(&heap, a)) {
    case 9:
        goto block_2124;
    default:
        goto block_2123;
    }
block_2124:
    a = var(2);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
block_2123:
    a = labeled_empty_tuple(1);
    goto pop_frame;
block_2122:
    push_frame(block_2120);
    a = closure_env[2];
    push_var(a);
    push_frame(block_2121);
    a = var(2);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_2121:
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2120:
    switch (value_label(&heap, a)) {
    case 9:
        goto block_2119;
    default:
        goto block_2118;
    }
block_2119:
    a = var(2);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
block_2118:
    push_frame(block_2116);
    a = closure_env[2];
    push_var(a);
    push_frame(block_2117);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_2117:
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2116:
    switch (value_label(&heap, a)) {
    case 9:
        goto block_2115;
    default:
        goto block_2114;
    }
block_2115:
    a = var(3);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
block_2114:
    a = labeled_empty_tuple(1);
    goto pop_frame;
block_2086:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 136:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_2113;
    case 133:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 5);
        sp += 5;
        goto block_2103;
    default:
        halt();
    }
block_2113:
    push_frame(block_2111);
    a = closure_env[2];
    push_var(a);
    push_frame(block_2112);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_2112:
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2111:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_2110;
    case 9:
        goto block_2107;
    case 111:
        goto block_2106;
    default:
        halt();
    }
block_2110:
    push_frame(block_2108);
    a = var(0);
    push_var(a);
    push_frame(block_2109);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2109:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2108:
    push_var(a);
    a = var(2);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_2107:
    a = var(3);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
block_2106:
    push_frame(block_2104);
    a = var(0);
    push_var(a);
    push_frame(block_2105);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2105:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2104:
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_2103:
    push_frame(block_2101);
    a = closure_env[2];
    push_var(a);
    push_frame(block_2102);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_2102:
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2101:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_2100;
    case 9:
        goto block_2097;
    case 111:
        goto block_2096;
    default:
        halt();
    }
block_2100:
    push_frame(block_2098);
    a = var(0);
    push_var(a);
    push_frame(block_2099);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2099:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2098:
    push_var(a);
    a = var(2);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_2097:
    a = var(3);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
block_2096:
    push_frame(block_2094);
    a = closure_env[2];
    push_var(a);
    push_frame(block_2095);
    a = var(5);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_2095:
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2094:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_2093;
    case 9:
        goto block_2090;
    case 111:
        goto block_2089;
    default:
        halt();
    }
block_2093:
    push_frame(block_2091);
    a = var(0);
    push_var(a);
    push_frame(block_2092);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2092:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2091:
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_2090:
    a = var(5);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
block_2089:
    push_frame(block_2087);
    a = var(0);
    push_var(a);
    push_frame(block_2088);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2088:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2087:
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
entry_235:
    a = alloc_closure(&heap, 2, 3, &&entry_234 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, closure_env[1]);
    push_var(a);
    push_frame(block_2085);
    a = var(0);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = number(0);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_2085:
    if (a.bits == false_value.bits) goto block_2080;
    a = number(1);
    push_var(a);
    a = var(1);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 62);
    pop_vars(2);
    goto pop_frame;
block_2080:
    push_frame(block_2084);
    a = var(0);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 137);
    push_var(a);
    a = var(2);
    fp = sp - 5;
    goto enter;
block_2084:
    switch (value_label(&heap, a)) {
    case 134:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_2083;
    case 135:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_2082;
    default:
        halt();
    }
block_2083:
    a = var(0);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 62);
    pop_vars(2);
    goto pop_frame;
block_2082:
    push_frame(block_2081);
    a = var(0);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2081:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 62);
    pop_vars(2);
    goto pop_frame;
entry_234:
    push_frame(block_2079);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_2079:
    if (a.bits == false_value.bits) goto block_2015;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 136:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_2078;
    case 133:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2071;
    default:
        halt();
    }
block_2078:
    push_frame(block_2075);
    push_frame(block_2077);
    a = closure_env[1];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2077:
    push_var(a);
    push_frame(block_2076);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2076:
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2075:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_2074;
    case 111:
        goto block_2073;
    case 9:
        goto block_2072;
    default:
        halt();
    }
block_2074:
    a = closure_env[1];
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2073:
    a = var(2);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2072:
    a = closure_env[1];
    a = alloc_labeled_value(&heap, 136, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2071:
    push_frame(block_2070);
    a = closure_env[1];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2070:
    push_var(a);
    push_frame(block_2069);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2069:
    push_var(a);
    push_frame(block_2068);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2068:
    push_var(a);
    push_frame(block_2067);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2067:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_2066;
    case 111:
        goto block_2065;
    case 9:
        goto block_2060;
    default:
        halt();
    }
block_2066:
    a = closure_env[1];
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 135, a);
    goto pop_frame;
block_2065:
    push_frame(block_2064);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2064:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_2063;
    case 111:
        goto block_2062;
    case 9:
        goto block_2061;
    default:
        halt();
    }
block_2063:
    a = var(2);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(3);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 135, a);
    goto pop_frame;
block_2062:
    a = var(2);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 135, a);
    goto pop_frame;
block_2061:
    a = var(2);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2060:
    a = closure_env[1];
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2015:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 136:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_2059;
    case 133:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 5);
        sp += 5;
        goto block_2042;
    default:
        halt();
    }
block_2059:
    push_frame(block_2056);
    push_frame(block_2058);
    a = closure_env[1];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2058:
    push_var(a);
    push_frame(block_2057);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2057:
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2056:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_2055;
    case 111:
        goto block_2049;
    case 9:
        goto block_2043;
    default:
        halt();
    }
block_2055:
    push_frame(block_2052);
    push_frame(block_2053);
    a = var(0);
    push_var(a);
    push_frame(block_2054);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2054:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2053:
    push_var(a);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_2052:
    switch (value_label(&heap, a)) {
    case 134:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_2051;
    case 135:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_2050;
    default:
        halt();
    }
block_2051:
    a = var(5);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2050:
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2049:
    push_frame(block_2046);
    push_frame(block_2047);
    a = var(0);
    push_var(a);
    push_frame(block_2048);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2048:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2047:
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_2046:
    switch (value_label(&heap, a)) {
    case 134:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_2045;
    case 135:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_2044;
    default:
        halt();
    }
block_2045:
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2044:
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2043:
    a = var(2);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2042:
    push_frame(block_2041);
    a = closure_env[1];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2041:
    push_var(a);
    push_frame(block_2040);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2040:
    push_var(a);
    push_frame(block_2039);
    a = var(5);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2039:
    push_var(a);
    push_frame(block_2038);
    a = var(7);
    push_var(a);
    a = var(8);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2038:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_2037;
    case 111:
        goto block_2031;
    case 9:
        goto block_2016;
    default:
        halt();
    }
block_2037:
    push_frame(block_2034);
    push_frame(block_2035);
    a = var(0);
    push_var(a);
    push_frame(block_2036);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2036:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2035:
    push_var(a);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_2034:
    switch (value_label(&heap, a)) {
    case 134:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_2033;
    case 135:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_2032;
    default:
        halt();
    }
block_2033:
    a = var(10);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2032:
    a = var(10);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 135, a);
    goto pop_frame;
block_2031:
    push_frame(block_2030);
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_2030:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_2029;
    case 111:
        goto block_2023;
    case 9:
        goto block_2017;
    default:
        halt();
    }
block_2029:
    push_frame(block_2026);
    push_frame(block_2027);
    a = var(0);
    push_var(a);
    push_frame(block_2028);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2028:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2027:
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_2026:
    switch (value_label(&heap, a)) {
    case 134:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_2025;
    case 135:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_2024;
    default:
        halt();
    }
block_2025:
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2024:
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(12);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 135, a);
    goto pop_frame;
block_2023:
    push_frame(block_2020);
    push_frame(block_2021);
    a = var(0);
    push_var(a);
    push_frame(block_2022);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_2022:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_2021:
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_2020:
    switch (value_label(&heap, a)) {
    case 134:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_2019;
    case 135:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_2018;
    default:
        halt();
    }
block_2019:
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2018:
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 136, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 135, a);
    goto pop_frame;
block_2017:
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
block_2016:
    a = var(2);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 133, a);
    a = alloc_labeled_value(&heap, 134, a);
    goto pop_frame;
entry_233:
    push_frame(block_2014);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_232 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[2]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_2014:
    goto pop_frame;
entry_232:
    push_frame(block_2012);
    push_frame(block_2013);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_2013:
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 132);
    fp = sp - 4;
    goto enter;
block_2012:
    goto pop_frame;
entry_231:
    push_frame(block_2011);
    a = closure_env[3];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_2011:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_2010;
    case 1:
        goto block_2009;
    default:
        halt();
    }
block_2010:
    a = var(2);
    goto pop_frame;
block_2009:
    push_frame(block_2007);
    push_frame(block_2008);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[266];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(0);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[267];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 15);
    fp = sp - 4;
    goto enter;
block_2008:
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_2007:
    goto pop_frame;
entry_230:
    push_frame(block_2006);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_229 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_2006:
    goto pop_frame;
entry_229:
    push_frame(block_2005);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_2005:
    goto pop_frame;
entry_228:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    goto pop_frame;
entry_227:
    push_frame(block_2004);
    a = var(0);
    push_var(a);
    a = closure_env[7];
    fp = sp - 4;
    goto enter;
block_2004:
    push_var(a);
    push_frame(block_2003);
    a = var(1);
    push_var(a);
    a = constant_env[189];
    push_var(a);
    a = closure_env[3];
    a = module_fetch(&heap, a, 28);
    fp = sp - 5;
    goto enter;
block_2003:
    push_var(a);
    push_frame(block_2002);
    a = var(2);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 131);
    fp = sp - 4;
    goto enter;
block_2002:
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_220 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, var(3));
    push_var(a);
    push_frame(block_2001);
    a = var(4);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 120);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 121);
    push_var(a);
    a = closure_env[6];
    fp = sp - 6;
    goto enter;
block_2001:
    push_var(a);
    push_frame(block_2000);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[190];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_2000:
    push_frame(block_1999);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[191];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1999:
    push_frame(block_1998);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[192];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1998:
    push_frame(block_1997);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[193];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1997:
    push_frame(block_1996);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[176];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1996:
    push_frame(block_1995);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[194];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1995:
    push_frame(block_1994);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[176];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1994:
    push_frame(block_1993);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[195];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1993:
    push_frame(block_1992);
    a = var(0);
    a = module_fetch(&heap, a, 118);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_221 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[4]);
    closure_store(&heap, a, 1, var(4));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_1992:
    push_frame(block_1991);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[176];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1991:
    push_frame(block_1990);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[196];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1990:
    push_frame(block_1989);
    a = var(0);
    a = module_fetch(&heap, a, 119);
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_223 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[4]);
    closure_store(&heap, a, 2, var(4));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_1989:
    push_frame(block_1988);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[197];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1988:
    push_frame(block_1987);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[176];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1987:
    push_frame(block_1986);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[198];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1986:
    push_frame(block_1985);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[199];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1985:
    push_frame(block_1984);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[200];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1984:
    push_frame(block_1983);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[201];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1983:
    push_frame(block_1982);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[202];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1982:
    push_frame(block_1981);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[203];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1981:
    push_frame(block_1980);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[204];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1980:
    push_frame(block_1979);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[205];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1979:
    push_frame(block_1978);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[206];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1978:
    push_frame(block_1977);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[207];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1977:
    push_frame(block_1976);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[208];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1976:
    push_frame(block_1975);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[209];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1975:
    push_frame(block_1974);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[176];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1974:
    push_frame(block_1973);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[210];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1973:
    push_frame(block_1972);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[211];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1972:
    push_frame(block_1971);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[212];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1971:
    push_frame(block_1970);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[213];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1970:
    push_frame(block_1969);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[214];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1969:
    push_frame(block_1968);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[215];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1968:
    push_frame(block_1967);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[216];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1967:
    push_frame(block_1964);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[217];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1965);
    push_frame(block_1966);
    a = var(0);
    a = module_fetch(&heap, a, 113);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1966:
    push_var(a);
    a = closure_env[4];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1965:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[218];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1964:
    push_frame(block_1961);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[217];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1962);
    push_frame(block_1963);
    a = var(0);
    a = module_fetch(&heap, a, 114);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1963:
    push_var(a);
    a = closure_env[4];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1962:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[219];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1961:
    push_frame(block_1960);
    a = var(0);
    a = module_fetch(&heap, a, 113);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_224 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[2]);
    closure_store(&heap, a, 1, closure_env[4]);
    closure_store(&heap, a, 2, var(4));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 128);
    fp = sp - 5;
    goto enter;
block_1960:
    push_frame(block_1959);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[220];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1959:
    push_frame(block_1958);
    a = var(0);
    a = module_fetch(&heap, a, 123);
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_1958:
    push_frame(block_1956);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1957);
    a = var(0);
    a = module_fetch(&heap, a, 120);
    push_var(a);
    a = closure_env[4];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1957:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[152];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1956:
    push_frame(block_1955);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[221];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1955:
    push_frame(block_1954);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[222];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1954:
    push_frame(block_1953);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[223];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1953:
    push_frame(block_1951);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[150];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1952);
    a = var(0);
    a = module_fetch(&heap, a, 121);
    push_var(a);
    a = closure_env[4];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1952:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[224];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1951:
    push_frame(block_1950);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[147];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1950:
    push_frame(block_1949);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[175];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1949:
    push_frame(block_1944);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[133];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1945);
    push_frame(block_1946);
    push_frame(block_1948);
    a = var(0);
    a = module_fetch(&heap, a, 114);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1948:
    push_var(a);
    push_frame(block_1947);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_1947:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1946:
    push_var(a);
    a = closure_env[4];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1945:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[171];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1944:
    push_frame(block_1943);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[225];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1943:
    push_frame(block_1942);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[136];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1942:
    push_frame(block_1941);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[226];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1941:
    push_frame(block_1940);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[227];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1940:
    push_frame(block_1939);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[228];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1939:
    push_frame(block_1938);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[229];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1938:
    push_frame(block_1937);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[230];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1937:
    push_frame(block_1936);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[231];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1936:
    push_frame(block_1935);
    a = var(0);
    a = module_fetch(&heap, a, 124);
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_1935:
    push_frame(block_1933);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[142];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[150];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1934);
    a = var(0);
    a = module_fetch(&heap, a, 121);
    push_var(a);
    a = closure_env[4];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1934:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[151];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[232];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[233];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[175];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[234];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[175];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[235];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[236];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1933:
    push_frame(block_1931);
    push_frame(block_1932);
    a = var(0);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_1932:
    push_var(a);
    a = alloc_closure(&heap, 1, 4, &&entry_226 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[2]);
    closure_store(&heap, a, 1, closure_env[3]);
    closure_store(&heap, a, 2, closure_env[4]);
    closure_store(&heap, a, 3, var(4));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_1931:
    push_frame(block_1930);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[237];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1930:
    push_frame(block_1929);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[238];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1929:
    push_frame(block_1928);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[239];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1928:
    push_frame(block_1927);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[240];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1927:
    push_frame(block_1926);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[241];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1926:
    push_frame(block_1925);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[242];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1925:
    push_frame(block_1924);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[243];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1924:
    push_frame(block_1923);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[244];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1923:
    push_frame(block_1922);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[147];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1922:
    push_frame(block_1921);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[245];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1921:
    push_frame(block_1920);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[238];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1920:
    push_frame(block_1919);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[246];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1919:
    push_frame(block_1918);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[247];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1918:
    push_frame(block_1917);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[248];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1917:
    push_frame(block_1916);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[249];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1916:
    push_frame(block_1915);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[241];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1915:
    push_frame(block_1914);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[243];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1914:
    push_frame(block_1913);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[250];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1913:
    push_frame(block_1912);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[147];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1912:
    push_frame(block_1911);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[251];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_1911:
    push_frame(block_1910);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 73);
    fp = sp - 4;
    goto enter;
block_1910:
    a = empty_tuple;
    goto pop_frame;
entry_226:
    push_frame(block_1909);
    a = var(0);
    push_var(a);
    a = constant_env[30];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_1909:
    a = (a.bits == true_value.bits) ? false_value : true_value;
    if (a.bits == false_value.bits) goto block_1903;
    push_frame(block_1908);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[119];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(0);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[186];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_1908:
    push_frame(block_1907);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[187];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(0);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[188];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_1907:
    a = alloc_closure(&heap, 1, 4, &&entry_225 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[2]);
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, var(0));
    push_var(a);
    push_frame(block_1906);
    a = number(0);
    push_var(a);
    a = var(1);
    fp = sp - 4;
    goto enter;
block_1906:
    pop_vars(1);
    push_frame(block_1905);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_1905:
    push_frame(block_1904);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[142];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_1904:
    a = empty_tuple;
    goto pop_frame;
block_1903:
    a = empty_tuple;
    goto pop_frame;
entry_225:
    push_frame(block_1901);
    a = var(0);
    push_var(a);
    push_frame(block_1902);
    a = closure_env[3];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 130);
    fp = sp - 4;
    goto enter;
block_1902:
    push_var(a);
    a = constant_env[38];
    fp = sp - 5;
    goto enter;
block_1901:
    if (a.bits == false_value.bits) goto block_1897;
    push_frame(block_1899);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[35];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1900);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1900:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[185];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1899:
    push_frame(block_1898);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1898:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
block_1897:
    a = empty_tuple;
    goto pop_frame;
entry_224:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 36:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1896;
    case 29:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1893;
    default:
        halt();
    }
block_1896:
    push_frame(block_1894);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[184];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1895);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1895:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[183];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1894:
    pop_vars(1);
    goto block_1888;
block_1893:
    push_frame(block_1889);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[181];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1891);
    push_frame(block_1892);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 130);
    fp = sp - 4;
    goto enter;
block_1892:
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1891:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[182];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1890);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1890:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[183];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1889:
    pop_vars(1);
    goto block_1888;
block_1888:
    a = empty_tuple;
    goto pop_frame;
entry_223:
    push_frame(block_1887);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[179];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1887:
    push_frame(block_1886);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_222 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[2]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_1886:
    push_frame(block_1885);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[180];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1885:
    a = empty_tuple;
    goto pop_frame;
entry_222:
    push_frame(block_1883);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[110];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1884);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1884:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1883:
    goto pop_frame;
entry_221:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1881);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[176];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[177];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1882);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1882:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[178];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1881:
    goto pop_frame;
entry_220:
    push_frame(block_1880);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_219 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[2]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_1880:
    goto pop_frame;
entry_219:
    push_frame(block_1879);
    a = closure_env[1];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 129);
    fp = sp - 5;
    goto enter;
block_1879:
    goto pop_frame;
entry_218:
    a = alloc_closure(&heap, 1, 6, &&entry_217 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, var(2));
    closure_store(&heap, a, 3, closure_env[2]);
    closure_store(&heap, a, 4, var(0));
    closure_store(&heap, a, 5, var(1));
    goto pop_frame;
entry_217:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 89:
        goto block_1878;
    case 85:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1876;
    case 93:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1871;
    case 26:
        goto block_1867;
    case 7:
        goto block_1864;
    case 108:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1861;
    case 52:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1858;
    case 122:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1855;
    case 88:
        goto block_1852;
    case 87:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1850;
    case 105:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1842;
    case 48:
        goto block_1836;
    case 47:
        goto block_1834;
    case 46:
        goto block_1832;
    case 32:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1830;
    case 84:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1827;
    case 90:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1824;
    case 98:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1821;
    case 97:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1818;
    case 96:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1815;
    case 99:
        goto block_1812;
    case 42:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1810;
    case 43:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1794;
    case 104:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1783;
    case 95:
        goto block_1780;
    case 101:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1778;
    case 103:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1775;
    case 100:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1771;
    case 94:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1766;
    case 107:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1763;
    case 106:
        goto block_1760;
    case 30:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1758;
    case 102:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_1755;
    case 117:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1748;
    case 116:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1745;
    default:
        goto block_1742;
    }
block_1878:
    push_frame(block_1877);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[175];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1877:
    goto pop_frame;
block_1876:
    push_frame(block_1875);
    a = var(1);
    push_var(a);
    a = number(0);
    push_var(a);
    a = constant_env[93];
    fp = sp - 5;
    goto enter;
block_1875:
    if (a.bits == false_value.bits) goto block_1872;
    push_frame(block_1873);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1874);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1874:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[160];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1873:
    goto pop_frame;
block_1872:
    a = empty_tuple;
    goto pop_frame;
block_1871:
    push_frame(block_1868);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1870);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1870:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[173];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1869);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1869:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[174];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1868:
    goto pop_frame;
block_1867:
    push_frame(block_1865);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1866);
    a = closure_env[5];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1866:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[152];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1865:
    goto pop_frame;
block_1864:
    push_frame(block_1862);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[150];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1863);
    a = closure_env[2];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1863:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[151];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1862:
    goto pop_frame;
block_1861:
    push_frame(block_1859);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[133];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1860);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1860:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[172];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1859:
    goto pop_frame;
block_1858:
    push_frame(block_1856);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[133];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1857);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1857:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[171];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1856:
    goto pop_frame;
block_1855:
    push_frame(block_1853);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[169];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1854);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1854:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[170];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1853:
    goto pop_frame;
block_1852:
    push_frame(block_1851);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[166];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[167];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[168];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1851:
    goto pop_frame;
block_1850:
    push_frame(block_1843);
    push_frame(block_1849);
    a = var(1);
    push_var(a);
    a = number(0);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_1849:
    if (a.bits == false_value.bits) goto block_1845;
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[164];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    goto block_1844;
block_1845:
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1848);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1848:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[160];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1847);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1847:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[161];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1846);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1846:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[165];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
block_1844:
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1843:
    goto pop_frame;
block_1842:
    push_frame(block_1837);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1841);
    a = var(2);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1841:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[160];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1840);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1840:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[110];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1839);
    a = var(2);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1839:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[161];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1838);
    a = var(2);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1838:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[162];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[163];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1837:
    goto pop_frame;
block_1836:
    push_frame(block_1835);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[159];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1835:
    goto pop_frame;
block_1834:
    push_frame(block_1833);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[158];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1833:
    goto pop_frame;
block_1832:
    push_frame(block_1831);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[157];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1831:
    goto pop_frame;
block_1830:
    push_frame(block_1828);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[119];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1829);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1829:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[156];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1828:
    goto pop_frame;
block_1827:
    push_frame(block_1825);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1826);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1826:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[155];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1825:
    goto pop_frame;
block_1824:
    push_frame(block_1822);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1823);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1823:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[154];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1822:
    goto pop_frame;
block_1821:
    push_frame(block_1819);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1820);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1820:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[153];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1819:
    goto pop_frame;
block_1818:
    push_frame(block_1816);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1817);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1817:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[152];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1816:
    goto pop_frame;
block_1815:
    push_frame(block_1813);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[150];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1814);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1814:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[151];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1813:
    goto pop_frame;
block_1812:
    push_frame(block_1811);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[149];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1811:
    goto pop_frame;
block_1810:
    a = alloc_closure(&heap, 1, 2, &&entry_216 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[4]);
    push_var(a);
    push_frame(block_1809);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[148];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1809:
    push_frame(block_1808);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_1808:
    push_frame(block_1807);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[145];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1807:
    a = var(2);
    switch (value_label(&heap, a)) {
    case 1:
        goto block_1806;
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1804;
    default:
        halt();
    }
block_1806:
    push_frame(block_1805);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[146];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1805:
    goto block_1796;
block_1804:
    a = var(4);
    switch (value_label(&heap, a)) {
    case 92:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1803;
    case 84:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1800;
    default:
        halt();
    }
block_1803:
    push_frame(block_1801);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1802);
    a = var(5);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1802:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[118];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[124];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1801:
    pop_vars(1);
    goto block_1797;
block_1800:
    push_frame(block_1798);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1799);
    a = var(5);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1799:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[118];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1798:
    pop_vars(1);
    goto block_1797;
block_1797:
    pop_vars(1);
    goto block_1796;
block_1796:
    push_frame(block_1795);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[147];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1795:
    a = empty_tuple;
    goto pop_frame;
block_1794:
    a = alloc_closure(&heap, 1, 2, &&entry_215 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[4]);
    push_var(a);
    push_frame(block_1793);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[144];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1793:
    push_frame(block_1792);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_1792:
    push_frame(block_1791);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[145];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1791:
    a = var(2);
    switch (value_label(&heap, a)) {
    case 1:
        goto block_1790;
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1788;
    default:
        halt();
    }
block_1790:
    push_frame(block_1789);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[146];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1789:
    goto block_1785;
block_1788:
    push_frame(block_1786);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1787);
    a = var(4);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1787:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[118];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1786:
    pop_vars(1);
    goto block_1785;
block_1785:
    push_frame(block_1784);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[147];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1784:
    a = empty_tuple;
    goto pop_frame;
block_1783:
    push_frame(block_1781);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1782);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1782:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[143];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1781:
    goto pop_frame;
block_1780:
    push_frame(block_1779);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[142];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1779:
    goto pop_frame;
block_1778:
    push_frame(block_1776);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[119];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1777);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1777:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[141];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1776:
    goto pop_frame;
block_1775:
    push_frame(block_1772);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[136];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1773);
    push_frame(block_1774);
    a = number(3);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1774:
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1773:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[140];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1772:
    goto pop_frame;
block_1771:
    push_frame(block_1770);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1770:
    push_var(a);
    push_frame(block_1768);
    push_frame(block_1769);
    a = var(1);
    push_var(a);
    a = number(3);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1769:
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1768:
    push_var(a);
    push_frame(block_1767);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[136];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[137];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[138];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[110];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[139];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1767:
    goto pop_frame;
block_1766:
    push_frame(block_1764);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1765);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1765:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[135];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1764:
    goto pop_frame;
block_1763:
    push_frame(block_1761);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[133];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1762);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1762:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[134];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1761:
    goto pop_frame;
block_1760:
    push_frame(block_1759);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[132];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1759:
    goto pop_frame;
block_1758:
    push_frame(block_1756);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1757);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1757:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[131];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1756:
    goto pop_frame;
block_1755:
    push_frame(block_1750);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[128];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1754);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1754:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[129];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[110];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1752);
    push_frame(block_1753);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1753:
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1752:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[110];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1751);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1751:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[130];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1750:
    push_frame(block_1749);
    a = var(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_214 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[3]);
    closure_store(&heap, a, 2, closure_env[4]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 128);
    fp = sp - 5;
    goto enter;
block_1749:
    goto pop_frame;
block_1748:
    push_frame(block_1746);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1747);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1747:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[127];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1746:
    goto pop_frame;
block_1745:
    push_frame(block_1743);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1744);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1744:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[126];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1743:
    goto pop_frame;
block_1742:
    push_frame(block_1741);
    a = constant_env[125];
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_1741:
    goto pop_frame;
entry_216:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1738);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1740);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1740:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[118];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[119];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1739);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1739:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[120];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1738:
    goto pop_frame;
entry_215:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 34:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1737;
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1733;
    case 13:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1729;
    default:
        halt();
    }
block_1737:
    push_frame(block_1734);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1736);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1736:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[118];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[119];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1735);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1735:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[120];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1734:
    goto pop_frame;
block_1733:
    push_frame(block_1730);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1732);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1732:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[118];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[124];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[123];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[119];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1731);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1731:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[120];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1730:
    goto pop_frame;
block_1729:
    push_frame(block_1728);
    a = var(4);
    push_var(a);
    a = number(0);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_1728:
    if (a.bits == false_value.bits) goto block_1719;
    push_frame(block_1725);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1727);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1727:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[118];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[119];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1726);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1726:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[120];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1725:
    goto pop_frame;
block_1719:
    push_frame(block_1720);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1724);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1724:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[118];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[117];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1723);
    a = var(4);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1723:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[121];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1722);
    a = var(4);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1722:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[122];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[123];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[119];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1721);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1721:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[120];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1720:
    goto pop_frame;
entry_214:
    push_frame(block_1717);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[110];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1718);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1718:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[111];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1717:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 94:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1716;
    case 107:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1713;
    case 106:
        goto block_1710;
    default:
        goto block_1708;
    }
block_1716:
    push_frame(block_1714);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[35];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1715);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1715:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[115];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1714:
    pop_vars(1);
    goto block_1706;
block_1713:
    push_frame(block_1711);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[63];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    push_frame(block_1712);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 127);
    fp = sp - 4;
    goto enter;
block_1712:
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[114];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1711:
    pop_vars(1);
    goto block_1706;
block_1710:
    push_frame(block_1709);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[113];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1709:
    goto block_1706;
block_1708:
    push_frame(block_1707);
    a = constant_env[112];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1707:
    goto block_1706;
block_1706:
    push_frame(block_1705);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[116];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1705:
    a = empty_tuple;
    goto pop_frame;
entry_213:
    push_frame(block_1704);
    a = var(0);
    a = module_fetch(&heap, a, 114);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 126);
    fp = sp - 4;
    goto enter;
block_1704:
    switch (value_label(&heap, a)) {
    case 1:
        goto block_1703;
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1701;
    default:
        halt();
    }
block_1703:
    push_frame(block_1702);
    a = constant_env[109];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1702:
    goto pop_frame;
block_1701:
    a = var(1);
    a = module_fetch(&heap, a, 58);
    goto pop_frame;
entry_212:
    push_frame(block_1700);
    a = var(0);
    a = module_fetch(&heap, a, 113);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_211 - &&entry_0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1700:
    goto pop_frame;
entry_211:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 29:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1699;
    default:
        goto block_1697;
    }
block_1699:
    push_frame(block_1698);
    a = var(2);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1698:
    goto pop_frame;
block_1697:
    a = var(0);
    goto pop_frame;
entry_210:
    push_frame(block_1696);
    a = var(1);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_209 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(0));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1696:
    goto pop_frame;
entry_209:
    a = alloc_closure(&heap, 2, 3, &&entry_208 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, var(1));
    push_var(a);
    push_frame(block_1695);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(2);
    fp = sp - 5;
    goto enter;
block_1695:
    goto pop_frame;
entry_208:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_1694;
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1691;
    default:
        halt();
    }
block_1694:
    push_frame(block_1692);
    push_frame(block_1693);
    a = closure_env[2];
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1693:
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_1692:
    goto pop_frame;
block_1691:
    push_frame(block_1690);
    a = closure_env[2];
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_1690:
    switch (value_label(&heap, a)) {
    case 110:
        goto block_1689;
    default:
        goto block_1686;
    }
block_1689:
    push_frame(block_1687);
    a = var(0);
    push_var(a);
    push_frame(block_1688);
    a = closure_env[2];
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1688:
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 125);
    fp = sp - 5;
    goto enter;
block_1687:
    goto pop_frame;
block_1686:
    push_frame(block_1685);
    a = var(2);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1685:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
entry_207:
    push_frame(block_1684);
    a = var(0);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_1684:
    push_var(a);
    push_frame(block_1683);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1683:
    push_var(a);
    push_frame(block_1682);
    a = var(2);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1682:
    push_var(a);
    push_frame(block_1681);
    a = var(3);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1681:
    push_var(a);
    push_frame(block_1680);
    a = var(4);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1680:
    push_var(a);
    a = var(5);
    goto pop_frame;
entry_206:
    push_frame(block_1679);
    a = var(0);
    a = module_fetch(&heap, a, 114);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1679:
    push_var(a);
    push_frame(block_1676);
    a = var(0);
    a = module_fetch(&heap, a, 114);
    push_var(a);
    a = number(0);
    push_var(a);
    push_frame(block_1677);
    a = var(1);
    push_var(a);
    push_frame(block_1678);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_1678:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1677:
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_203 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1676:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_1675);
    a = var(0);
    a = module_fetch(&heap, a, 114);
    push_var(a);
    a = var(2);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_205 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1675:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(0);
    a = module_fetch(&heap, a, 113);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 114);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 118);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 119);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 120);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 121);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-8], 8, 44);
    pop_vars(8);
    goto pop_frame;
entry_205:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1674);
    a = var(0);
    a = module_fetch(&heap, a, 82);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_204 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1674:
    goto pop_frame;
entry_204:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1673);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(86);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    fp = sp - 7;
    goto enter;
block_1673:
    goto pop_frame;
entry_203:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_1671);
    a = var(0);
    a = module_fetch(&heap, a, 81);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1672);
    a = var(3);
    a = alloc_labeled_value(&heap, 122, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1672:
    push_var(a);
    a = closure_env[0];
    fp = sp - 7;
    goto enter;
block_1671:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(5);
    push_var(a);
    push_frame(block_1669);
    a = var(3);
    push_var(a);
    push_frame(block_1670);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_1670:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1669:
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_202:
    push_frame(block_1668);
    a = closure_env[2];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_182 - &&entry_0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 59);
    fp = sp - 5;
    goto enter;
block_1668:
    push_var(a);
    a = alloc_closure(&heap, 3, 4, &&entry_199 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, closure_env[4]);
    push_var(a);
    push_frame(block_1667);
    a = var(0);
    a = module_fetch(&heap, a, 114);
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_201 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(2));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1667:
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 113);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 118);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 119);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 120);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 121);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-6], 6, 37);
    pop_vars(6);
    goto pop_frame;
entry_201:
    a = var(0);
    a = module_fetch(&heap, a, 57);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 58);
    push_var(a);
    push_frame(block_1666);
    a = closure_env[1];
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = number(0);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 81);
    push_var(a);
    a = closure_env[2];
    fp = sp - 6;
    goto enter;
block_1666:
    push_var(a);
    push_frame(block_1665);
    a = var(0);
    a = module_fetch(&heap, a, 82);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_200 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[2]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1665:
    push_var(a);
    a = alloc_module(&heap, &stack[sp-4], 4, 29);
    pop_vars(4);
    goto pop_frame;
entry_200:
    push_frame(block_1664);
    a = closure_env[0];
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = number(0);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 6;
    goto enter;
block_1664:
    goto pop_frame;
entry_199:
    a = var(2);
    switch (value_label(&heap, a)) {
    case 48:
        goto block_1663;
    case 47:
        goto block_1662;
    case 30:
        goto block_1661;
    case 108:
        goto block_1660;
    case 52:
        goto block_1659;
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1658;
    case 54:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1653;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1651;
    case 53:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1648;
    case 32:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1645;
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1642;
    case 80:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_1634;
    case 25:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 5);
        sp += 5;
        goto block_1632;
    case 51:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1623;
    case 42:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1614;
    case 50:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1611;
    case 49:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_1609;
    case 46:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1605;
    case 45:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1603;
    case 44:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1600;
    case 41:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1597;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1595;
    case 43:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1593;
    default:
        halt();
    }
block_1663:
    a = var(2);
    goto pop_frame;
block_1662:
    a = var(2);
    goto pop_frame;
block_1661:
    a = var(2);
    goto pop_frame;
block_1660:
    a = var(2);
    goto pop_frame;
block_1659:
    a = var(2);
    goto pop_frame;
block_1658:
    push_frame(block_1657);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_1657:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1656;
    case 1:
        goto block_1655;
    default:
        halt();
    }
block_1656:
    a = var(5);
    goto pop_frame;
block_1655:
    push_frame(block_1654);
    a = constant_env[108];
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_1654:
    goto pop_frame;
block_1653:
    push_frame(block_1652);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1652:
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 54, a);
    goto pop_frame;
block_1651:
    push_frame(block_1650);
    a = var(3);
    push_var(a);
    a = var(1);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_198 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1650:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1649);
    a = var(5);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_1649:
    a = alloc_labeled_value(&heap, 13, a);
    goto pop_frame;
block_1648:
    push_frame(block_1647);
    a = var(4);
    push_var(a);
    a = var(1);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_197 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1647:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(3);
    push_var(a);
    push_frame(block_1646);
    a = var(6);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_1646:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 53, a);
    goto pop_frame;
block_1645:
    push_frame(block_1644);
    a = var(3);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(0);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 4, &&entry_196 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[2]);
    closure_store(&heap, a, 3, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1644:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_1643);
    a = var(7);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1643:
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 32, a);
    goto pop_frame;
block_1642:
    push_frame(block_1639);
    push_frame(block_1641);
    a = var(1);
    push_var(a);
    a = number(3);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1641:
    push_var(a);
    push_frame(block_1640);
    a = var(4);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1640:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1639:
    push_var(a);
    push_frame(block_1638);
    a = var(0);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1638:
    push_var(a);
    push_frame(block_1635);
    a = var(4);
    push_var(a);
    push_frame(block_1636);
    a = var(5);
    push_var(a);
    push_frame(block_1637);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_1637:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1636:
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_193 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1635:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(6);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    goto pop_frame;
block_1634:
    push_frame(block_1633);
    a = var(4);
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_192 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1633:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 80, a);
    goto pop_frame;
block_1632:
    a = var(4);
    switch (value_label(&heap, a)) {
    case 1:
        goto block_1631;
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1630;
    default:
        halt();
    }
block_1631:
    a = var(0);
    goto block_1628;
block_1630:
    push_frame(block_1629);
    a = var(0);
    push_var(a);
    a = var(8);
    push_var(a);
    a = labeled_empty_tuple(106);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1629:
    pop_vars(1);
    goto block_1628;
block_1628:
    push_var(a);
    push_frame(block_1627);
    a = var(5);
    push_var(a);
    a = number(0);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_189 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1627:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1626);
    a = var(6);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1626:
    push_var(a);
    push_frame(block_1625);
    a = var(6);
    push_var(a);
    a = number(0);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_191 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1625:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_1624);
    a = var(14);
    push_var(a);
    a = var(13);
    push_var(a);
    a = var(7);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1624:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(15);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 25, a);
    goto pop_frame;
block_1623:
    a = var(3);
    switch (value_label(&heap, a)) {
    case 27:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1622;
    default:
        halt();
    }
block_1622:
    a = var(4);
    pop_vars(1);
    goto block_1621;
block_1621:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1619);
    a = var(1);
    push_var(a);
    push_frame(block_1620);
    a = var(5);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1620:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1619:
    push_var(a);
    push_frame(block_1618);
    a = var(0);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1618:
    push_var(a);
    push_frame(block_1615);
    a = var(5);
    push_var(a);
    push_frame(block_1616);
    a = var(6);
    push_var(a);
    push_frame(block_1617);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_1617:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1616:
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_188 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1615:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    a = alloc_labeled_value(&heap, 51, a);
    goto pop_frame;
block_1614:
    push_frame(block_1613);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1613:
    push_var(a);
    push_frame(block_1612);
    a = var(4);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 4, &&entry_187 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, var(0));
    closure_store(&heap, a, 2, var(1));
    closure_store(&heap, a, 3, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1612:
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 42, a);
    goto pop_frame;
block_1611:
    push_frame(block_1610);
    a = var(3);
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_186 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1610:
    push_var(a);
    a = var(4);
    a = alloc_labeled_value(&heap, 50, a);
    goto pop_frame;
block_1609:
    push_frame(block_1608);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1608:
    push_var(a);
    push_frame(block_1607);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1607:
    push_var(a);
    push_frame(block_1606);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1606:
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 49, a);
    goto pop_frame;
block_1605:
    push_frame(block_1604);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1604:
    a = alloc_labeled_value(&heap, 46, a);
    goto pop_frame;
block_1603:
    push_frame(block_1602);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1602:
    push_var(a);
    push_frame(block_1601);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1601:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 45, a);
    goto pop_frame;
block_1600:
    push_frame(block_1599);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1599:
    push_var(a);
    push_frame(block_1598);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1598:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 44, a);
    goto pop_frame;
block_1597:
    push_frame(block_1596);
    a = var(3);
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_185 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1596:
    a = alloc_labeled_value(&heap, 41, a);
    goto pop_frame;
block_1595:
    a = var(3);
    push_var(a);
    push_frame(block_1594);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1594:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    goto pop_frame;
block_1593:
    push_frame(block_1592);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_1592:
    push_var(a);
    push_frame(block_1591);
    a = var(4);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 5, &&entry_184 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, var(0));
    closure_store(&heap, a, 3, var(1));
    closure_store(&heap, a, 4, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1591:
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 43, a);
    goto pop_frame;
entry_198:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1590);
    a = closure_env[0];
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    fp = sp - 6;
    goto enter;
block_1590:
    push_var(a);
    push_frame(block_1589);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1589:
    push_var(a);
    push_frame(block_1588);
    a = var(4);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1588:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_197:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1587;
    default:
        halt();
    }
block_1587:
    a = var(4);
    push_var(a);
    push_frame(block_1586);
    a = closure_env[0];
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[1];
    fp = sp - 6;
    goto enter;
block_1586:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    push_var(a);
    push_frame(block_1585);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1585:
    push_var(a);
    push_frame(block_1584);
    a = var(6);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1584:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_196:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_1583);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 5, &&entry_195 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[2]);
    closure_store(&heap, a, 3, var(4));
    closure_store(&heap, a, 4, closure_env[3]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1583:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_1582);
    a = var(5);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1582:
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_195:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1581;
    case 31:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1575;
    default:
        halt();
    }
block_1581:
    a = var(5);
    switch (value_label(&heap, a)) {
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1580;
    case 17:
        goto block_1578;
    default:
        halt();
    }
block_1580:
    push_frame(block_1579);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1579:
    a = alloc_labeled_value(&heap, 13, a);
    pop_vars(1);
    goto block_1577;
block_1578:
    a = labeled_empty_tuple(17);
    goto block_1577;
block_1577:
    push_var(a);
    a = var(7);
    push_var(a);
    push_frame(block_1576);
    a = closure_env[3];
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(6);
    push_var(a);
    a = closure_env[4];
    fp = sp - 6;
    goto enter;
block_1576:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    pop_vars(1);
    pop_vars(2);
    goto block_1573;
block_1575:
    push_frame(block_1574);
    a = closure_env[3];
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[4];
    fp = sp - 6;
    goto enter;
block_1574:
    a = alloc_labeled_value(&heap, 31, a);
    pop_vars(1);
    goto block_1573;
block_1573:
    push_var(a);
    push_frame(block_1571);
    push_frame(block_1572);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1572:
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_194 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1571:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1570);
    a = var(5);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1570:
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_194:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1569);
    a = var(2);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    a = alloc_labeled_value(&heap, 94, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1569:
    push_var(a);
    push_frame(block_1568);
    a = var(3);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1568:
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_193:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1566);
    a = var(2);
    push_var(a);
    push_frame(block_1567);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_1567:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1566:
    push_var(a);
    push_frame(block_1564);
    push_frame(block_1565);
    a = closure_env[0];
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 6;
    goto enter;
block_1565:
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1564:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_192:
    push_frame(block_1563);
    a = closure_env[0];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(0);
    a = alloc_labeled_value(&heap, 17, a);
    push_var(a);
    a = closure_env[2];
    fp = sp - 6;
    goto enter;
block_1563:
    goto pop_frame;
entry_191:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 16:
        goto block_1562;
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1561;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1559;
    default:
        halt();
    }
block_1562:
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1557;
block_1561:
    a = var(3);
    push_var(a);
    push_frame(block_1560);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 94, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1560:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    pop_vars(1);
    goto block_1557;
block_1559:
    push_frame(block_1558);
    a = var(5);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_190 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1558:
    pop_vars(1);
    goto block_1557;
block_1557:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1556);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1556:
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_190:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1555);
    a = var(3);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 94, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1555:
    push_var(a);
    push_frame(block_1554);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1554:
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_189:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1553);
    a = var(3);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 107, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1553:
    push_var(a);
    push_frame(block_1552);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1552:
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_188:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1550);
    a = var(2);
    push_var(a);
    push_frame(block_1551);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_1551:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1550:
    push_var(a);
    push_frame(block_1548);
    push_frame(block_1549);
    a = closure_env[0];
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 6;
    goto enter;
block_1549:
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1548:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_187:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 34:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1547;
    case 33:
        goto block_1541;
    default:
        halt();
    }
block_1547:
    a = var(4);
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1546;
    case 1:
        goto block_1543;
    default:
        halt();
    }
block_1546:
    push_frame(block_1545);
    a = closure_env[2];
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1545:
    push_var(a);
    push_frame(block_1544);
    a = closure_env[1];
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[2];
    a = alloc_labeled_value(&heap, 94, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1544:
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = labeled_empty_tuple(89);
    a = alloc_labeled_value(&heap, 34, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    pop_vars(2);
    pop_vars(1);
    goto block_1542;
block_1543:
    a = closure_env[2];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = labeled_empty_tuple(91);
    a = alloc_labeled_value(&heap, 34, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto block_1542;
block_1542:
    pop_vars(1);
    goto block_1540;
block_1541:
    a = closure_env[2];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto block_1540;
block_1540:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_1539);
    a = var(5);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[3];
    fp = sp - 6;
    goto enter;
block_1539:
    push_var(a);
    push_frame(block_1538);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1538:
    goto pop_frame;
entry_186:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1537);
    a = closure_env[0];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[2];
    fp = sp - 6;
    goto enter;
block_1537:
    push_var(a);
    push_frame(block_1536);
    a = closure_env[0];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    fp = sp - 6;
    goto enter;
block_1536:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_185:
    push_frame(block_1535);
    a = closure_env[0];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    fp = sp - 6;
    goto enter;
block_1535:
    goto pop_frame;
entry_184:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_1534;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1533;
    default:
        halt();
    }
block_1534:
    a = labeled_empty_tuple(34);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1527;
block_1533:
    a = var(5);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_1532;
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1531;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1530;
    default:
        halt();
    }
block_1532:
    a = labeled_empty_tuple(34);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1528;
block_1531:
    a = labeled_empty_tuple(17);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(6);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    pop_vars(1);
    goto block_1528;
block_1530:
    push_frame(block_1529);
    a = var(6);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1529:
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    pop_vars(1);
    goto block_1528;
block_1528:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    pop_vars(2);
    pop_vars(2);
    goto block_1527;
block_1527:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1526);
    a = var(5);
    push_var(a);
    a = closure_env[3];
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_183 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1526:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1525);
    a = var(7);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[4];
    fp = sp - 6;
    goto enter;
block_1525:
    push_var(a);
    push_frame(block_1524);
    a = var(4);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1524:
    goto pop_frame;
entry_183:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1523);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1523:
    push_var(a);
    push_frame(block_1522);
    a = var(3);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 94, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1522:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_182:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    goto pop_frame;
entry_181:
    push_frame(block_1521);
    a = closure_env[3];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_163 - &&entry_0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 59);
    fp = sp - 5;
    goto enter;
block_1521:
    push_var(a);
    push_frame(block_1520);
    a = closure_env[4];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_164 - &&entry_0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 59);
    fp = sp - 5;
    goto enter;
block_1520:
    push_var(a);
    push_frame(block_1519);
    a = alloc_closure(&heap, 2, 1, &&entry_167 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_165 - &&entry_0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 59);
    fp = sp - 5;
    goto enter;
block_1519:
    push_var(a);
    push_frame(block_1518);
    a = var(1);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = constant_env[104];
    fp = sp - 4;
    goto enter;
block_1518:
    push_var(a);
    push_frame(block_1517);
    a = var(2);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = constant_env[104];
    fp = sp - 4;
    goto enter;
block_1517:
    push_var(a);
    push_frame(block_1516);
    a = var(3);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = constant_env[104];
    fp = sp - 4;
    goto enter;
block_1516:
    push_var(a);
    push_frame(block_1515);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[104];
    fp = sp - 4;
    goto enter;
block_1515:
    push_var(a);
    push_frame(block_1514);
    a = number(0);
    push_var(a);
    a = constant_env[104];
    fp = sp - 4;
    goto enter;
block_1514:
    push_var(a);
    push_frame(block_1513);
    a = number(0);
    push_var(a);
    a = constant_env[104];
    fp = sp - 4;
    goto enter;
block_1513:
    push_var(a);
    a = alloc_closure(&heap, 1, 5, &&entry_168 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(2));
    closure_store(&heap, a, 2, var(8));
    closure_store(&heap, a, 3, var(5));
    closure_store(&heap, a, 4, var(4));
    push_var(a);
    a = alloc_closure(&heap, 1, 5, &&entry_169 - &&entry_0);
    closure_store(&heap, a, 0, var(3));
    closure_store(&heap, a, 1, closure_env[0]);
    closure_store(&heap, a, 2, var(9));
    closure_store(&heap, a, 3, var(6));
    closure_store(&heap, a, 4, var(7));
    push_var(a);
    a = alloc_closure(&heap, 1, 6, &&entry_179 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[2]);
    closure_store(&heap, a, 2, closure_env[4]);
    closure_store(&heap, a, 3, closure_env[5]);
    closure_store(&heap, a, 4, var(10));
    closure_store(&heap, a, 5, var(11));
    push_var(a);
    push_frame(block_1512);
    a = var(0);
    a = module_fetch(&heap, a, 114);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_180 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(12));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1512:
    push_var(a);
    push_frame(block_1511);
    a = constant_env[107];
    push_var(a);
    a = var(10);
    fp = sp - 4;
    goto enter;
block_1511:
    push_var(a);
    push_frame(block_1510);
    a = constant_env[30];
    push_var(a);
    a = var(10);
    fp = sp - 4;
    goto enter;
block_1510:
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 113);
    push_var(a);
    a = var(13);
    push_var(a);
    push_frame(block_1508);
    push_frame(block_1509);
    a = var(5);
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1509:
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 41);
    fp = sp - 4;
    goto enter;
block_1508:
    push_var(a);
    push_frame(block_1506);
    push_frame(block_1507);
    a = var(7);
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1507:
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_1506:
    push_var(a);
    a = var(14);
    push_var(a);
    a = var(15);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-6], 6, 37);
    pop_vars(6);
    goto pop_frame;
entry_180:
    a = var(0);
    a = module_fetch(&heap, a, 57);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 58);
    push_var(a);
    push_frame(block_1505);
    a = var(0);
    a = module_fetch(&heap, a, 81);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1505:
    push_var(a);
    push_frame(block_1504);
    a = var(0);
    a = module_fetch(&heap, a, 82);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1504:
    push_var(a);
    a = alloc_module(&heap, &stack[sp-4], 4, 29);
    pop_vars(4);
    goto pop_frame;
entry_179:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 48:
        goto block_1503;
    case 47:
        goto block_1502;
    case 30:
        goto block_1501;
    case 108:
        goto block_1500;
    case 52:
        goto block_1499;
    case 17:
        goto block_1498;
    case 54:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1497;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1494;
    case 53:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1492;
    case 32:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1487;
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1484;
    case 80:
        goto block_1481;
    case 25:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 5);
        sp += 5;
        goto block_1480;
    case 51:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1478;
    case 42:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1476;
    case 50:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1473;
    case 49:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_1471;
    case 46:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1467;
    case 45:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1465;
    case 44:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1462;
    case 41:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1459;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1457;
    case 43:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1454;
    default:
        halt();
    }
block_1503:
    a = var(0);
    goto pop_frame;
block_1502:
    a = var(0);
    goto pop_frame;
block_1501:
    a = var(0);
    goto pop_frame;
block_1500:
    a = var(0);
    goto pop_frame;
block_1499:
    a = var(0);
    goto pop_frame;
block_1498:
    a = var(0);
    goto pop_frame;
block_1497:
    push_frame(block_1496);
    a = var(2);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_178 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[4]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1496:
    push_var(a);
    push_frame(block_1495);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1495:
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 54, a);
    goto pop_frame;
block_1494:
    push_frame(block_1493);
    a = var(1);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1493:
    a = alloc_labeled_value(&heap, 13, a);
    goto pop_frame;
block_1492:
    push_frame(block_1491);
    a = var(1);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_175 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[3]);
    closure_store(&heap, a, 1, closure_env[4]);
    closure_store(&heap, a, 2, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1491:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1490);
    a = closure_env[2];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 112);
    fp = sp - 5;
    goto enter;
block_1490:
    push_var(a);
    push_frame(block_1489);
    a = var(4);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_1489:
    push_var(a);
    push_frame(block_1488);
    a = var(4);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 4, &&entry_177 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(2));
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, closure_env[4]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1488:
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 53, a);
    goto pop_frame;
block_1487:
    push_frame(block_1486);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_174 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1486:
    push_var(a);
    push_frame(block_1485);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1485:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 32, a);
    goto pop_frame;
block_1484:
    push_frame(block_1483);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1483:
    push_var(a);
    push_frame(block_1482);
    a = var(2);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1482:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    goto pop_frame;
block_1481:
    a = var(0);
    goto pop_frame;
block_1480:
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    push_frame(block_1479);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1479:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 25, a);
    goto pop_frame;
block_1478:
    push_frame(block_1477);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1477:
    a = alloc_labeled_value(&heap, 51, a);
    goto pop_frame;
block_1476:
    push_frame(block_1475);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1475:
    push_var(a);
    push_frame(block_1474);
    a = var(2);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_172 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1474:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 42, a);
    goto pop_frame;
block_1473:
    push_frame(block_1472);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_171 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1472:
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 50, a);
    goto pop_frame;
block_1471:
    push_frame(block_1470);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1470:
    push_var(a);
    push_frame(block_1469);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1469:
    push_var(a);
    push_frame(block_1468);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1468:
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 49, a);
    goto pop_frame;
block_1467:
    push_frame(block_1466);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1466:
    a = alloc_labeled_value(&heap, 46, a);
    goto pop_frame;
block_1465:
    push_frame(block_1464);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1464:
    push_var(a);
    push_frame(block_1463);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1463:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 45, a);
    goto pop_frame;
block_1462:
    push_frame(block_1461);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1461:
    push_var(a);
    push_frame(block_1460);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1460:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 44, a);
    goto pop_frame;
block_1459:
    push_frame(block_1458);
    a = var(1);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1458:
    a = alloc_labeled_value(&heap, 41, a);
    goto pop_frame;
block_1457:
    push_frame(block_1456);
    a = var(1);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_1456:
    push_var(a);
    push_frame(block_1455);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1455:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    goto pop_frame;
block_1454:
    push_frame(block_1453);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1453:
    push_var(a);
    push_frame(block_1452);
    a = var(2);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_170 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[4]);
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1452:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 43, a);
    goto pop_frame;
entry_178:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 12:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1451;
    case 30:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1449;
    default:
        halt();
    }
block_1451:
    push_frame(block_1450);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1450:
    a = alloc_labeled_value(&heap, 117, a);
    goto pop_frame;
block_1449:
    a = var(1);
    a = alloc_labeled_value(&heap, 116, a);
    goto pop_frame;
entry_177:
    push_frame(block_1448);
    a = closure_env[1];
    push_var(a);
    a = labeled_empty_tuple(1);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_176 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[3]);
    closure_store(&heap, a, 1, var(0));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1448:
    push_var(a);
    a = var(2);
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1447;
    case 1:
        goto block_1445;
    default:
        halt();
    }
block_1447:
    push_frame(block_1446);
    a = var(3);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1446:
    goto pop_frame;
block_1445:
    push_frame(block_1444);
    a = constant_env[106];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1444:
    goto pop_frame;
entry_176:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 1:
        goto block_1443;
    case 3:
        goto block_1437;
    default:
        halt();
    }
block_1443:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1442;
    default:
        halt();
    }
block_1442:
    a = var(2);
    switch (value_label(&heap, a)) {
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1441;
    default:
        halt();
    }
block_1441:
    push_frame(block_1439);
    a = closure_env[1];
    push_var(a);
    push_frame(block_1440);
    a = var(4);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1440:
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_1439:
    if (a.bits == false_value.bits) goto block_1438;
    a = var(1);
    a = alloc_labeled_value(&heap, 3, a);
    goto pop_frame;
block_1438:
    a = labeled_empty_tuple(1);
    goto pop_frame;
block_1437:
    a = var(0);
    goto pop_frame;
entry_175:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1436;
    default:
        halt();
    }
block_1436:
    a = var(4);
    push_var(a);
    push_frame(block_1435);
    a = var(5);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1435:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    push_var(a);
    a = var(4);
    switch (value_label(&heap, a)) {
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1434;
    default:
        goto block_1432;
    }
block_1434:
    push_frame(block_1433);
    a = var(7);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1433:
    pop_vars(1);
    goto block_1430;
block_1432:
    push_frame(block_1431);
    a = constant_env[105];
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1431:
    goto block_1430;
block_1430:
    push_var(a);
    push_frame(block_1429);
    a = var(6);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1429:
    push_var(a);
    push_frame(block_1428);
    a = var(7);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1428:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_174:
    push_frame(block_1427);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_173 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1427:
    goto pop_frame;
entry_173:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1426;
    case 31:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1424;
    default:
        halt();
    }
block_1426:
    a = var(1);
    push_var(a);
    push_frame(block_1425);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1425:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    goto pop_frame;
block_1424:
    push_frame(block_1423);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1423:
    a = alloc_labeled_value(&heap, 31, a);
    goto pop_frame;
entry_172:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    push_var(a);
    push_frame(block_1422);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1422:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_171:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1421);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1421:
    push_var(a);
    push_frame(block_1420);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1420:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_170:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_1419;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1418;
    default:
        halt();
    }
block_1419:
    a = var(2);
    goto block_1416;
block_1418:
    push_frame(block_1417);
    a = var(4);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1417:
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    pop_vars(1);
    pop_vars(2);
    goto block_1416;
block_1416:
    push_var(a);
    push_frame(block_1414);
    a = var(4);
    push_var(a);
    push_frame(block_1415);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1415:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1414:
    goto pop_frame;
entry_169:
    push_frame(block_1412);
    push_frame(block_1413);
    a = closure_env[3];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1413:
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_1412:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1411;
    case 1:
        goto block_1410;
    default:
        halt();
    }
block_1411:
    a = var(2);
    goto pop_frame;
block_1410:
    push_frame(block_1409);
    a = closure_env[2];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1409:
    push_var(a);
    push_frame(block_1405);
    a = closure_env[2];
    push_var(a);
    push_frame(block_1406);
    push_frame(block_1407);
    a = var(1);
    push_var(a);
    push_frame(block_1408);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1408:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1407:
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1406:
    push_var(a);
    a = constant_env[103];
    fp = sp - 5;
    goto enter;
block_1405:
    push_frame(block_1402);
    a = closure_env[3];
    push_var(a);
    push_frame(block_1403);
    push_frame(block_1404);
    a = closure_env[3];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1404:
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1403:
    push_var(a);
    a = constant_env[103];
    fp = sp - 5;
    goto enter;
block_1402:
    push_frame(block_1399);
    a = closure_env[4];
    push_var(a);
    push_frame(block_1400);
    a = var(0);
    push_var(a);
    push_frame(block_1401);
    a = closure_env[4];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1401:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1400:
    push_var(a);
    a = constant_env[103];
    fp = sp - 5;
    goto enter;
block_1399:
    a = var(1);
    goto pop_frame;
entry_168:
    push_frame(block_1397);
    push_frame(block_1398);
    a = closure_env[4];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1398:
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_1397:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1396;
    case 1:
        goto block_1395;
    default:
        halt();
    }
block_1396:
    a = var(2);
    goto pop_frame;
block_1395:
    push_frame(block_1394);
    a = closure_env[2];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1394:
    push_var(a);
    push_frame(block_1392);
    a = closure_env[2];
    push_var(a);
    push_frame(block_1393);
    a = var(1);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1393:
    push_var(a);
    a = constant_env[103];
    fp = sp - 5;
    goto enter;
block_1392:
    push_frame(block_1389);
    a = closure_env[4];
    push_var(a);
    push_frame(block_1390);
    push_frame(block_1391);
    a = closure_env[4];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1391:
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1390:
    push_var(a);
    a = constant_env[103];
    fp = sp - 5;
    goto enter;
block_1389:
    push_frame(block_1386);
    a = closure_env[3];
    push_var(a);
    push_frame(block_1387);
    push_frame(block_1388);
    a = closure_env[3];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1388:
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(0);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1387:
    push_var(a);
    a = constant_env[103];
    fp = sp - 5;
    goto enter;
block_1386:
    a = var(1);
    goto pop_frame;
entry_167:
    push_frame(block_1385);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1385:
    push_var(a);
    push_frame(block_1384);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1384:
    push_var(a);
block_1383:
    push_frame(block_1382);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[38];
    fp = sp - 5;
    goto enter;
block_1382:
    if (a.bits == false_value.bits) goto block_1381;
    a = labeled_empty_tuple(110);
    goto pop_frame;
block_1381:
    push_frame(block_1380);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[93];
    fp = sp - 5;
    goto enter;
block_1380:
    if (a.bits == false_value.bits) goto block_1379;
    a = labeled_empty_tuple(111);
    goto pop_frame;
block_1379:
    a = true_value;
    if (a.bits == false_value.bits) goto block_1376;
    push_frame(block_1377);
    push_frame(block_1378);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 115);
    fp = sp - 5;
    goto enter;
block_1378:
    push_var(a);
    a = labeled_empty_tuple(9);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_166 - &&entry_0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1377:
    goto pop_frame;
block_1376:
    halt();
entry_166:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 9:
        goto block_1375;
    default:
        goto block_1368;
    }
block_1375:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_1374:
    push_frame(block_1373);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[38];
    fp = sp - 5;
    goto enter;
block_1373:
    if (a.bits == false_value.bits) goto block_1372;
    a = labeled_empty_tuple(110);
    goto pop_frame;
block_1372:
    push_frame(block_1371);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[93];
    fp = sp - 5;
    goto enter;
block_1371:
    if (a.bits == false_value.bits) goto block_1370;
    a = labeled_empty_tuple(111);
    goto pop_frame;
block_1370:
    a = true_value;
    if (a.bits == false_value.bits) goto block_1369;
    a = labeled_empty_tuple(9);
    goto pop_frame;
block_1369:
    halt();
block_1368:
    a = var(0);
    goto pop_frame;
entry_165:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    goto pop_frame;
entry_164:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    goto pop_frame;
entry_163:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    goto pop_frame;
entry_162:
    push_frame(block_1367);
    a = alloc_closure(&heap, 2, 2, &&entry_150 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[3]);
    closure_store(&heap, a, 1, closure_env[5]);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_149 - &&entry_0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 59);
    fp = sp - 5;
    goto enter;
block_1367:
    push_var(a);
    push_frame(block_1366);
    a = number(0);
    push_var(a);
    a = constant_env[104];
    fp = sp - 4;
    goto enter;
block_1366:
    push_var(a);
    push_frame(block_1365);
    a = var(1);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = constant_env[104];
    fp = sp - 4;
    goto enter;
block_1365:
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_151 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(3));
    closure_store(&heap, a, 2, var(2));
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_158 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(4));
    push_var(a);
    push_frame(block_1364);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_159 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(5));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1364:
    push_var(a);
    push_frame(block_1360);
    push_frame(block_1361);
    a = alloc_closure(&heap, 2, 1, &&entry_161 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[4]);
    push_var(a);
    push_frame(block_1362);
    push_frame(block_1363);
    a = var(3);
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1363:
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 41);
    fp = sp - 4;
    goto enter;
block_1362:
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 112);
    fp = sp - 5;
    goto enter;
block_1361:
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_160 - &&entry_0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1360:
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 34);
    pop_vars(2);
    goto pop_frame;
entry_161:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1359);
    a = var(3);
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 60);
    fp = sp - 5;
    goto enter;
block_1359:
    goto pop_frame;
entry_160:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    goto pop_frame;
entry_159:
    a = var(0);
    a = module_fetch(&heap, a, 57);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 58);
    push_var(a);
    push_frame(block_1358);
    a = var(0);
    a = module_fetch(&heap, a, 81);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1358:
    push_var(a);
    push_frame(block_1357);
    a = var(0);
    a = module_fetch(&heap, a, 82);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1357:
    push_var(a);
    a = alloc_module(&heap, &stack[sp-4], 4, 29);
    pop_vars(4);
    goto pop_frame;
entry_158:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 48:
        goto block_1356;
    case 47:
        goto block_1355;
    case 30:
        goto block_1354;
    case 36:
        goto block_1353;
    case 52:
        goto block_1351;
    case 29:
        goto block_1350;
    case 17:
        goto block_1348;
    case 54:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1347;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1345;
    case 53:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1343;
    case 32:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1341;
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1338;
    case 80:
        goto block_1335;
    case 25:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 5);
        sp += 5;
        goto block_1334;
    case 51:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1332;
    case 42:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1330;
    case 50:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1327;
    case 49:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_1325;
    case 46:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1321;
    case 45:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1319;
    case 44:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1316;
    case 41:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1313;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1311;
    case 43:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1309;
    default:
        halt();
    }
block_1356:
    a = var(0);
    goto pop_frame;
block_1355:
    a = var(0);
    goto pop_frame;
block_1354:
    a = var(0);
    goto pop_frame;
block_1353:
    push_frame(block_1352);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1352:
    a = alloc_labeled_value(&heap, 108, a);
    goto pop_frame;
block_1351:
    a = var(0);
    goto pop_frame;
block_1350:
    push_frame(block_1349);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1349:
    a = alloc_labeled_value(&heap, 108, a);
    goto pop_frame;
block_1348:
    a = var(0);
    goto pop_frame;
block_1347:
    push_frame(block_1346);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1346:
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 54, a);
    goto pop_frame;
block_1345:
    push_frame(block_1344);
    a = var(1);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1344:
    a = alloc_labeled_value(&heap, 13, a);
    goto pop_frame;
block_1343:
    push_frame(block_1342);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_157 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1342:
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 53, a);
    goto pop_frame;
block_1341:
    push_frame(block_1340);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_156 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1340:
    push_var(a);
    push_frame(block_1339);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1339:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 32, a);
    goto pop_frame;
block_1338:
    push_frame(block_1337);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1337:
    push_var(a);
    push_frame(block_1336);
    a = var(2);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1336:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    goto pop_frame;
block_1335:
    a = var(0);
    goto pop_frame;
block_1334:
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    push_frame(block_1333);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1333:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 25, a);
    goto pop_frame;
block_1332:
    push_frame(block_1331);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1331:
    a = alloc_labeled_value(&heap, 51, a);
    goto pop_frame;
block_1330:
    push_frame(block_1329);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1329:
    push_var(a);
    push_frame(block_1328);
    a = var(2);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_154 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1328:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 42, a);
    goto pop_frame;
block_1327:
    push_frame(block_1326);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_153 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1326:
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 50, a);
    goto pop_frame;
block_1325:
    push_frame(block_1324);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1324:
    push_var(a);
    push_frame(block_1323);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1323:
    push_var(a);
    push_frame(block_1322);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1322:
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 49, a);
    goto pop_frame;
block_1321:
    push_frame(block_1320);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1320:
    a = alloc_labeled_value(&heap, 46, a);
    goto pop_frame;
block_1319:
    push_frame(block_1318);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1318:
    push_var(a);
    push_frame(block_1317);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1317:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 45, a);
    goto pop_frame;
block_1316:
    push_frame(block_1315);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1315:
    push_var(a);
    push_frame(block_1314);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1314:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 44, a);
    goto pop_frame;
block_1313:
    push_frame(block_1312);
    a = var(1);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1312:
    a = alloc_labeled_value(&heap, 41, a);
    goto pop_frame;
block_1311:
    a = var(1);
    push_var(a);
    push_frame(block_1310);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1310:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    goto pop_frame;
block_1309:
    push_frame(block_1308);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1308:
    push_var(a);
    push_frame(block_1307);
    a = var(2);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_152 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1307:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 43, a);
    goto pop_frame;
entry_157:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1306;
    default:
        halt();
    }
block_1306:
    a = var(1);
    push_var(a);
    push_frame(block_1305);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1305:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    goto pop_frame;
entry_156:
    push_frame(block_1304);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_155 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1304:
    goto pop_frame;
entry_155:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1303;
    case 31:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1301;
    default:
        halt();
    }
block_1303:
    a = var(1);
    push_var(a);
    push_frame(block_1302);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1302:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    goto pop_frame;
block_1301:
    push_frame(block_1300);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1300:
    a = alloc_labeled_value(&heap, 31, a);
    goto pop_frame;
entry_154:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    push_var(a);
    push_frame(block_1299);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1299:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_153:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1298);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1298:
    push_var(a);
    push_frame(block_1297);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1297:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_152:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    push_var(a);
    push_frame(block_1296);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1296:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_151:
    push_frame(block_1294);
    push_frame(block_1295);
    a = closure_env[1];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1295:
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_1294:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1293;
    case 1:
        goto block_1292;
    default:
        halt();
    }
block_1293:
    a = var(2);
    goto pop_frame;
block_1292:
    push_frame(block_1291);
    a = closure_env[2];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1291:
    push_var(a);
    push_frame(block_1289);
    a = closure_env[2];
    push_var(a);
    push_frame(block_1290);
    a = var(1);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1290:
    push_var(a);
    a = constant_env[103];
    fp = sp - 5;
    goto enter;
block_1289:
    push_frame(block_1286);
    a = closure_env[1];
    push_var(a);
    push_frame(block_1287);
    push_frame(block_1288);
    a = closure_env[1];
    push_var(a);
    a = constant_env[102];
    fp = sp - 4;
    goto enter;
block_1288:
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1287:
    push_var(a);
    a = constant_env[103];
    fp = sp - 5;
    goto enter;
block_1286:
    a = var(1);
    goto pop_frame;
entry_150:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 36:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1285;
    case 29:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1281;
    default:
        goto block_1277;
    }
block_1285:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 36:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1284;
    case 29:
        goto block_1282;
    default:
        halt();
    }
block_1284:
    push_frame(block_1283);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 60);
    fp = sp - 5;
    goto enter;
block_1283:
    goto pop_frame;
block_1282:
    a = labeled_empty_tuple(111);
    goto pop_frame;
block_1281:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 36:
        goto block_1280;
    case 29:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1279;
    default:
        halt();
    }
block_1280:
    a = labeled_empty_tuple(110);
    goto pop_frame;
block_1279:
    push_frame(block_1278);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 60);
    fp = sp - 5;
    goto enter;
block_1278:
    goto pop_frame;
block_1277:
    push_frame(block_1276);
    a = constant_env[101];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1276:
    goto pop_frame;
entry_149:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    goto pop_frame;
entry_148:
    push_frame(block_1275);
    a = closure_env[2];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_138 - &&entry_0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 59);
    fp = sp - 5;
    goto enter;
block_1275:
    push_var(a);
    push_frame(block_1274);
    a = var(0);
    push_var(a);
    a = number(0);
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_139 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1274:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = alloc_closure(&heap, 1, 4, &&entry_146 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, var(3));
    push_var(a);
    push_frame(block_1273);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_147 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(4));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1273:
    goto pop_frame;
entry_147:
    a = var(0);
    a = module_fetch(&heap, a, 57);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 58);
    push_var(a);
    push_frame(block_1272);
    a = var(0);
    a = module_fetch(&heap, a, 81);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_1272:
    push_var(a);
    push_frame(block_1271);
    a = var(0);
    a = module_fetch(&heap, a, 82);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1271:
    push_var(a);
    a = alloc_module(&heap, &stack[sp-4], 4, 29);
    pop_vars(4);
    goto pop_frame;
entry_146:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 48:
        goto block_1270;
    case 47:
        goto block_1269;
    case 30:
        goto block_1268;
    case 36:
        goto block_1267;
    case 52:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1266;
    case 29:
        goto block_1260;
    case 17:
        goto block_1259;
    case 54:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1258;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1256;
    case 53:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1254;
    case 32:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1252;
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1249;
    case 80:
        goto block_1246;
    case 25:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 5);
        sp += 5;
        goto block_1245;
    case 51:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1243;
    case 42:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1241;
    case 50:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1238;
    case 49:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_1236;
    case 46:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1232;
    case 45:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1230;
    case 44:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1227;
    case 41:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1224;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1222;
    case 43:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1220;
    default:
        halt();
    }
block_1270:
    a = var(0);
    goto pop_frame;
block_1269:
    a = var(0);
    goto pop_frame;
block_1268:
    a = var(0);
    goto pop_frame;
block_1267:
    a = var(0);
    goto pop_frame;
block_1266:
    push_frame(block_1265);
    a = closure_env[3];
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_1265:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1264;
    case 1:
        goto block_1263;
    default:
        halt();
    }
block_1264:
    a = var(3);
    pop_vars(2);
    goto block_1261;
block_1263:
    push_frame(block_1262);
    a = constant_env[100];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1262:
    goto block_1261;
block_1261:
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 52, a);
    goto pop_frame;
block_1260:
    a = var(0);
    goto pop_frame;
block_1259:
    a = var(0);
    goto pop_frame;
block_1258:
    push_frame(block_1257);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1257:
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 54, a);
    goto pop_frame;
block_1256:
    push_frame(block_1255);
    a = var(1);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1255:
    a = alloc_labeled_value(&heap, 13, a);
    goto pop_frame;
block_1254:
    push_frame(block_1253);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_145 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1253:
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 53, a);
    goto pop_frame;
block_1252:
    push_frame(block_1251);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 1, 2, &&entry_144 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1251:
    push_var(a);
    push_frame(block_1250);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1250:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 32, a);
    goto pop_frame;
block_1249:
    push_frame(block_1248);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1248:
    push_var(a);
    push_frame(block_1247);
    a = var(2);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1247:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    goto pop_frame;
block_1246:
    a = var(0);
    goto pop_frame;
block_1245:
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    push_frame(block_1244);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1244:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 25, a);
    goto pop_frame;
block_1243:
    push_frame(block_1242);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1242:
    a = alloc_labeled_value(&heap, 51, a);
    goto pop_frame;
block_1241:
    push_frame(block_1240);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1240:
    push_var(a);
    push_frame(block_1239);
    a = var(2);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_142 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1239:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 42, a);
    goto pop_frame;
block_1238:
    push_frame(block_1237);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_141 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1237:
    push_var(a);
    a = var(2);
    a = alloc_labeled_value(&heap, 50, a);
    goto pop_frame;
block_1236:
    push_frame(block_1235);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1235:
    push_var(a);
    push_frame(block_1234);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1234:
    push_var(a);
    push_frame(block_1233);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1233:
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 49, a);
    goto pop_frame;
block_1232:
    push_frame(block_1231);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1231:
    a = alloc_labeled_value(&heap, 46, a);
    goto pop_frame;
block_1230:
    push_frame(block_1229);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1229:
    push_var(a);
    push_frame(block_1228);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1228:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 45, a);
    goto pop_frame;
block_1227:
    push_frame(block_1226);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1226:
    push_var(a);
    push_frame(block_1225);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1225:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 44, a);
    goto pop_frame;
block_1224:
    push_frame(block_1223);
    a = var(1);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1223:
    a = alloc_labeled_value(&heap, 41, a);
    goto pop_frame;
block_1222:
    a = var(1);
    push_var(a);
    push_frame(block_1221);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1221:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    goto pop_frame;
block_1220:
    push_frame(block_1219);
    a = var(1);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_1219:
    push_var(a);
    push_frame(block_1218);
    a = var(2);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_140 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1218:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 43, a);
    goto pop_frame;
entry_145:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1217;
    default:
        halt();
    }
block_1217:
    a = var(1);
    push_var(a);
    push_frame(block_1216);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1216:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    goto pop_frame;
entry_144:
    push_frame(block_1215);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_143 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 109);
    fp = sp - 5;
    goto enter;
block_1215:
    goto pop_frame;
entry_143:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1214;
    case 31:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1212;
    default:
        halt();
    }
block_1214:
    a = var(1);
    push_var(a);
    push_frame(block_1213);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1213:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    goto pop_frame;
block_1212:
    push_frame(block_1211);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1211:
    a = alloc_labeled_value(&heap, 31, a);
    goto pop_frame;
entry_142:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    push_var(a);
    push_frame(block_1210);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1210:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_141:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1209);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1209:
    push_var(a);
    push_frame(block_1208);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1208:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_140:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    push_var(a);
    push_frame(block_1207);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1207:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_139:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1206);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1206:
    push_var(a);
    push_frame(block_1205);
    a = var(3);
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 58);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_1205:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_138:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    goto pop_frame;
entry_137:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 86:
        goto block_1204;
    case 83:
        goto block_1193;
    default:
        halt();
    }
block_1204:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 51:
        goto block_1203;
    case 32:
        goto block_1202;
    case 49:
        goto block_1201;
    case 43:
        goto block_1200;
    case 50:
        goto block_1199;
    case 42:
        goto block_1198;
    case 25:
        goto block_1197;
    default:
        goto block_1196;
    }
block_1203:
    a = var(3);
    goto block_1194;
block_1202:
    a = var(3);
    goto block_1194;
block_1201:
    a = var(3);
    goto block_1194;
block_1200:
    a = var(3);
    goto block_1194;
block_1199:
    a = var(3);
    goto block_1194;
block_1198:
    a = var(3);
    goto block_1194;
block_1197:
    a = var(3);
    goto block_1194;
block_1196:
    push_frame(block_1195);
    a = labeled_empty_tuple(95);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1195:
    goto block_1194;
block_1194:
    goto block_1188;
block_1193:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 51:
        goto block_1192;
    default:
        goto block_1190;
    }
block_1192:
    push_frame(block_1191);
    a = constant_env[99];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_1191:
    goto block_1189;
block_1190:
    a = var(3);
    goto block_1189;
block_1189:
    goto block_1188;
block_1188:
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1187);
    a = var(0);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1187:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(0);
    switch (value_label(&heap, a)) {
    case 48:
        goto block_1186;
    case 47:
        goto block_1185;
    case 30:
        goto block_1184;
    case 108:
        goto block_1183;
    case 52:
        goto block_1182;
    case 94:
        goto block_1181;
    case 107:
        goto block_1180;
    case 106:
        goto block_1179;
    case 54:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1178;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1175;
    case 53:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1171;
    case 32:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1167;
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1156;
    case 80:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_1148;
    case 25:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_1146;
    case 51:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1139;
    case 42:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1133;
    case 50:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1123;
    case 49:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_1113;
    case 46:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1097;
    case 45:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1094;
    case 44:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1088;
    case 41:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1082;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1079;
    case 43:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1069;
    default:
        halt();
    }
block_1186:
    a = var(5);
    goto pop_frame;
block_1185:
    a = var(5);
    goto pop_frame;
block_1184:
    a = var(5);
    goto pop_frame;
block_1183:
    a = var(5);
    goto pop_frame;
block_1182:
    a = var(5);
    goto pop_frame;
block_1181:
    a = var(5);
    goto pop_frame;
block_1180:
    a = var(5);
    goto pop_frame;
block_1179:
    a = var(5);
    goto pop_frame;
block_1178:
    push_frame(block_1177);
    a = var(7);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_136 - &&entry_0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1177:
    push_var(a);
    push_frame(block_1176);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(8);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1176:
    goto pop_frame;
block_1175:
    push_frame(block_1174);
    a = var(6);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1174:
    push_var(a);
    push_frame(block_1172);
    a = var(6);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1173);
    a = var(7);
    a = alloc_labeled_value(&heap, 87, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1173:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_135 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1172:
    goto pop_frame;
block_1171:
    push_frame(block_1168);
    a = var(7);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1169);
    a = var(6);
    push_var(a);
    push_frame(block_1170);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1170:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 105, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1169:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_134 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1168:
    goto pop_frame;
block_1167:
    push_frame(block_1166);
    a = var(6);
    push_var(a);
    a = number(0);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_131 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1166:
    push_var(a);
    push_frame(block_1165);
    a = var(8);
    push_var(a);
    a = number(0);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_1165:
    if (a.bits == false_value.bits) goto block_1160;
    a = var(4);
    goto block_1159;
block_1160:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 86:
        goto block_1164;
    case 83:
        goto block_1163;
    default:
        halt();
    }
block_1164:
    a = var(4);
    goto block_1161;
block_1163:
    push_frame(block_1162);
    a = var(8);
    a = alloc_labeled_value(&heap, 85, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1162:
    goto block_1161;
block_1161:
block_1159:
    push_var(a);
    push_frame(block_1157);
    a = var(6);
    push_var(a);
    push_frame(block_1158);
    a = var(7);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(9);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1158:
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_133 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1157:
    goto pop_frame;
block_1156:
    push_frame(block_1155);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1155:
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1151);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    push_frame(block_1154);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1154:
    push_var(a);
    push_frame(block_1152);
    a = var(8);
    a = alloc_labeled_value(&heap, 103, a);
    push_var(a);
    push_frame(block_1153);
    a = var(9);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1153:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1152:
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1151:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1150);
    a = var(7);
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_129 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1150:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(12);
    push_var(a);
    push_frame(block_1149);
    a = var(9);
    a = alloc_labeled_value(&heap, 104, a);
    push_var(a);
    a = var(13);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1149:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_1148:
    a = var(2);
    push_var(a);
    push_frame(block_1147);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 102, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1147:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_1146:
    push_frame(block_1145);
    a = var(8);
    push_var(a);
    a = labeled_empty_tuple(86);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1145:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1142);
    push_frame(block_1144);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1144:
    push_var(a);
    push_frame(block_1143);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_1143:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1142:
    push_var(a);
    push_frame(block_1141);
    a = var(7);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_128 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1141:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(9);
    push_var(a);
    push_frame(block_1140);
    a = var(6);
    a = alloc_labeled_value(&heap, 101, a);
    push_var(a);
    a = var(13);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1140:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_1139:
    a = var(6);
    switch (value_label(&heap, a)) {
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1138;
    default:
        halt();
    }
block_1138:
    push_frame(block_1137);
    a = var(8);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1137:
    push_var(a);
    push_frame(block_1135);
    a = var(7);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1136);
    a = var(9);
    a = alloc_labeled_value(&heap, 100, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1136:
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1135:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1134);
    a = var(8);
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_127 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1134:
    goto pop_frame;
block_1133:
    a = var(2);
    push_var(a);
    a = var(1);
    switch (value_label(&heap, a)) {
    case 86:
        goto block_1132;
    case 83:
        goto block_1131;
    default:
        halt();
    }
block_1132:
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1128;
block_1131:
    push_frame(block_1130);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1130:
    push_var(a);
    push_frame(block_1129);
    a = var(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1129:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1128;
block_1128:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1127);
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(10);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_125 - &&entry_0);
    closure_store(&heap, a, 0, c);
    closure_store(&heap, a, 1, var(8));
    closure_store(&heap, a, 2, var(1));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1127:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_1126);
    a = var(13);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = labeled_empty_tuple(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_126 - &&entry_0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1126:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1125);
    a = var(14);
    push_var(a);
    a = var(15);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 42, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1125:
    push_var(a);
    push_frame(block_1124);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(16);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1124:
    goto pop_frame;
block_1123:
    a = var(2);
    push_var(a);
    a = var(1);
    switch (value_label(&heap, a)) {
    case 83:
        goto block_1122;
    case 86:
        goto block_1119;
    default:
        halt();
    }
block_1122:
    push_frame(block_1121);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1121:
    push_var(a);
    push_frame(block_1120);
    a = var(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1120:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1118;
block_1119:
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1118;
block_1118:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1116);
    a = var(8);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    push_frame(block_1117);
    a = labeled_empty_tuple(99);
    push_var(a);
    a = var(9);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1117:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1116:
    push_var(a);
    push_frame(block_1114);
    a = var(6);
    push_var(a);
    push_frame(block_1115);
    a = var(8);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1115:
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_124 - &&entry_0);
    closure_store(&heap, a, 0, c);
    closure_store(&heap, a, 1, var(7));
    closure_store(&heap, a, 2, var(1));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1114:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(11);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_1113:
    a = var(2);
    push_var(a);
    a = var(1);
    switch (value_label(&heap, a)) {
    case 83:
        goto block_1112;
    case 86:
        goto block_1109;
    default:
        halt();
    }
block_1112:
    push_frame(block_1111);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1111:
    push_var(a);
    push_frame(block_1110);
    a = var(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1110:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1108;
block_1109:
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1108;
block_1108:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(10);
    push_var(a);
    push_frame(block_1106);
    a = var(8);
    push_var(a);
    a = var(1);
    push_var(a);
    push_frame(block_1107);
    a = var(10);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1107:
    push_var(a);
    a = var(11);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1106:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1105);
    a = var(12);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(14);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1105:
    push_var(a);
    a = var(1);
    switch (value_label(&heap, a)) {
    case 86:
        goto block_1104;
    case 83:
        goto block_1103;
    default:
        halt();
    }
block_1104:
    a = var(15);
    goto block_1101;
block_1103:
    push_frame(block_1102);
    a = var(9);
    a = alloc_labeled_value(&heap, 84, a);
    push_var(a);
    a = var(15);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1102:
    goto block_1101;
block_1101:
    push_var(a);
    push_frame(block_1100);
    a = var(7);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(13);
    push_var(a);
    a = var(16);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1100:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1098);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(17);
    push_var(a);
    push_frame(block_1099);
    a = var(12);
    a = alloc_labeled_value(&heap, 90, a);
    push_var(a);
    a = var(18);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1099:
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1098:
    goto pop_frame;
block_1097:
    push_frame(block_1095);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1096);
    a = labeled_empty_tuple(46);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1096:
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1095:
    goto pop_frame;
block_1094:
    a = var(2);
    push_var(a);
    push_frame(block_1093);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1093:
    push_var(a);
    push_frame(block_1092);
    a = var(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1092:
    push_var(a);
    push_frame(block_1091);
    a = var(7);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(10);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1091:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1089);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(11);
    push_var(a);
    push_frame(block_1090);
    a = var(8);
    a = alloc_labeled_value(&heap, 90, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1090:
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1089:
    goto pop_frame;
block_1088:
    a = var(2);
    push_var(a);
    push_frame(block_1087);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1087:
    push_var(a);
    push_frame(block_1086);
    a = var(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1086:
    push_var(a);
    push_frame(block_1085);
    a = var(7);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(10);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1085:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1083);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(11);
    push_var(a);
    push_frame(block_1084);
    a = var(8);
    a = alloc_labeled_value(&heap, 98, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1084:
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1083:
    goto pop_frame;
block_1082:
    push_frame(block_1081);
    a = var(6);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_123 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1081:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(7);
    push_var(a);
    push_frame(block_1080);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(8);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1080:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_1079:
    a = var(7);
    switch (value_label(&heap, a)) {
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1078;
    default:
        goto block_1072;
    }
block_1078:
    a = var(8);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_1077;
    case 7:
        goto block_1075;
    default:
        halt();
    }
block_1077:
    a = var(2);
    push_var(a);
    push_frame(block_1076);
    a = var(6);
    a = alloc_labeled_value(&heap, 97, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1076:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_1075:
    push_frame(block_1073);
    a = var(7);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1074);
    a = var(6);
    a = alloc_labeled_value(&heap, 96, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1074:
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1073:
    goto pop_frame;
block_1072:
    push_frame(block_1070);
    a = var(7);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1071);
    a = var(6);
    a = alloc_labeled_value(&heap, 96, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1071:
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1070:
    goto pop_frame;
block_1069:
    a = var(2);
    push_var(a);
    a = var(1);
    switch (value_label(&heap, a)) {
    case 86:
        goto block_1068;
    case 83:
        goto block_1067;
    default:
        halt();
    }
block_1068:
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1064;
block_1067:
    push_frame(block_1066);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1066:
    push_var(a);
    push_frame(block_1065);
    a = var(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1065:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_1064;
block_1064:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1063);
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(10);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_121 - &&entry_0);
    closure_store(&heap, a, 0, c);
    closure_store(&heap, a, 1, var(8));
    closure_store(&heap, a, 2, var(1));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1063:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_1062);
    a = var(13);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = labeled_empty_tuple(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_122 - &&entry_0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_1062:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1061);
    a = var(14);
    push_var(a);
    a = var(15);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 43, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1061:
    push_var(a);
    push_frame(block_1060);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(16);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_1060:
    goto pop_frame;
entry_136:
    push_frame(block_1059);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1059:
    goto pop_frame;
entry_135:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1057);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1058);
    a = labeled_empty_tuple(89);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1058:
    push_var(a);
    a = closure_env[0];
    fp = sp - 7;
    goto enter;
block_1057:
    goto pop_frame;
entry_134:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1056;
    default:
        halt();
    }
block_1056:
    a = var(5);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1055);
    a = labeled_empty_tuple(89);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1055:
    push_var(a);
    a = closure_env[0];
    memmove(stack+fp+3, stack+sp-4, 4*sizeof(struct value));
    sp = fp + 7;
    goto enter;
entry_133:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1054);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_132 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1054:
    goto pop_frame;
entry_132:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_1053;
    case 31:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1044;
    default:
        halt();
    }
block_1053:
    a = var(4);
    switch (value_label(&heap, a)) {
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1052;
    case 17:
        goto block_1047;
    default:
        halt();
    }
block_1052:
    a = var(6);
    switch (value_unbox_int32(a)) {
    case 0:
        goto block_1051;
    default:
        goto block_1050;
    }
block_1051:
    a = var(3);
    goto block_1048;
block_1050:
    push_frame(block_1049);
    a = var(6);
    a = alloc_labeled_value(&heap, 93, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1049:
    goto block_1048;
block_1048:
    pop_vars(1);
    goto block_1045;
block_1047:
    push_frame(block_1046);
    a = labeled_empty_tuple(89);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1046:
    goto block_1045;
block_1045:
    push_var(a);
    a = var(5);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(6);
    push_var(a);
    a = closure_env[0];
    memmove(stack+fp+3, stack+sp-4, 4*sizeof(struct value));
    sp = fp + 7;
    goto enter;
block_1044:
    a = var(4);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    memmove(stack+fp+3, stack+sp-4, 4*sizeof(struct value));
    sp = fp + 7;
    goto enter;
entry_131:
    push_frame(block_1043);
    a = var(1);
    push_var(a);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_130 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_1043:
    goto pop_frame;
entry_130:
    push_frame(block_1041);
    a = var(0);
    push_var(a);
    push_frame(block_1042);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_1042:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1041:
    goto pop_frame;
entry_129:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1040);
    a = labeled_empty_tuple(89);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1040:
    push_var(a);
    a = closure_env[0];
    memmove(stack+fp+3, stack+sp-4, 4*sizeof(struct value));
    sp = fp + 7;
    goto enter;
entry_128:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(0);
    switch (value_label(&heap, a)) {
    case 16:
        goto block_1039;
    case 17:
        goto block_1038;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1037;
    default:
        halt();
    }
block_1039:
    a = var(3);
    goto block_1033;
block_1038:
    a = var(3);
    goto block_1033;
block_1037:
    push_frame(block_1034);
    a = var(2);
    a = alloc_labeled_value(&heap, 94, a);
    push_var(a);
    push_frame(block_1035);
    push_frame(block_1036);
    a = var(4);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_1036:
    a = alloc_labeled_value(&heap, 93, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1035:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1034:
    pop_vars(1);
    goto block_1033;
block_1033:
    push_var(a);
    push_frame(block_1031);
    a = var(2);
    push_var(a);
    push_frame(block_1032);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_1032:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1031:
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_127:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_1030);
    a = labeled_empty_tuple(89);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1030:
    push_var(a);
    a = closure_env[0];
    memmove(stack+fp+3, stack+sp-4, 4*sizeof(struct value));
    sp = fp + 7;
    goto enter;
entry_126:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 34:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1029;
    case 33:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1026;
    default:
        halt();
    }
block_1029:
    a = var(6);
    switch (value_label(&heap, a)) {
    case 89:
        goto block_1028;
    case 91:
        goto block_1027;
    default:
        halt();
    }
block_1028:
    a = var(4);
    push_var(a);
    a = var(3);
    a = alloc_labeled_value(&heap, 92, a);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_1027:
    a = var(4);
    push_var(a);
    a = var(3);
    a = alloc_labeled_value(&heap, 84, a);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_1026:
    push_frame(block_1025);
    a = var(6);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1025:
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_125:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = closure_env[2];
    switch (value_label(&heap, a)) {
    case 86:
        goto block_1024;
    case 83:
        goto block_1023;
    default:
        halt();
    }
block_1024:
    a = var(5);
    goto block_1012;
block_1023:
    a = var(2);
    switch (value_label(&heap, a)) {
    case 34:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_1022;
    case 33:
        goto block_1015;
    default:
        halt();
    }
block_1022:
    a = var(7);
    switch (value_label(&heap, a)) {
    case 89:
        goto block_1021;
    case 91:
        goto block_1018;
    default:
        halt();
    }
block_1021:
    push_frame(block_1019);
    a = number(1);
    a = alloc_labeled_value(&heap, 85, a);
    push_var(a);
    push_frame(block_1020);
    a = closure_env[1];
    a = alloc_labeled_value(&heap, 84, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1020:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1019:
    goto block_1016;
block_1018:
    push_frame(block_1017);
    a = closure_env[1];
    a = alloc_labeled_value(&heap, 84, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1017:
    goto block_1016;
block_1016:
    pop_vars(1);
    goto block_1013;
block_1015:
    push_frame(block_1014);
    a = closure_env[1];
    a = alloc_labeled_value(&heap, 84, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1014:
    goto block_1013;
block_1013:
    goto block_1012;
block_1012:
    push_var(a);
    push_frame(block_1011);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    fp = sp - 7;
    goto enter;
block_1011:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1010);
    a = var(8);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1010:
    push_var(a);
    push_frame(block_1009);
    a = var(8);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1009:
    push_var(a);
    push_frame(block_1008);
    a = var(2);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(6);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1008:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_124:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = closure_env[2];
    switch (value_label(&heap, a)) {
    case 86:
        goto block_1007;
    case 83:
        goto block_1006;
    default:
        halt();
    }
block_1007:
    a = var(5);
    goto block_1004;
block_1006:
    push_frame(block_1005);
    a = closure_env[1];
    a = alloc_labeled_value(&heap, 84, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1005:
    goto block_1004;
block_1004:
    push_var(a);
    push_frame(block_1003);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    fp = sp - 7;
    goto enter;
block_1003:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1002);
    a = var(6);
    a = alloc_labeled_value(&heap, 90, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_1002:
    push_var(a);
    push_frame(block_1001);
    a = var(2);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(10);
    push_var(a);
    a = closure_env[0];
    fp = sp - 7;
    goto enter;
block_1001:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_1000);
    a = var(11);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_1000:
    push_var(a);
    push_frame(block_999);
    a = var(11);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_999:
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_123:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_995);
    a = labeled_empty_tuple(89);
    push_var(a);
    push_frame(block_996);
    a = labeled_empty_tuple(88);
    push_var(a);
    push_frame(block_997);
    a = number(2);
    a = alloc_labeled_value(&heap, 87, a);
    push_var(a);
    push_frame(block_998);
    a = labeled_empty_tuple(7);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_998:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_997:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_996:
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_995:
    push_var(a);
    push_frame(block_994);
    a = var(1);
    push_var(a);
    a = labeled_empty_tuple(83);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = closure_env[0];
    fp = sp - 7;
    goto enter;
block_994:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(5);
    push_var(a);
    push_frame(block_993);
    a = labeled_empty_tuple(89);
    push_var(a);
    a = var(6);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_993:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_122:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_992;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_991;
    default:
        halt();
    }
block_992:
    a = var(4);
    push_var(a);
    a = var(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_991:
    a = var(7);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_990;
    case 17:
        goto block_988;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_986;
    default:
        halt();
    }
block_990:
    push_frame(block_989);
    a = var(6);
    a = alloc_labeled_value(&heap, 34, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_989:
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_988:
    push_frame(block_987);
    a = var(6);
    a = alloc_labeled_value(&heap, 17, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_987:
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_986:
    push_frame(block_985);
    a = var(6);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_985:
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_121:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = closure_env[2];
    switch (value_label(&heap, a)) {
    case 86:
        goto block_984;
    case 83:
        goto block_983;
    default:
        halt();
    }
block_984:
    a = var(5);
    goto block_972;
block_983:
    push_frame(block_982);
    a = closure_env[1];
    a = alloc_labeled_value(&heap, 84, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_982:
    push_var(a);
    a = var(2);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_981;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_980;
    default:
        halt();
    }
block_981:
    a = var(7);
    goto block_973;
block_980:
    a = var(9);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_979;
    case 17:
        goto block_978;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_976;
    default:
        halt();
    }
block_979:
    a = var(7);
    goto block_974;
block_978:
    push_frame(block_977);
    a = number(1);
    a = alloc_labeled_value(&heap, 85, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_977:
    goto block_974;
block_976:
    push_frame(block_975);
    a = var(10);
    a = alloc_labeled_value(&heap, 85, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_975:
    pop_vars(1);
    goto block_974;
block_974:
    pop_vars(2);
    goto block_973;
block_973:
    pop_vars(1);
    goto block_972;
block_972:
    push_var(a);
    push_frame(block_971);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    fp = sp - 7;
    goto enter;
block_971:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_970);
    a = var(8);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_970:
    push_var(a);
    push_frame(block_969);
    a = var(8);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_969:
    push_var(a);
    push_frame(block_968);
    a = var(2);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(6);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_968:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_120:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_967;
    case 31:
        goto block_964;
    default:
        halt();
    }
block_967:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_966;
    case 17:
        goto block_965;
    default:
        halt();
    }
block_966:
    a = var(3);
    goto pop_frame;
block_965:
    a = number(1);
    goto pop_frame;
block_964:
    a = number(0);
    goto pop_frame;
entry_119:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_963;
    case 31:
        goto block_960;
    default:
        halt();
    }
block_963:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_962;
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_961;
    default:
        halt();
    }
block_962:
    a = var(3);
    goto pop_frame;
block_961:
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(3);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    goto pop_frame;
block_960:
    a = labeled_empty_tuple(26);
    goto pop_frame;
entry_118:
    push_frame(block_959);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_117 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[2]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_959:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    goto pop_frame;
entry_117:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_957);
    a = var(2);
    push_var(a);
    push_frame(block_958);
    a = var(0);
    a = module_fetch(&heap, a, 76);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_958:
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_957:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(0);
    a = module_fetch(&heap, a, 57);
    push_var(a);
    a = var(0);
    a = module_fetch(&heap, a, 58);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-4], 4, 29);
    pop_vars(4);
    push_var(a);
    a = var(4);
    push_var(a);
    push_frame(block_956);
    a = var(7);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_956:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_116:
    a = alloc_closure(&heap, 4, 1, &&entry_107 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    push_var(a);
    a = alloc_closure(&heap, 4, 0, &&entry_108 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 3, 3, &&entry_115 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(3));
    closure_store(&heap, a, 2, var(2));
    push_var(a);
    push_frame(block_955);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(4);
    fp = sp - 6;
    goto enter;
block_955:
    goto pop_frame;
entry_115:
    a = alloc_closure(&heap, 3, 2, &&entry_109 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = var(2);
    switch (value_label(&heap, a)) {
    case 48:
        goto block_954;
    case 47:
        goto block_953;
    case 30:
        goto block_952;
    case 36:
        goto block_951;
    case 52:
        goto block_950;
    case 29:
        goto block_949;
    case 17:
        goto block_948;
    case 54:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_947;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_945;
    case 53:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_943;
    case 32:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_941;
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_938;
    case 25:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 4);
        sp += 4;
        goto block_935;
    case 51:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_930;
    case 42:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_928;
    case 50:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_925;
    case 49:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_923;
    case 46:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_919;
    case 45:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_917;
    case 44:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_914;
    case 41:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_911;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_909;
    case 43:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_907;
    default:
        halt();
    }
block_954:
    a = var(4);
    goto pop_frame;
block_953:
    a = var(4);
    goto pop_frame;
block_952:
    a = var(4);
    goto pop_frame;
block_951:
    a = var(4);
    goto pop_frame;
block_950:
    a = var(4);
    goto pop_frame;
block_949:
    a = var(4);
    goto pop_frame;
block_948:
    a = var(4);
    goto pop_frame;
block_947:
    push_frame(block_946);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_946:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(7);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 54, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_945:
    push_frame(block_944);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[2];
    fp = sp - 7;
    goto enter;
block_944:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(6);
    push_var(a);
    a = var(7);
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_943:
    push_frame(block_942);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    fp = sp - 7;
    goto enter;
block_942:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(6);
    push_var(a);
    a = var(7);
    a = alloc_labeled_value(&heap, 53, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_941:
    push_frame(block_940);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 3, 2, &&entry_114 - &&entry_0);
    closure_store(&heap, a, 0, var(3));
    closure_store(&heap, a, 1, closure_env[2]);
    push_var(a);
    a = closure_env[2];
    fp = sp - 7;
    goto enter;
block_940:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_939);
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_939:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(10);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_938:
    push_frame(block_937);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_937:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_936);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[2];
    fp = sp - 7;
    goto enter;
block_936:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(10);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_935:
    push_frame(block_934);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(8);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_934:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(9);
    push_var(a);
    a = var(6);
    push_var(a);
    push_frame(block_933);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_933:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 80, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-5], 5);
    pop_vars(5);
    a = alloc_labeled_value(&heap, 25, a);
    push_var(a);
    push_frame(block_932);
    a = var(9);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_932:
    push_var(a);
    a = var(12);
    push_var(a);
    push_frame(block_931);
    a = var(13);
    push_var(a);
    a = var(11);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_931:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_930:
    push_frame(block_929);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_929:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(6);
    push_var(a);
    a = var(7);
    a = alloc_labeled_value(&heap, 51, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_928:
    push_frame(block_927);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_927:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_926);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_113 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_926:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(10);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 42, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_925:
    push_frame(block_924);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_112 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_924:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(6);
    push_var(a);
    a = var(7);
    a = alloc_labeled_value(&heap, 50, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_923:
    push_frame(block_922);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_922:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_921);
    a = var(8);
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_921:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_920);
    a = var(11);
    push_var(a);
    a = var(13);
    push_var(a);
    a = var(7);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_920:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(14);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(12);
    push_var(a);
    a = var(15);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 49, a);
    push_var(a);
    a = var(16);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_919:
    push_frame(block_918);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_918:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(6);
    push_var(a);
    a = var(7);
    a = alloc_labeled_value(&heap, 46, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_917:
    push_frame(block_916);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_916:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_915);
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_915:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(10);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 45, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_914:
    push_frame(block_913);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_913:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_912);
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_912:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(10);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 44, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_911:
    push_frame(block_910);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_111 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_910:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(6);
    push_var(a);
    a = var(7);
    a = alloc_labeled_value(&heap, 41, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_909:
    push_frame(block_908);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_908:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(7);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_907:
    push_frame(block_906);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 6;
    goto enter;
block_906:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_905);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_110 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_905:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(10);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 43, a);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_114:
    push_frame(block_904);
    a = var(2);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    push_var(a);
    a = closure_env[1];
    fp = sp - 7;
    goto enter;
block_904:
    goto pop_frame;
entry_113:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_903);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_903:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(7);
    push_var(a);
    push_frame(block_902);
    a = var(2);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_902:
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_112:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_901);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_901:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_900);
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_900:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(10);
    push_var(a);
    push_frame(block_899);
    a = var(8);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_899:
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_111:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_898);
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_898:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(5);
    push_var(a);
    push_frame(block_897);
    a = var(6);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_897:
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_110:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_896);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_896:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(7);
    push_var(a);
    push_frame(block_895);
    a = var(2);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_895:
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_109:
    push_frame(block_894);
    a = closure_env[1];
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 7;
    goto enter;
block_894:
    goto pop_frame;
entry_108:
    a = var(3);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_893;
    case 31:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_891;
    default:
        halt();
    }
block_893:
    push_frame(block_892);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(0);
    fp = sp - 6;
    goto enter;
block_892:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(6);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_891:
    push_frame(block_890);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(0);
    fp = sp - 6;
    goto enter;
block_890:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(5);
    push_var(a);
    a = var(6);
    a = alloc_labeled_value(&heap, 31, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_107:
    push_frame(block_889);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_106 - &&entry_0);
    closure_store(&heap, a, 0, var(3));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_889:
    goto pop_frame;
entry_106:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_888);
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_888:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(5);
    push_var(a);
    push_frame(block_887);
    a = var(6);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_887:
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_105:
    push_frame(block_886);
    a = closure_env[2];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 68);
    fp = sp - 4;
    goto enter;
block_886:
    push_var(a);
    push_frame(block_885);
    a = closure_env[2];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_88 - &&entry_0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 59);
    fp = sp - 5;
    goto enter;
block_885:
    push_var(a);
    a = alloc_closure(&heap, 6, 0, &&entry_89 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 4, 8, &&entry_104 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(2));
    closure_store(&heap, a, 2, var(1));
    closure_store(&heap, a, 3, closure_env[2]);
    closure_store(&heap, a, 4, closure_env[3]);
    closure_store(&heap, a, 5, closure_env[4]);
    closure_store(&heap, a, 6, closure_env[5]);
    closure_store(&heap, a, 7, var(3));
    push_var(a);
    a = var(2);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = number(0);
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    push_frame(block_884);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(4);
    fp = sp - 7;
    goto enter;
block_884:
    pop_vars(3);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(5);
    goto pop_frame;
entry_104:
    a = var(3);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(3);
    switch (value_label(&heap, a)) {
    case 48:
        goto block_883;
    case 47:
        goto block_882;
    case 30:
        goto block_881;
    case 36:
        goto block_880;
    case 52:
        goto block_879;
    case 29:
        goto block_878;
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_877;
    case 54:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_867;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_865;
    case 53:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_863;
    case 32:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_861;
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_858;
    case 25:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_855;
    case 51:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_843;
    case 42:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_841;
    case 50:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_838;
    case 49:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_836;
    case 46:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_832;
    case 45:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_830;
    case 44:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_827;
    case 41:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_824;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_822;
    case 43:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_820;
    default:
        halt();
    }
block_883:
    a = var(4);
    goto pop_frame;
block_882:
    a = var(4);
    goto pop_frame;
block_881:
    a = var(4);
    goto pop_frame;
block_880:
    a = var(4);
    goto pop_frame;
block_879:
    a = var(4);
    goto pop_frame;
block_878:
    a = var(4);
    goto pop_frame;
block_877:
    push_frame(block_876);
    a = var(0);
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_876:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_875;
    case 1:
        goto block_870;
    default:
        halt();
    }
block_875:
    push_frame(block_874);
    a = var(6);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[38];
    fp = sp - 5;
    goto enter;
block_874:
    if (a.bits == false_value.bits) goto block_872;
    push_frame(block_873);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_873:
    goto block_871;
block_872:
    a = var(2);
block_871:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_870:
    push_frame(block_868);
    push_frame(block_869);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[97];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[98];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[3];
    a = module_fetch(&heap, a, 15);
    fp = sp - 4;
    goto enter;
block_869:
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_868:
    goto pop_frame;
block_867:
    push_frame(block_866);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_866:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(7);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 54, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_865:
    push_frame(block_864);
    a = var(5);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_103 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(0));
    closure_store(&heap, a, 2, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_864:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(6);
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_863:
    push_frame(block_862);
    a = var(5);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 4, &&entry_102 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(0));
    closure_store(&heap, a, 2, closure_env[7]);
    closure_store(&heap, a, 3, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_862:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(6);
    a = alloc_labeled_value(&heap, 53, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_861:
    push_frame(block_860);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 6, &&entry_101 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[4]);
    closure_store(&heap, a, 3, var(1));
    closure_store(&heap, a, 4, closure_env[7]);
    closure_store(&heap, a, 5, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_860:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_859);
    a = var(7);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_859:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(8);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(11);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_858:
    push_frame(block_857);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_857:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_856);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_98 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(0));
    closure_store(&heap, a, 2, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_856:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_855:
    push_frame(block_854);
    a = var(1);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_854:
    push_var(a);
    push_frame(block_850);
    a = var(6);
    push_var(a);
    a = var(5);
    switch (value_label(&heap, a)) {
    case 1:
        goto block_853;
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_852;
    default:
        halt();
    }
block_853:
    a = labeled_empty_tuple(26);
    goto block_851;
block_852:
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(13);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    pop_vars(1);
    goto block_851;
block_851:
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_95 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[6]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_850:
    push_var(a);
    push_frame(block_849);
    a = var(9);
    push_var(a);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_96 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, var(8));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_849:
    pop_vars(2);
    push_var(a);
    push_frame(block_847);
    a = var(8);
    push_var(a);
    push_frame(block_848);
    a = var(1);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_848:
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = var(7);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_847:
    pop_vars(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_845);
    push_frame(block_846);
    a = var(9);
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 41);
    fp = sp - 4;
    goto enter;
block_846:
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 4, &&entry_97 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[2]);
    closure_store(&heap, a, 2, var(1));
    closure_store(&heap, a, 3, var(0));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_845:
    push_var(a);
    a = var(5);
    push_var(a);
    push_frame(block_844);
    a = var(9);
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 41);
    fp = sp - 4;
    goto enter;
block_844:
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-4], 4);
    pop_vars(4);
    a = alloc_labeled_value(&heap, 25, a);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_843:
    push_frame(block_842);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_842:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(6);
    a = alloc_labeled_value(&heap, 51, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_841:
    push_frame(block_840);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_840:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_839);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 4, &&entry_94 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(0));
    closure_store(&heap, a, 3, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_839:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 42, a);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_838:
    push_frame(block_837);
    a = var(5);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_93 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(0));
    closure_store(&heap, a, 2, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_837:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(6);
    a = alloc_labeled_value(&heap, 50, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_836:
    push_frame(block_835);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_835:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_834);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_834:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_833);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(7);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_833:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(8);
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(12);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 49, a);
    push_var(a);
    a = var(13);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_832:
    push_frame(block_831);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_831:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(6);
    a = alloc_labeled_value(&heap, 46, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_830:
    push_frame(block_829);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_829:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_828);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_828:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 45, a);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_827:
    push_frame(block_826);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_826:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_825);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_825:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 44, a);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_824:
    push_frame(block_823);
    a = var(5);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_92 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    closure_store(&heap, a, 1, var(0));
    closure_store(&heap, a, 2, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_823:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(6);
    a = alloc_labeled_value(&heap, 41, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_822:
    push_frame(block_821);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_821:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(5);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_820:
    push_frame(block_819);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 7;
    goto enter;
block_819:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_818);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 5, &&entry_91 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, var(1));
    closure_store(&heap, a, 3, var(0));
    closure_store(&heap, a, 4, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_818:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(7);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 43, a);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_103:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_817);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    fp = sp - 7;
    goto enter;
block_817:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_816);
    a = var(4);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_816:
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_102:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_815);
    a = closure_env[3];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    fp = sp - 9;
    goto enter;
block_815:
    goto pop_frame;
entry_101:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_814);
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    push_var(a);
    a = alloc_closure(&heap, 2, 6, &&entry_99 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[2]);
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, var(2));
    closure_store(&heap, a, 4, closure_env[4]);
    closure_store(&heap, a, 5, closure_env[5]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_814:
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_813);
    a = var(5);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_100 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[3]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_813:
    push_var(a);
    a = var(8);
    push_var(a);
    push_frame(block_812);
    a = var(6);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_812:
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_100:
    push_frame(block_811);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 26);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_811:
    goto pop_frame;
entry_99:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_810);
    a = closure_env[5];
    push_var(a);
    a = closure_env[3];
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[4];
    fp = sp - 9;
    goto enter;
block_810:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_808);
    push_frame(block_809);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_809:
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 28);
    fp = sp - 5;
    goto enter;
block_808:
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
entry_98:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_807);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    fp = sp - 7;
    goto enter;
block_807:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_806);
    a = var(4);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_806:
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_97:
    push_frame(block_805);
    a = closure_env[3];
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_805:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_804;
    default:
        halt();
    }
block_804:
    push_frame(block_803);
    a = var(2);
    a = module_fetch(&heap, a, 79);
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = constant_env[38];
    fp = sp - 5;
    goto enter;
block_803:
    if (a.bits == false_value.bits) goto block_801;
    push_frame(block_802);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_802:
    goto pop_frame;
block_801:
    a = var(0);
    goto pop_frame;
entry_96:
    push_frame(block_800);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 26);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_800:
    goto pop_frame;
entry_95:
    push_frame(block_798);
    push_frame(block_799);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_799:
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 28);
    fp = sp - 5;
    goto enter;
block_798:
    goto pop_frame;
entry_94:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 34:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_797;
    case 33:
        goto block_790;
    default:
        halt();
    }
block_797:
    a = var(6);
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_796;
    case 1:
        goto block_793;
    default:
        halt();
    }
block_796:
    push_frame(block_795);
    a = closure_env[2];
    push_var(a);
    a = var(7);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 26);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_795:
    push_var(a);
    push_frame(block_794);
    a = var(8);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[3];
    fp = sp - 7;
    goto enter;
block_794:
    pop_vars(1);
    pop_vars(1);
    goto block_791;
block_793:
    push_frame(block_792);
    a = closure_env[2];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[3];
    fp = sp - 7;
    goto enter;
block_792:
    goto block_791;
block_791:
    pop_vars(1);
    goto block_788;
block_790:
    push_frame(block_789);
    a = closure_env[2];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[3];
    fp = sp - 7;
    goto enter;
block_789:
    goto block_788;
block_788:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_787);
    a = var(2);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_787:
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_93:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_786);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    fp = sp - 7;
    goto enter;
block_786:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_785);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    fp = sp - 7;
    goto enter;
block_785:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_784);
    a = var(6);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_784:
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_92:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_783);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    fp = sp - 7;
    goto enter;
block_783:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_782);
    a = var(4);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_782:
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_91:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_781;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_780;
    default:
        halt();
    }
block_781:
    a = closure_env[3];
    goto block_774;
block_780:
    a = var(7);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_779;
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_778;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_777;
    default:
        halt();
    }
block_779:
    a = labeled_empty_tuple(26);
    goto block_776;
block_778:
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(8);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    pop_vars(1);
    goto block_776;
block_777:
    a = var(8);
    pop_vars(1);
    goto block_776;
block_776:
    push_var(a);
    push_frame(block_775);
    a = var(8);
    push_var(a);
    a = closure_env[3];
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_90 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[2]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_775:
    pop_vars(1);
    pop_vars(2);
    goto block_774;
block_774:
    push_var(a);
    push_frame(block_773);
    a = var(6);
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[4];
    fp = sp - 7;
    goto enter;
block_773:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_772);
    a = var(2);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_772:
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_90:
    push_frame(block_771);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 26);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_771:
    goto pop_frame;
entry_89:
    a = var(5);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_770;
    case 31:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_767;
    default:
        halt();
    }
block_770:
    push_frame(block_769);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(0);
    fp = sp - 7;
    goto enter;
block_769:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_768);
    a = var(6);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_768:
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_767:
    push_frame(block_766);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(0);
    fp = sp - 7;
    goto enter;
block_766:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_765);
    a = var(7);
    a = alloc_labeled_value(&heap, 31, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_765:
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_88:
    a = var(0);
    a = module_fetch(&heap, a, 20);
    goto pop_frame;
entry_87:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_764;
    case 31:
        goto block_761;
    default:
        halt();
    }
block_764:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_763;
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_762;
    default:
        halt();
    }
block_763:
    a = var(3);
    goto pop_frame;
block_762:
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(3);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    goto pop_frame;
block_761:
    a = labeled_empty_tuple(26);
    goto pop_frame;
entry_86:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_760;
    case 17:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_759;
    case 16:
        goto block_758;
    default:
        halt();
    }
block_760:
    a = var(1);
    goto pop_frame;
block_759:
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    goto pop_frame;
block_758:
    a = labeled_empty_tuple(26);
    goto pop_frame;
entry_85:
    push_frame(block_757);
    a = number(48);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[96];
    fp = sp - 5;
    goto enter;
block_757:
    if (a.bits == false_value.bits) goto block_755;
    push_frame(block_756);
    a = var(0);
    push_var(a);
    a = number(57);
    push_var(a);
    a = constant_env[96];
    fp = sp - 5;
    goto enter;
block_756:
    goto pop_frame;
block_755:
    goto pop_frame;
entry_84:
    push_frame(block_754);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_754:
    if (a.bits == true_value.bits) goto block_752;
    push_frame(block_753);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_753:
    goto pop_frame;
block_752:
    goto pop_frame;
entry_83:
    push_frame(block_751);
    a = number(97);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[96];
    fp = sp - 5;
    goto enter;
block_751:
    if (a.bits == false_value.bits) goto block_749;
    push_frame(block_750);
    a = var(0);
    push_var(a);
    a = number(122);
    push_var(a);
    a = constant_env[96];
    fp = sp - 5;
    goto enter;
block_750:
    goto pop_frame;
block_749:
    goto pop_frame;
entry_82:
    push_frame(block_748);
    a = number(65);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[96];
    fp = sp - 5;
    goto enter;
block_748:
    if (a.bits == false_value.bits) goto block_746;
    push_frame(block_747);
    a = var(0);
    push_var(a);
    a = number(90);
    push_var(a);
    a = constant_env[96];
    fp = sp - 5;
    goto enter;
block_747:
    goto pop_frame;
block_746:
    goto pop_frame;
entry_81:
    a = var(0);
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_73 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_74 - &&entry_0);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-2], 2, 16);
    pop_vars(2);
    push_var(a);
    push_frame(block_745);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 68);
    fp = sp - 4;
    goto enter;
block_745:
    push_var(a);
    a = alloc_closure(&heap, 2, 0, &&entry_75 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 7, 6, &&entry_78 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, closure_env[0]);
    closure_store(&heap, a, 2, var(0));
    closure_store(&heap, a, 3, var(3));
    closure_store(&heap, a, 4, var(1));
    closure_store(&heap, a, 5, var(4));
    push_var(a);
    a = alloc_closure(&heap, 7, 4, &&entry_79 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, closure_env[0]);
    closure_store(&heap, a, 2, var(3));
    closure_store(&heap, a, 3, var(5));
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_80 - &&entry_0);
    closure_store(&heap, a, 0, var(0));
    closure_store(&heap, a, 1, var(3));
    closure_store(&heap, a, 2, var(6));
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 19);
    pop_vars(1);
    goto pop_frame;
entry_80:
    push_frame(block_743);
    a = var(0);
    push_var(a);
    push_frame(block_744);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 41);
    fp = sp - 4;
    goto enter;
block_744:
    push_var(a);
    a = number(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = closure_env[2];
    fp = sp - 10;
    goto enter;
block_743:
    goto pop_frame;
entry_79:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_742;
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_740;
    default:
        halt();
    }
block_742:
    push_frame(block_741);
    a = var(6);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_741:
    goto pop_frame;
block_740:
    push_frame(block_738);
    a = var(5);
    push_var(a);
    push_frame(block_739);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 77);
    fp = sp - 4;
    goto enter;
block_739:
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_738:
    switch (value_label(&heap, a)) {
    case 3:
        goto block_737;
    case 1:
        goto block_736;
    default:
        halt();
    }
block_737:
    a = var(0);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-7, 7*sizeof(struct value));
    sp = fp + 10;
    goto enter;
block_736:
    push_frame(block_735);
    a = var(0);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = closure_env[3];
    fp = sp - 10;
    goto enter;
block_735:
    open_tuple(&heap, &stack[sp], a, 6);
    sp += 6;
    a = var(0);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(12);
    push_var(a);
    a = var(13);
    push_var(a);
    a = var(14);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-7, 7*sizeof(struct value));
    sp = fp + 10;
    goto enter;
entry_78:
    push_frame(block_734);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 77);
    fp = sp - 4;
    goto enter;
block_734:
    push_var(a);
    push_frame(block_733);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 78);
    fp = sp - 4;
    goto enter;
block_733:
    push_var(a);
    push_frame(block_732);
    a = var(4);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_732:
    push_var(a);
    push_frame(block_731);
    a = var(7);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_731:
    push_var(a);
    push_frame(block_729);
    a = var(8);
    push_var(a);
    a = var(2);
    push_var(a);
    push_frame(block_730);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_730:
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(9);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-6], 6);
    pop_vars(6);
    push_var(a);
    a = alloc_closure(&heap, 2, 5, &&entry_76 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[2]);
    closure_store(&heap, a, 1, closure_env[3]);
    closure_store(&heap, a, 2, var(0));
    closure_store(&heap, a, 3, closure_env[5]);
    closure_store(&heap, a, 4, c);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_729:
    open_tuple(&heap, &stack[sp], a, 6);
    sp += 6;
    push_frame(block_728);
    a = var(2);
    push_var(a);
    a = var(11);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_728:
    if (a.bits == false_value.bits) goto block_725;
    a = alloc_closure(&heap, 3, 3, &&entry_77 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[3]);
    closure_store(&heap, a, 1, closure_env[4]);
    closure_store(&heap, a, 2, var(7));
    push_var(a);
    push_frame(block_727);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(13);
    push_var(a);
    a = var(15);
    push_var(a);
    a = var(17);
    fp = sp - 6;
    goto enter;
block_727:
    pop_vars(1);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    a = var(11);
    push_var(a);
    a = var(12);
    push_var(a);
    a = var(18);
    push_var(a);
    a = var(14);
    push_var(a);
    a = var(19);
    push_var(a);
    push_frame(block_726);
    a = var(17);
    push_var(a);
    a = var(16);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_726:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-6], 6);
    pop_vars(6);
    goto pop_frame;
block_725:
    a = var(11);
    push_var(a);
    a = var(12);
    push_var(a);
    a = var(13);
    push_var(a);
    a = var(14);
    push_var(a);
    a = var(15);
    push_var(a);
    a = var(16);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-6], 6);
    pop_vars(6);
    goto pop_frame;
entry_77:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_724;
    default:
        halt();
    }
block_724:
    push_frame(block_723);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_723:
    push_var(a);
    push_frame(block_722);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_722:
    switch (value_label(&heap, a)) {
    case 9:
        goto block_721;
    default:
        goto block_719;
    }
block_721:
    push_frame(block_720);
    a = closure_env[2];
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_720:
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto pop_frame;
block_719:
    push_frame(block_718);
    a = var(3);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_718:
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-3, 3*sizeof(struct value));
    sp = fp + 6;
    goto enter;
entry_76:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 6);
    sp += 6;
    push_frame(block_717);
    a = var(6);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_717:
    switch (value_label(&heap, a)) {
    case 3:
        goto block_716;
    case 1:
        goto block_715;
    default:
        halt();
    }
block_716:
    a = var(0);
    goto pop_frame;
block_715:
    push_frame(block_714);
    a = var(5);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_714:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_713;
    case 1:
        goto block_711;
    default:
        halt();
    }
block_713:
    push_frame(block_712);
    a = var(2);
    push_var(a);
    a = var(9);
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_712:
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-6], 6);
    pop_vars(6);
    goto pop_frame;
block_711:
    push_frame(block_710);
    a = closure_env[2];
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_710:
    switch (value_label(&heap, a)) {
    case 1:
        goto block_709;
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_708;
    default:
        halt();
    }
block_709:
    a = var(1);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_707;
block_708:
    a = var(8);
    pop_vars(1);
    goto block_707;
block_707:
    push_var(a);
    push_frame(block_706);
    a = closure_env[2];
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = closure_env[4];
    fp = sp - 10;
    goto enter;
block_706:
    open_tuple(&heap, &stack[sp], a, 6);
    sp += 6;
    push_frame(block_705);
    a = var(2);
    push_var(a);
    a = var(9);
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_705:
    push_var(a);
    a = var(15);
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(12);
    push_var(a);
    a = var(13);
    push_var(a);
    a = var(14);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-6], 6);
    pop_vars(6);
    goto pop_frame;
entry_75:
    push_frame(block_704);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[38];
    fp = sp - 5;
    goto enter;
block_704:
    if (a.bits == false_value.bits) goto block_703;
    a = var(0);
    goto pop_frame;
block_703:
    a = var(1);
    goto pop_frame;
entry_74:
    a = var(0);
    a = tuple_fetch(&heap, a, 1);
    goto pop_frame;
entry_73:
    a = var(0);
    a = tuple_fetch(&heap, a, 0);
    goto pop_frame;
entry_72:
    push_frame(block_702);
    a = closure_env[3];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 68);
    fp = sp - 4;
    goto enter;
block_702:
    push_var(a);
    a = alloc_closure(&heap, 3, 8, &&entry_71 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, var(1));
    closure_store(&heap, a, 4, closure_env[4]);
    closure_store(&heap, a, 5, closure_env[5]);
    closure_store(&heap, a, 6, closure_env[6]);
    closure_store(&heap, a, 7, closure_env[7]);
    push_var(a);
    push_frame(block_701);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(0);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = var(2);
    fp = sp - 6;
    goto enter;
block_701:
    goto pop_frame;
entry_71:
    a = var(1);
    switch (value_label(&heap, a)) {
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_700;
    case 26:
        goto block_689;
    default:
        halt();
    }
block_700:
    push_frame(block_699);
    a = var(3);
    push_var(a);
    a = constant_env[95];
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 28);
    fp = sp - 5;
    goto enter;
block_699:
    push_var(a);
    push_frame(block_698);
    a = var(5);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 71);
    fp = sp - 4;
    goto enter;
block_698:
    push_var(a);
    push_frame(block_697);
    a = var(6);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 72);
    fp = sp - 4;
    goto enter;
block_697:
    push_var(a);
    push_frame(block_696);
    a = var(6);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 73);
    fp = sp - 4;
    goto enter;
block_696:
    push_frame(block_695);
    a = var(7);
    push_var(a);
    a = closure_env[6];
    fp = sp - 4;
    goto enter;
block_695:
    push_var(a);
    push_frame(block_694);
    a = var(8);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_694:
    push_var(a);
    push_frame(block_693);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[3];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_693:
    push_var(a);
    push_frame(block_692);
    a = var(9);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_692:
    push_var(a);
    a = var(11);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-5], 5, 8);
    pop_vars(5);
    push_var(a);
    push_frame(block_691);
    a = var(11);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_70 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[3]);
    closure_store(&heap, a, 1, var(10));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_691:
    push_var(a);
    push_frame(block_690);
    a = var(12);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_690:
    push_var(a);
    a = var(13);
    push_var(a);
    a = var(10);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-3, 3*sizeof(struct value));
    sp = fp + 6;
    goto enter;
block_689:
    push_frame(block_688);
    a = var(0);
    push_var(a);
    a = closure_env[7];
    fp = sp - 4;
    goto enter;
block_688:
    push_var(a);
    push_frame(block_687);
    a = var(3);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_69 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[2]);
    closure_store(&heap, a, 2, var(0));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_687:
    push_var(a);
    a = var(4);
    goto pop_frame;
entry_70:
    push_frame(block_686);
    a = closure_env[1];
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 70);
    fp = sp - 5;
    goto enter;
block_686:
    switch (value_label(&heap, a)) {
    case 3:
        goto block_685;
    case 1:
        goto block_684;
    default:
        halt();
    }
block_685:
    a = var(0);
    goto pop_frame;
block_684:
    push_frame(block_683);
    a = var(1);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_683:
    goto pop_frame;
entry_69:
    a = alloc_closure(&heap, 1, 2, &&entry_68 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, var(0));
    push_var(a);
    push_frame(block_682);
    a = closure_env[2];
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 69);
    fp = sp - 5;
    goto enter;
block_682:
    switch (value_label(&heap, a)) {
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_681;
    default:
        halt();
    }
block_681:
    a = var(3);
    pop_vars(2);
    goto block_680;
block_680:
    pop_vars(1);
    push_var(a);
    push_frame(block_679);
    a = var(2);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_679:
    goto pop_frame;
entry_68:
    push_frame(block_678);
    a = var(0);
    a = module_fetch(&heap, a, 58);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_678:
    goto pop_frame;
entry_67:
    push_frame(block_677);
    a = closure_env[2];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 68);
    fp = sp - 4;
    goto enter;
block_677:
    push_var(a);
    a = alloc_closure(&heap, 3, 0, &&entry_60 - &&entry_0);
    push_var(a);
    a = alloc_closure(&heap, 2, 3, &&entry_66 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, var(2));
    push_var(a);
    push_frame(block_675);
    push_frame(block_676);
    a = var(1);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(3);
    fp = sp - 5;
    goto enter;
block_676:
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 41);
    fp = sp - 4;
    goto enter;
block_675:
    goto pop_frame;
entry_66:
    a = alloc_closure(&heap, 2, 2, &&entry_61 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[2]);
    closure_store(&heap, a, 1, c);
    push_var(a);
    a = var(1);
    switch (value_label(&heap, a)) {
    case 48:
        goto block_674;
    case 47:
        goto block_673;
    case 30:
        goto block_672;
    case 36:
        goto block_671;
    case 52:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_670;
    case 29:
        goto block_668;
    case 17:
        goto block_667;
    case 54:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_666;
    case 13:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_664;
    case 53:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_662;
    case 32:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_660;
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_657;
    case 25:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_654;
    case 51:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_652;
    case 42:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_650;
    case 50:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_647;
    case 49:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_645;
    case 46:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_641;
    case 45:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_639;
    case 44:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_636;
    case 41:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_633;
    case 35:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_631;
    case 43:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_629;
    default:
        halt();
    }
block_674:
    a = var(0);
    goto pop_frame;
block_673:
    a = var(0);
    goto pop_frame;
block_672:
    a = var(0);
    goto pop_frame;
block_671:
    a = var(0);
    goto pop_frame;
block_670:
    push_frame(block_669);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_669:
    goto pop_frame;
block_668:
    a = var(0);
    goto pop_frame;
block_667:
    a = var(0);
    goto pop_frame;
block_666:
    push_frame(block_665);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_665:
    goto pop_frame;
block_664:
    push_frame(block_663);
    a = var(3);
    push_var(a);
    a = var(0);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_663:
    goto pop_frame;
block_662:
    push_frame(block_661);
    a = var(3);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_661:
    goto pop_frame;
block_660:
    push_frame(block_658);
    a = var(3);
    push_var(a);
    push_frame(block_659);
    a = var(0);
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_659:
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_65 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(2));
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_658:
    goto pop_frame;
block_657:
    push_frame(block_655);
    push_frame(block_656);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_656:
    push_var(a);
    a = var(0);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_655:
    goto pop_frame;
block_654:
    push_frame(block_653);
    a = var(0);
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_653:
    goto pop_frame;
block_652:
    push_frame(block_651);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_651:
    goto pop_frame;
block_650:
    push_frame(block_648);
    a = var(4);
    push_var(a);
    push_frame(block_649);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_649:
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_64 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_648:
    goto pop_frame;
block_647:
    push_frame(block_646);
    a = var(3);
    push_var(a);
    a = var(0);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_63 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_646:
    goto pop_frame;
block_645:
    push_frame(block_642);
    push_frame(block_643);
    push_frame(block_644);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_644:
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_643:
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_642:
    goto pop_frame;
block_641:
    push_frame(block_640);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_640:
    goto pop_frame;
block_639:
    push_frame(block_637);
    push_frame(block_638);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_638:
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_637:
    goto pop_frame;
block_636:
    push_frame(block_634);
    push_frame(block_635);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_635:
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_634:
    goto pop_frame;
block_633:
    push_frame(block_632);
    a = var(3);
    push_var(a);
    a = var(0);
    push_var(a);
    a = c;
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_632:
    goto pop_frame;
block_631:
    push_frame(block_630);
    a = var(0);
    push_var(a);
    a = var(4);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_630:
    goto pop_frame;
block_629:
    push_frame(block_627);
    a = var(4);
    push_var(a);
    push_frame(block_628);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    fp = sp - 5;
    goto enter;
block_628:
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_62 - &&entry_0);
    closure_store(&heap, a, 0, c);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_627:
    goto pop_frame;
entry_65:
    push_frame(block_626);
    a = var(1);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_626:
    goto pop_frame;
entry_64:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_625);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_625:
    goto pop_frame;
entry_63:
    a = var(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_623);
    push_frame(block_624);
    a = var(0);
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_624:
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_623:
    goto pop_frame;
entry_62:
    push_frame(block_622);
    a = var(0);
    push_var(a);
    a = var(1);
    a = tuple_fetch(&heap, a, 1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 5;
    goto enter;
block_622:
    goto pop_frame;
entry_61:
    push_frame(block_621);
    a = closure_env[1];
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_621:
    goto pop_frame;
entry_60:
    a = var(2);
    switch (value_label(&heap, a)) {
    case 24:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_620;
    case 31:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_618;
    default:
        halt();
    }
block_620:
    push_frame(block_619);
    a = var(1);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(0);
    fp = sp - 5;
    goto enter;
block_619:
    goto pop_frame;
block_618:
    push_frame(block_617);
    a = var(1);
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(0);
    fp = sp - 5;
    goto enter;
block_617:
    goto pop_frame;
entry_59:
    push_frame(block_616);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_616:
    goto pop_frame;
entry_58:
    push_frame(block_615);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_615:
    push_var(a);
    a = alloc_closure(&heap, 3, 5, &&entry_57 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(1));
    closure_store(&heap, a, 2, closure_env[2]);
    closure_store(&heap, a, 3, closure_env[3]);
    closure_store(&heap, a, 4, var(0));
    push_var(a);
    push_frame(block_614);
    a = number(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = labeled_empty_tuple(67);
    push_var(a);
    a = var(2);
    fp = sp - 6;
    goto enter;
block_614:
    goto pop_frame;
entry_57:
    push_frame(block_613);
    a = closure_env[1];
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_613:
    if (a.bits == false_value.bits) goto block_605;
    push_frame(block_611);
    push_frame(block_612);
    a = labeled_empty_tuple(55);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_612:
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_611:
    goto pop_frame;
block_605:
    a = var(2);
    switch (value_label(&heap, a)) {
    case 67:
        goto block_610;
    case 66:
        goto block_608;
    default:
        halt();
    }
block_610:
    push_frame(block_609);
    a = closure_env[4];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_609:
    push_var(a);
    a = var(3);
    push_var(a);
    a = var(1);
    push_var(a);
    a = labeled_empty_tuple(66);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-3, 3*sizeof(struct value));
    sp = fp + 6;
    goto enter;
block_608:
    push_frame(block_607);
    a = closure_env[4];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_607:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(3);
    push_var(a);
    push_frame(block_606);
    a = var(4);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_606:
    push_var(a);
    a = labeled_empty_tuple(67);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-3, 3*sizeof(struct value));
    sp = fp + 6;
    goto enter;
entry_56:
    push_frame(block_604);
    a = closure_env[3];
    a = module_fetch(&heap, a, 60);
    push_var(a);
    a = alloc_closure(&heap, 1, 0, &&entry_53 - &&entry_0);
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 59);
    fp = sp - 5;
    goto enter;
block_604:
    push_var(a);
    push_frame(block_603);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 61);
    fp = sp - 4;
    goto enter;
block_603:
    push_var(a);
    push_frame(block_602);
    a = var(0);
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 63);
    push_var(a);
    a = alloc_closure(&heap, 2, 1, &&entry_54 - &&entry_0);
    closure_store(&heap, a, 0, var(1));
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 62);
    fp = sp - 6;
    goto enter;
block_602:
    push_var(a);
    push_frame(block_601);
    a = var(3);
    push_var(a);
    a = var(2);
    a = module_fetch(&heap, a, 64);
    fp = sp - 4;
    goto enter;
block_601:
    push_var(a);
    push_frame(block_600);
    a = var(4);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_55 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    closure_store(&heap, a, 1, closure_env[4]);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 65);
    fp = sp - 6;
    goto enter;
block_600:
    push_var(a);
    a = var(5);
    goto pop_frame;
entry_55:
    push_frame(block_598);
    push_frame(block_599);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_599:
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[93];
    fp = sp - 5;
    goto enter;
block_598:
    if (a.bits == false_value.bits) goto block_594;
    push_frame(block_597);
    a = constant_env[94];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_597:
    goto pop_frame;
block_594:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_596;
    default:
        halt();
    }
block_596:
    push_frame(block_595);
    a = var(2);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_595:
    goto pop_frame;
entry_54:
    push_frame(block_593);
    a = var(0);
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 58);
    push_var(a);
    a = var(1);
    a = module_fetch(&heap, a, 57);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 56);
    fp = sp - 5;
    goto enter;
block_593:
    goto pop_frame;
entry_53:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    goto pop_frame;
entry_52:
    push_frame(block_592);
    a = var(0);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_592:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = alloc_closure(&heap, 2, 8, &&entry_51 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[2]);
    closure_store(&heap, a, 3, var(1));
    closure_store(&heap, a, 4, closure_env[3]);
    closure_store(&heap, a, 5, closure_env[4]);
    closure_store(&heap, a, 6, closure_env[5]);
    closure_store(&heap, a, 7, closure_env[6]);
    push_var(a);
    push_frame(block_591);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    fp = sp - 5;
    goto enter;
block_591:
    goto pop_frame;
entry_51:
    push_frame(block_590);
    a = var(1);
    push_var(a);
    a = closure_env[7];
    fp = sp - 4;
    goto enter;
block_590:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 55:
        goto block_589;
    case 8:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_587;
    default:
        halt();
    }
block_589:
    push_frame(block_588);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_588:
    push_var(a);
    a = closure_env[3];
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 32, a);
    goto pop_frame;
block_587:
block_586:
    push_frame(block_585);
    a = var(4);
    push_var(a);
    a = constant_env[92];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_585:
    if (a.bits == false_value.bits) goto block_582;
    push_frame(block_584);
    a = closure_env[5];
    push_var(a);
    a = closure_env[6];
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[4];
    fp = sp - 6;
    goto enter;
block_584:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_583);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_583:
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_582:
    a = true_value;
    if (a.bits == false_value.bits) goto block_580;
    push_frame(block_581);
    a = constant_env[91];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_581:
    goto pop_frame;
block_580:
    halt();
entry_50:
    push_frame(block_579);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_579:
    switch (value_unbox_int32(a)) {
    case 39:
        goto block_578;
    case 34:
        goto block_577;
    default:
        push_var(a);
        goto block_576;
    }
block_578:
    a = closure_env[3];
    goto block_569;
block_577:
    a = closure_env[5];
    goto block_569;
block_576:
    push_frame(block_575);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 38);
    fp = sp - 4;
    goto enter;
block_575:
    if (a.bits == false_value.bits) goto block_571;
    a = closure_env[6];
    goto block_570;
block_571:
    push_frame(block_574);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 37);
    fp = sp - 4;
    goto enter;
block_574:
    if (a.bits == false_value.bits) goto block_573;
    a = closure_env[4];
    goto block_572;
block_573:
    a = closure_env[2];
block_572:
block_570:
    pop_vars(1);
    goto block_569;
block_569:
    push_var(a);
    push_frame(block_568);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    fp = sp - 5;
    goto enter;
block_568:
    goto pop_frame;
entry_49:
    push_frame(block_567);
    a = var(0);
    push_var(a);
    a = closure_env[13];
    fp = sp - 4;
    goto enter;
block_567:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 30:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_566;
    case 36:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_565;
    case 12:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_564;
    case 8:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_560;
    default:
        halt();
    }
block_566:
    a = var(3);
    a = alloc_labeled_value(&heap, 30, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_565:
    a = var(3);
    a = alloc_labeled_value(&heap, 36, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_564:
    push_frame(block_563);
    a = var(2);
    push_var(a);
    a = closure_env[7];
    fp = sp - 4;
    goto enter;
block_563:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_562;
    case 7:
        goto block_561;
    default:
        halt();
    }
block_562:
    a = var(3);
    a = alloc_labeled_value(&heap, 17, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_561:
    a = var(3);
    a = alloc_labeled_value(&heap, 17, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 54, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_560:
block_559:
    push_frame(block_558);
    a = var(3);
    push_var(a);
    a = constant_env[46];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_558:
    if (a.bits == false_value.bits) goto block_556;
    push_frame(block_557);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_557:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = constant_env[90];
    a = alloc_labeled_value(&heap, 29, a);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(4);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_556:
    push_frame(block_555);
    a = var(3);
    push_var(a);
    a = constant_env[88];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_555:
    if (a.bits == false_value.bits) goto block_553;
    push_frame(block_554);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_554:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = constant_env[89];
    a = alloc_labeled_value(&heap, 29, a);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(4);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_553:
    push_frame(block_552);
    a = var(3);
    push_var(a);
    a = constant_env[86];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_552:
    if (a.bits == false_value.bits) goto block_550;
    push_frame(block_551);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_551:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = constant_env[87];
    a = alloc_labeled_value(&heap, 29, a);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(4);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_550:
    push_frame(block_549);
    a = var(3);
    push_var(a);
    a = constant_env[85];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_549:
    if (a.bits == false_value.bits) goto block_547;
    push_frame(block_548);
    a = c;
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[4];
    fp = sp - 5;
    goto enter;
block_548:
    goto pop_frame;
block_547:
    push_frame(block_546);
    a = var(3);
    push_var(a);
    a = constant_env[15];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_546:
    if (a.bits == false_value.bits) goto block_530;
    push_frame(block_545);
    a = var(2);
    push_var(a);
    a = closure_env[13];
    fp = sp - 4;
    goto enter;
block_545:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_544:
    push_frame(block_543);
    a = var(4);
    push_var(a);
    a = constant_env[40];
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_543:
    if (a.bits == true_value.bits) goto block_541;
    push_frame(block_542);
    a = var(4);
    push_var(a);
    a = constant_env[41];
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_542:
block_541:
    if (a.bits == false_value.bits) goto block_534;
    push_frame(block_539);
    a = closure_env[6];
    push_var(a);
    a = c;
    push_var(a);
    push_frame(block_540);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_540:
    push_var(a);
    a = closure_env[5];
    fp = sp - 6;
    goto enter;
block_539:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_538);
    a = var(7);
    push_var(a);
    a = closure_env[13];
    fp = sp - 4;
    goto enter;
block_538:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_537);
    a = var(8);
    push_var(a);
    a = constant_env[7];
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_537:
    if (a.bits == false_value.bits) goto block_535;
    a = var(6);
    a = alloc_labeled_value(&heap, 53, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_535:
    push_frame(block_536);
    a = constant_env[84];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_536:
    goto pop_frame;
block_534:
    a = true_value;
    if (a.bits == false_value.bits) goto block_531;
    a = alloc_closure(&heap, 2, 4, &&entry_48 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[3]);
    closure_store(&heap, a, 2, c);
    closure_store(&heap, a, 3, closure_env[13]);
    push_var(a);
    push_frame(block_532);
    a = labeled_empty_tuple(26);
    push_var(a);
    push_frame(block_533);
    a = var(4);
    push_var(a);
    a = var(5);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_533:
    push_var(a);
    a = var(6);
    fp = sp - 5;
    goto enter;
block_532:
    goto pop_frame;
block_531:
    halt();
block_530:
    push_frame(block_529);
    a = var(3);
    push_var(a);
    a = constant_env[83];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_529:
    if (a.bits == false_value.bits) goto block_527;
    a = alloc_closure(&heap, 2, 4, &&entry_47 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[3]);
    closure_store(&heap, a, 2, c);
    closure_store(&heap, a, 3, closure_env[13]);
    push_var(a);
    push_frame(block_528);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(4);
    fp = sp - 5;
    goto enter;
block_528:
    goto pop_frame;
block_527:
    push_frame(block_526);
    a = var(3);
    push_var(a);
    a = constant_env[48];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_526:
    if (a.bits == false_value.bits) goto block_517;
    push_frame(block_525);
    a = var(2);
    push_var(a);
    a = closure_env[9];
    fp = sp - 4;
    goto enter;
block_525:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_524);
    a = var(5);
    push_var(a);
    a = closure_env[13];
    fp = sp - 4;
    goto enter;
block_524:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_523:
    push_frame(block_522);
    a = var(6);
    push_var(a);
    a = constant_env[9];
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_522:
    if (a.bits == false_value.bits) goto block_520;
    push_frame(block_521);
    a = var(7);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_521:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_520:
    a = true_value;
    if (a.bits == false_value.bits) goto block_518;
    a = var(4);
    push_var(a);
    a = labeled_empty_tuple(26);
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    push_var(a);
    push_frame(block_519);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_519:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_518:
    halt();
block_517:
    push_frame(block_516);
    a = var(3);
    push_var(a);
    a = constant_env[82];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_516:
    if (a.bits == false_value.bits) goto block_514;
    push_frame(block_515);
    a = var(2);
    push_var(a);
    a = closure_env[9];
    fp = sp - 4;
    goto enter;
block_515:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    a = alloc_labeled_value(&heap, 29, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_514:
    push_frame(block_513);
    a = var(3);
    push_var(a);
    a = constant_env[81];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_513:
    if (a.bits == false_value.bits) goto block_509;
    push_frame(block_512);
    a = var(2);
    push_var(a);
    a = closure_env[13];
    fp = sp - 4;
    goto enter;
block_512:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    switch (value_label(&heap, a)) {
    case 36:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_511;
    default:
        halt();
    }
block_511:
    push_frame(block_510);
    a = var(6);
    push_var(a);
    a = closure_env[14];
    fp = sp - 4;
    goto enter;
block_510:
    a = alloc_labeled_value(&heap, 52, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_509:
    push_frame(block_508);
    a = var(3);
    push_var(a);
    a = constant_env[79];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_508:
    if (a.bits == false_value.bits) goto block_503;
    push_frame(block_507);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_507:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    switch (value_label(&heap, a)) {
    case 27:
        goto block_506;
    default:
        goto block_505;
    }
block_506:
    a = var(4);
    a = alloc_labeled_value(&heap, 51, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_505:
    push_frame(block_504);
    a = constant_env[80];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_504:
    goto pop_frame;
block_503:
    push_frame(block_502);
    a = var(3);
    push_var(a);
    a = constant_env[78];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_502:
    if (a.bits == false_value.bits) goto block_500;
    a = alloc_closure(&heap, 2, 6, &&entry_46 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[2]);
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, closure_env[6]);
    closure_store(&heap, a, 4, c);
    closure_store(&heap, a, 5, closure_env[13]);
    push_var(a);
    push_frame(block_501);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(4);
    fp = sp - 5;
    goto enter;
block_501:
    pop_vars(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    a = alloc_labeled_value(&heap, 50, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_500:
    push_frame(block_499);
    a = var(3);
    push_var(a);
    a = constant_env[77];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_499:
    if (a.bits == false_value.bits) goto block_495;
    push_frame(block_498);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_498:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_497);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_497:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_496);
    a = var(7);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_496:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 49, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_495:
    push_frame(block_494);
    a = var(3);
    push_var(a);
    a = constant_env[76];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_494:
    if (a.bits == false_value.bits) goto block_491;
    push_frame(block_493);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_493:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_492);
    a = c;
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[6];
    fp = sp - 5;
    goto enter;
block_492:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = labeled_empty_tuple(26);
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 49, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_491:
    push_frame(block_490);
    a = var(3);
    push_var(a);
    a = constant_env[75];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_490:
    if (a.bits == false_value.bits) goto block_489;
    a = labeled_empty_tuple(48);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_489:
    push_frame(block_488);
    a = var(3);
    push_var(a);
    a = constant_env[74];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_488:
    if (a.bits == false_value.bits) goto block_487;
    a = labeled_empty_tuple(47);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_487:
    push_frame(block_486);
    a = var(3);
    push_var(a);
    a = constant_env[73];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_486:
    if (a.bits == false_value.bits) goto block_484;
    push_frame(block_485);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_485:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    a = alloc_labeled_value(&heap, 46, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_484:
    push_frame(block_483);
    a = var(3);
    push_var(a);
    a = constant_env[72];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_483:
    if (a.bits == false_value.bits) goto block_480;
    push_frame(block_482);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_482:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_481);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_481:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 45, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_480:
    push_frame(block_479);
    a = var(3);
    push_var(a);
    a = constant_env[71];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_479:
    if (a.bits == false_value.bits) goto block_476;
    push_frame(block_478);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_478:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_477);
    a = var(5);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_477:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 44, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_476:
    push_frame(block_475);
    a = var(3);
    push_var(a);
    a = constant_env[70];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_475:
    if (a.bits == false_value.bits) goto block_472;
    push_frame(block_474);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_474:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = alloc_closure(&heap, 2, 7, &&entry_45 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[2]);
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, closure_env[6]);
    closure_store(&heap, a, 4, c);
    closure_store(&heap, a, 5, closure_env[10]);
    closure_store(&heap, a, 6, closure_env[13]);
    push_var(a);
    push_frame(block_473);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    fp = sp - 5;
    goto enter;
block_473:
    pop_vars(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 43, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_472:
    push_frame(block_471);
    a = var(3);
    push_var(a);
    a = constant_env[69];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_471:
    if (a.bits == false_value.bits) goto block_468;
    push_frame(block_470);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_470:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = alloc_closure(&heap, 2, 7, &&entry_43 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[2]);
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, closure_env[6]);
    closure_store(&heap, a, 4, c);
    closure_store(&heap, a, 5, closure_env[12]);
    closure_store(&heap, a, 6, closure_env[13]);
    push_var(a);
    push_frame(block_469);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(6);
    fp = sp - 5;
    goto enter;
block_469:
    pop_vars(1);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 42, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_468:
    push_frame(block_467);
    a = var(3);
    push_var(a);
    a = constant_env[68];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_467:
    if (a.bits == false_value.bits) goto block_464;
    push_frame(block_466);
    a = var(2);
    push_var(a);
    a = closure_env[11];
    fp = sp - 4;
    goto enter;
block_466:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_465);
    a = c;
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[6];
    fp = sp - 5;
    goto enter;
block_465:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = labeled_empty_tuple(1);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 25, a);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_464:
    push_frame(block_463);
    a = var(3);
    push_var(a);
    a = constant_env[66];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_463:
    if (a.bits == false_value.bits) goto block_454;
    push_frame(block_462);
    a = var(2);
    push_var(a);
    a = c;
    fp = sp - 4;
    goto enter;
block_462:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_461);
    a = var(5);
    push_var(a);
    a = closure_env[13];
    fp = sp - 4;
    goto enter;
block_461:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_460:
    push_frame(block_459);
    a = var(6);
    push_var(a);
    a = constant_env[41];
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_459:
    if (a.bits == false_value.bits) goto block_457;
    push_frame(block_458);
    a = closure_env[6];
    push_var(a);
    a = c;
    push_var(a);
    a = var(7);
    push_var(a);
    a = closure_env[8];
    fp = sp - 6;
    goto enter;
block_458:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = labeled_empty_tuple(26);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(8);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_457:
    a = true_value;
    if (a.bits == false_value.bits) goto block_455;
    push_frame(block_456);
    a = constant_env[67];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_456:
    goto pop_frame;
block_455:
    halt();
block_454:
    push_frame(block_453);
    a = var(3);
    push_var(a);
    a = constant_env[65];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_453:
    if (a.bits == false_value.bits) goto block_451;
    push_frame(block_452);
    a = c;
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[6];
    fp = sp - 5;
    goto enter;
block_452:
    goto pop_frame;
block_451:
    a = true_value;
    if (a.bits == false_value.bits) goto block_449;
    push_frame(block_450);
    a = constant_env[64];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_450:
    goto pop_frame;
block_449:
    halt();
entry_48:
    push_frame(block_448);
    a = var(1);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_448:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_447:
    push_frame(block_446);
    a = var(2);
    push_var(a);
    a = constant_env[7];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_446:
    if (a.bits == false_value.bits) goto block_444;
    push_frame(block_445);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_445:
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_444:
    a = true_value;
    if (a.bits == false_value.bits) goto block_440;
    push_frame(block_442);
    push_frame(block_443);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_443:
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_442:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_441);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_441:
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_440:
    halt();
entry_47:
    push_frame(block_439);
    a = var(1);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_439:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_438:
    push_frame(block_437);
    a = var(2);
    push_var(a);
    a = constant_env[63];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_437:
    if (a.bits == false_value.bits) goto block_435;
    push_frame(block_436);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_436:
    a = alloc_labeled_value(&heap, 41, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_435:
    a = true_value;
    if (a.bits == false_value.bits) goto block_431;
    push_frame(block_433);
    push_frame(block_434);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_434:
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_433:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_432);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_432:
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_431:
    halt();
entry_46:
    push_frame(block_430);
    a = var(1);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_430:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_429:
    push_frame(block_428);
    a = var(2);
    push_var(a);
    a = constant_env[60];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_428:
    if (a.bits == false_value.bits) goto block_426;
    push_frame(block_427);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_427:
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_426:
    push_frame(block_425);
    a = var(2);
    push_var(a);
    a = constant_env[59];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_425:
    if (a.bits == false_value.bits) goto block_421;
    push_frame(block_424);
    a = var(3);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_424:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_423);
    a = closure_env[4];
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_423:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_422);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_422:
    push_var(a);
    a = var(7);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_421:
    a = true_value;
    if (a.bits == false_value.bits) goto block_419;
    push_frame(block_420);
    a = constant_env[62];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_420:
    goto pop_frame;
block_419:
    halt();
entry_45:
    push_frame(block_418);
    a = var(1);
    push_var(a);
    a = closure_env[6];
    fp = sp - 4;
    goto enter;
block_418:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_417:
    push_frame(block_416);
    a = var(2);
    push_var(a);
    a = constant_env[60];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_416:
    if (a.bits == false_value.bits) goto block_410;
    a = var(0);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_415;
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_414;
    default:
        halt();
    }
block_415:
    a = empty_tuple;
    goto block_412;
block_414:
    push_frame(block_413);
    a = var(5);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_44 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_413:
    pop_vars(2);
    goto block_412;
block_412:
    push_frame(block_411);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_411:
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_410:
    push_frame(block_409);
    a = var(2);
    push_var(a);
    a = constant_env[59];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_409:
    if (a.bits == false_value.bits) goto block_405;
    push_frame(block_408);
    a = var(3);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_408:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_407);
    a = closure_env[4];
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_407:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_406);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_406:
    push_var(a);
    a = var(7);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_405:
    a = true_value;
    if (a.bits == false_value.bits) goto block_403;
    push_frame(block_404);
    a = constant_env[61];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_404:
    goto pop_frame;
block_403:
    halt();
entry_44:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_402;
    default:
        goto block_400;
    }
block_402:
    push_frame(block_401);
    a = constant_env[61];
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_401:
    goto pop_frame;
block_400:
    a = empty_tuple;
    goto pop_frame;
entry_43:
    push_frame(block_399);
    a = var(1);
    push_var(a);
    a = closure_env[6];
    fp = sp - 4;
    goto enter;
block_399:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_398:
    push_frame(block_397);
    a = var(2);
    push_var(a);
    a = constant_env[60];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_397:
    if (a.bits == false_value.bits) goto block_391;
    a = var(0);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_396;
    case 7:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_395;
    default:
        halt();
    }
block_396:
    a = empty_tuple;
    goto block_393;
block_395:
    push_frame(block_394);
    a = var(5);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_42 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_394:
    pop_vars(2);
    goto block_393;
block_393:
    push_frame(block_392);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_392:
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_391:
    push_frame(block_390);
    a = var(2);
    push_var(a);
    a = constant_env[59];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_390:
    if (a.bits == false_value.bits) goto block_386;
    push_frame(block_389);
    a = var(3);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_389:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_388);
    a = closure_env[4];
    push_var(a);
    a = var(5);
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_388:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_387);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_387:
    push_var(a);
    a = var(7);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_386:
    a = true_value;
    if (a.bits == false_value.bits) goto block_384;
    push_frame(block_385);
    a = constant_env[58];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_385:
    goto pop_frame;
block_384:
    halt();
entry_42:
    a = var(0);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 34:
        goto block_383;
    default:
        goto block_381;
    }
block_383:
    push_frame(block_382);
    a = constant_env[58];
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_382:
    goto pop_frame;
block_381:
    a = empty_tuple;
    goto pop_frame;
entry_41:
    push_frame(block_380);
    a = var(1);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_380:
    push_var(a);
    push_frame(block_378);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    push_frame(block_379);
    a = var(1);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_379:
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 10);
    fp = sp - 6;
    goto enter;
block_378:
    a = alloc_labeled_value(&heap, 8, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_40:
    a = var(1);
    push_var(a);
    a = alloc_closure(&heap, 3, 4, &&entry_39 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, var(2));
    closure_store(&heap, a, 3, var(0));
    push_var(a);
    push_frame(block_377);
    a = var(1);
    push_var(a);
    a = false_value;
    push_var(a);
    a = false_value;
    push_var(a);
    a = var(3);
    fp = sp - 6;
    goto enter;
block_377:
    goto pop_frame;
entry_39:
    push_frame(block_376);
    a = closure_env[3];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_376:
    push_var(a);
    a = var(3);
    switch (value_unbox_int32(a)) {
    case 95:
        goto block_375;
    case 39:
        goto block_373;
    default:
        goto block_371;
    }
block_375:
    push_frame(block_374);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_374:
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-3, 3*sizeof(struct value));
    sp = fp + 6;
    goto enter;
block_373:
    push_frame(block_372);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_372:
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-3, 3*sizeof(struct value));
    sp = fp + 6;
    goto enter;
block_371:
    push_frame(block_370);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 37);
    fp = sp - 4;
    goto enter;
block_370:
    if (a.bits == false_value.bits) goto block_357;
    push_frame(block_369);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_369:
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-3, 3*sizeof(struct value));
    sp = fp + 6;
    goto enter;
block_357:
    push_frame(block_368);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 38);
    fp = sp - 4;
    goto enter;
block_368:
    if (a.bits == false_value.bits) goto block_358;
    push_frame(block_367);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_367:
    push_var(a);
    a = var(1);
    if (a.bits == true_value.bits) goto block_365;
    push_frame(block_366);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 40);
    fp = sp - 4;
    goto enter;
block_366:
block_365:
    push_var(a);
    a = var(2);
    if (a.bits == true_value.bits) goto block_363;
    push_frame(block_364);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 39);
    fp = sp - 4;
    goto enter;
block_364:
block_363:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-3, 3*sizeof(struct value));
    sp = fp + 6;
    goto enter;
block_358:
    a = var(1);
    if (a.bits == false_value.bits) goto block_362;
    a = var(2);
block_362:
    if (a.bits == false_value.bits) goto block_359;
    a = var(0);
    push_var(a);
    push_frame(block_361);
    a = closure_env[3];
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 10);
    fp = sp - 6;
    goto enter;
block_361:
    a = alloc_labeled_value(&heap, 8, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_359:
    a = var(0);
    push_var(a);
    push_frame(block_360);
    a = closure_env[3];
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 10);
    fp = sp - 6;
    goto enter;
block_360:
    a = alloc_labeled_value(&heap, 12, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_38:
    a = alloc_closure(&heap, 2, 3, &&entry_37 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, var(0));
    push_var(a);
    push_frame(block_356);
    a = var(1);
    push_var(a);
    a = number(0);
    push_var(a);
    a = var(2);
    fp = sp - 5;
    goto enter;
block_356:
    goto pop_frame;
entry_37:
    push_frame(block_355);
    a = closure_env[2];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_355:
    push_var(a);
    push_frame(block_354);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 37);
    fp = sp - 4;
    goto enter;
block_354:
    a = (a.bits == true_value.bits) ? false_value : true_value;
    if (a.bits == false_value.bits) goto block_348;
    a = var(0);
    push_var(a);
    a = var(1);
    a = alloc_labeled_value(&heap, 30, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_348:
    push_frame(block_353);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_353:
    push_var(a);
    push_frame(block_349);
    push_frame(block_351);
    push_frame(block_352);
    a = number(10);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[57];
    fp = sp - 5;
    goto enter;
block_352:
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_351:
    push_var(a);
    push_frame(block_350);
    a = number(48);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_350:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_349:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
entry_36:
    a = var(1);
    push_var(a);
    push_frame(block_346);
    push_frame(block_347);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_347:
    push_var(a);
    a = number(34);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_346:
    a = (a.bits == true_value.bits) ? false_value : true_value;
    if (a.bits == false_value.bits) goto block_342;
    push_frame(block_345);
    a = constant_env[56];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_345:
    goto pop_frame;
block_342:
    a = alloc_closure(&heap, 1, 4, &&entry_35 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(2));
    closure_store(&heap, a, 2, closure_env[1]);
    closure_store(&heap, a, 3, var(0));
    push_var(a);
    push_frame(block_343);
    push_frame(block_344);
    a = var(1);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_344:
    push_var(a);
    a = var(3);
    fp = sp - 4;
    goto enter;
block_343:
    goto pop_frame;
entry_35:
    push_frame(block_341);
    a = closure_env[3];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_341:
    switch (value_unbox_int32(a)) {
    case 34:
        goto block_340;
    case 92:
        goto block_337;
    case 10:
        goto block_328;
    default:
        goto block_326;
    }
block_340:
    push_frame(block_339);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_339:
    push_var(a);
    push_frame(block_338);
    a = closure_env[3];
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 10);
    fp = sp - 6;
    goto enter;
block_338:
    a = alloc_labeled_value(&heap, 36, a);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_337:
    push_frame(block_336);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_336:
    push_var(a);
    push_frame(block_335);
    a = var(0);
    push_var(a);
    a = number(2);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_335:
    push_var(a);
    push_frame(block_334);
    a = closure_env[3];
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_334:
    switch (value_unbox_int32(a)) {
    case 92:
        goto block_333;
    case 110:
        goto block_332;
    case 34:
        goto block_331;
    default:
        goto block_330;
    }
block_333:
    a = var(2);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
block_332:
    a = var(2);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
block_331:
    a = var(2);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
block_330:
    push_frame(block_329);
    a = constant_env[53];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_329:
    goto pop_frame;
block_328:
    push_frame(block_327);
    a = constant_env[55];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_327:
    goto pop_frame;
block_326:
    push_frame(block_325);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_325:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
entry_34:
    push_frame(block_323);
    push_frame(block_324);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_324:
    push_var(a);
    a = number(39);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_323:
    a = (a.bits == true_value.bits) ? false_value : true_value;
    if (a.bits == false_value.bits) goto block_298;
    push_frame(block_322);
    a = constant_env[50];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_322:
    goto pop_frame;
block_298:
    push_frame(block_321);
    a = var(1);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_321:
    push_var(a);
    push_frame(block_320);
    a = var(0);
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_320:
    switch (value_unbox_int32(a)) {
    case 92:
        goto block_319;
    case 39:
        goto block_310;
    case 10:
        goto block_308;
    default:
        push_var(a);
        goto block_306;
    }
block_319:
    push_frame(block_318);
    a = var(2);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_318:
    push_var(a);
    push_frame(block_317);
    a = var(0);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_317:
    switch (value_unbox_int32(a)) {
    case 92:
        goto block_316;
    case 110:
        goto block_315;
    case 39:
        goto block_314;
    default:
        goto block_313;
    }
block_316:
    a = number(92);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_311;
block_315:
    a = number(10);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_311;
block_314:
    a = number(39);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_311;
block_313:
    push_frame(block_312);
    a = constant_env[53];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_312:
    goto block_311;
block_311:
    pop_vars(1);
    goto block_305;
block_310:
    push_frame(block_309);
    a = constant_env[52];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_309:
    goto block_305;
block_308:
    push_frame(block_307);
    a = constant_env[51];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_307:
    goto block_305;
block_306:
    a = var(3);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    pop_vars(1);
    goto block_305;
block_305:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_302);
    push_frame(block_303);
    a = var(0);
    push_var(a);
    push_frame(block_304);
    a = var(4);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_304:
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_303:
    push_var(a);
    a = number(39);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_302:
    a = (a.bits == true_value.bits) ? false_value : true_value;
    if (a.bits == false_value.bits) goto block_299;
    push_frame(block_301);
    a = constant_env[54];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_301:
    goto pop_frame;
block_299:
    push_frame(block_300);
    a = var(4);
    push_var(a);
    a = number(2);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_300:
    push_var(a);
    a = var(3);
    a = alloc_labeled_value(&heap, 30, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_33:
    push_frame(block_297);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_297:
    push_var(a);
    a = alloc_closure(&heap, 1, 3, &&entry_31 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(2));
    closure_store(&heap, a, 2, var(0));
    push_var(a);
    a = alloc_closure(&heap, 1, 4, &&entry_32 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(3));
    closure_store(&heap, a, 2, var(2));
    closure_store(&heap, a, 3, var(0));
    push_var(a);
    push_frame(block_296);
    a = var(1);
    push_var(a);
    a = var(4);
    fp = sp - 4;
    goto enter;
block_296:
    goto pop_frame;
entry_32:
    push_frame(block_295);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_295:
    if (a.bits == false_value.bits) goto block_286;
    a = var(0);
    goto pop_frame;
block_286:
    push_frame(block_294);
    a = closure_env[3];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_294:
    switch (value_unbox_int32(a)) {
    case 32:
        goto block_293;
    case 10:
        goto block_291;
    case 92:
        goto block_289;
    default:
        goto block_287;
    }
block_293:
    push_frame(block_292);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_292:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
block_291:
    push_frame(block_290);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_290:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
block_289:
    push_frame(block_288);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_288:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
block_287:
    a = var(0);
    goto pop_frame;
entry_31:
    push_frame(block_285);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_285:
    if (a.bits == false_value.bits) goto block_279;
    a = var(0);
    goto pop_frame;
block_279:
    push_frame(block_283);
    push_frame(block_284);
    a = closure_env[2];
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_284:
    push_var(a);
    a = number(10);
    push_var(a);
    a = constant_env[49];
    fp = sp - 5;
    goto enter;
block_283:
    if (a.bits == false_value.bits) goto block_280;
    push_frame(block_282);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_282:
    goto pop_frame;
block_280:
    push_frame(block_281);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_281:
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-1, 1*sizeof(struct value));
    sp = fp + 4;
    goto enter;
entry_30:
    push_frame(block_278);
    a = var(0);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_278:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_277:
    push_frame(block_276);
    a = var(1);
    push_var(a);
    a = constant_env[6];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_276:
    if (a.bits == false_value.bits) goto block_275;
    a = labeled_empty_tuple(34);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_275:
    push_frame(block_274);
    a = var(1);
    push_var(a);
    a = constant_env[48];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_274:
    if (a.bits == false_value.bits) goto block_254;
    push_frame(block_273);
    a = var(2);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_273:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_272);
    a = var(4);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_272:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_271:
    push_frame(block_270);
    a = var(5);
    push_var(a);
    a = constant_env[9];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_270:
    if (a.bits == false_value.bits) goto block_258;
    push_frame(block_269);
    a = var(6);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_269:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_268:
    push_frame(block_267);
    a = var(7);
    push_var(a);
    a = constant_env[15];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_267:
    if (a.bits == false_value.bits) goto block_265;
    a = alloc_closure(&heap, 2, 4, &&entry_29 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[2]);
    closure_store(&heap, a, 2, closure_env[3]);
    closure_store(&heap, a, 3, closure_env[4]);
    push_var(a);
    push_frame(block_266);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(9);
    fp = sp - 5;
    goto enter;
block_266:
    pop_vars(1);
    goto block_259;
block_265:
    push_frame(block_264);
    a = var(7);
    push_var(a);
    a = constant_env[6];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_264:
    if (a.bits == false_value.bits) goto block_263;
    a = labeled_empty_tuple(34);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_259;
block_263:
    a = true_value;
    if (a.bits == false_value.bits) goto block_260;
    push_frame(block_261);
    push_frame(block_262);
    a = var(7);
    push_var(a);
    a = var(8);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_262:
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_261:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(9);
    a = alloc_labeled_value(&heap, 17, a);
    push_var(a);
    a = var(10);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    pop_vars(2);
    goto block_259;
block_260:
    halt();
block_259:
    pop_vars(2);
    goto block_255;
block_258:
    a = true_value;
    if (a.bits == false_value.bits) goto block_256;
    a = labeled_empty_tuple(26);
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    push_frame(block_257);
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_257:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_255;
block_256:
    halt();
block_255:
    pop_vars(2);
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(3);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 35, a);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_254:
    a = true_value;
    if (a.bits == false_value.bits) goto block_252;
    push_frame(block_253);
    a = constant_env[47];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_253:
    goto pop_frame;
block_252:
    halt();
entry_29:
    push_frame(block_251);
    a = var(1);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_251:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_250:
    push_frame(block_249);
    a = var(2);
    push_var(a);
    a = constant_env[7];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_249:
    if (a.bits == false_value.bits) goto block_247;
    push_frame(block_248);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_248:
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_247:
    push_frame(block_246);
    a = var(2);
    push_var(a);
    a = constant_env[6];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_246:
    if (a.bits == false_value.bits) goto block_244;
    push_frame(block_245);
    a = constant_env[6];
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_245:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_244:
    a = true_value;
    if (a.bits == false_value.bits) goto block_240;
    push_frame(block_242);
    push_frame(block_243);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_243:
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_242:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_241);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_241:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_240:
    halt();
entry_28:
    push_frame(block_239);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_239:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 8:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_238;
    case 12:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_225;
    case 30:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_224;
    default:
        halt();
    }
block_238:
block_237:
    push_frame(block_236);
    a = var(3);
    push_var(a);
    a = constant_env[6];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_236:
    if (a.bits == false_value.bits) goto block_235;
    a = labeled_empty_tuple(1);
    a = alloc_labeled_value(&heap, 34, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_235:
    push_frame(block_234);
    a = var(3);
    push_var(a);
    a = constant_env[46];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_234:
    if (a.bits == false_value.bits) goto block_228;
    push_frame(block_233);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_233:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    switch (value_label(&heap, a)) {
    case 30:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_232;
    default:
        goto block_230;
    }
block_232:
    push_frame(block_231);
    a = var(6);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_231:
    a = alloc_labeled_value(&heap, 33, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_230:
    push_frame(block_229);
    a = constant_env[45];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_229:
    goto pop_frame;
block_228:
    a = true_value;
    if (a.bits == false_value.bits) goto block_226;
    push_frame(block_227);
    a = constant_env[45];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_227:
    goto pop_frame;
block_226:
    halt();
block_225:
    a = var(3);
    a = alloc_labeled_value(&heap, 3, a);
    a = alloc_labeled_value(&heap, 34, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_224:
    a = var(3);
    a = alloc_labeled_value(&heap, 33, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_27:
    a = alloc_closure(&heap, 2, 6, &&entry_26 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[2]);
    closure_store(&heap, a, 3, c);
    closure_store(&heap, a, 4, var(0));
    closure_store(&heap, a, 5, closure_env[3]);
    push_var(a);
    push_frame(block_223);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(2);
    fp = sp - 5;
    goto enter;
block_223:
    goto pop_frame;
entry_26:
    push_frame(block_222);
    a = var(1);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_222:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_221);
    a = var(2);
    push_var(a);
    a = constant_env[40];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_221:
    if (a.bits == true_value.bits) goto block_217;
    push_frame(block_220);
    a = var(2);
    push_var(a);
    a = constant_env[42];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_220:
    if (a.bits == true_value.bits) goto block_218;
    push_frame(block_219);
    a = var(2);
    push_var(a);
    a = constant_env[41];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_219:
block_218:
block_217:
    push_var(a);
block_216:
    a = var(4);
    if (a.bits == false_value.bits) goto block_209;
    push_frame(block_215);
    a = closure_env[3];
    push_var(a);
    a = closure_env[4];
    push_var(a);
    a = var(1);
    push_var(a);
    a = closure_env[2];
    fp = sp - 6;
    goto enter;
block_215:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_214);
    a = var(6);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_214:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_213);
    a = var(7);
    push_var(a);
    a = constant_env[43];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_213:
    if (a.bits == false_value.bits) goto block_210;
    push_frame(block_212);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_212:
    push_var(a);
    a = var(8);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_210:
    push_frame(block_211);
    a = constant_env[44];
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_211:
    goto pop_frame;
block_209:
    a = true_value;
    if (a.bits == false_value.bits) goto block_207;
    push_frame(block_208);
    a = var(1);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_208:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(0);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 32, a);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_207:
    halt();
entry_25:
    a = alloc_closure(&heap, 2, 6, &&entry_24 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, var(0));
    closure_store(&heap, a, 2, closure_env[1]);
    closure_store(&heap, a, 3, var(1));
    closure_store(&heap, a, 4, closure_env[2]);
    closure_store(&heap, a, 5, closure_env[3]);
    push_var(a);
    push_frame(block_206);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    fp = sp - 5;
    goto enter;
block_206:
    goto pop_frame;
entry_24:
    push_frame(block_205);
    a = var(1);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_205:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 8:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_204;
    default:
        goto block_188;
    }
block_204:
block_203:
    push_frame(block_202);
    a = var(4);
    push_var(a);
    a = constant_env[42];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_202:
    if (a.bits == false_value.bits) goto block_199;
    push_frame(block_201);
    a = var(3);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_201:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(5);
    a = alloc_labeled_value(&heap, 31, a);
    push_var(a);
    push_frame(block_200);
    a = var(7);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_200:
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_199:
    push_frame(block_198);
    a = var(4);
    push_var(a);
    a = constant_env[41];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_198:
    if (a.bits == false_value.bits) goto block_195;
    push_frame(block_197);
    a = closure_env[1];
    push_var(a);
    a = closure_env[3];
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    fp = sp - 6;
    goto enter;
block_197:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_196);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_196:
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_195:
    push_frame(block_194);
    a = var(4);
    push_var(a);
    a = constant_env[40];
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_194:
    if (a.bits == false_value.bits) goto block_191;
    push_frame(block_193);
    a = closure_env[1];
    push_var(a);
    a = closure_env[3];
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[4];
    fp = sp - 6;
    goto enter;
block_193:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_192);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_192:
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_191:
    a = true_value;
    if (a.bits == false_value.bits) goto block_189;
    a = var(0);
    push_var(a);
    push_frame(block_190);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_190:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_189:
    halt();
block_188:
    a = var(0);
    push_var(a);
    push_frame(block_187);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_187:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_23:
    a = alloc_closure(&heap, 2, 3, &&entry_22 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[2]);
    push_var(a);
    push_frame(block_186);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    fp = sp - 5;
    goto enter;
block_186:
    goto pop_frame;
entry_22:
    push_frame(block_185);
    a = var(1);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_185:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_184);
    a = var(2);
    push_var(a);
    a = constant_env[9];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_184:
    if (a.bits == false_value.bits) goto block_176;
    push_frame(block_183);
    a = var(3);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_183:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    switch (value_label(&heap, a)) {
    case 12:
        goto block_182;
    case 30:
        goto block_180;
    default:
        halt();
    }
block_182:
    push_frame(block_181);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_181:
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_180:
    push_frame(block_179);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_179:
    push_var(a);
    a = var(5);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_176:
    push_frame(block_178);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_178:
    push_var(a);
    push_frame(block_177);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_177:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_21:
    a = alloc_closure(&heap, 3, 2, &&entry_18 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    push_var(a);
    a = alloc_closure(&heap, 4, 2, &&entry_19 - &&entry_0);
    closure_store(&heap, a, 0, var(2));
    closure_store(&heap, a, 1, closure_env[4]);
    push_var(a);
    a = alloc_closure(&heap, 2, 2, &&entry_20 - &&entry_0);
    closure_store(&heap, a, 0, var(3));
    closure_store(&heap, a, 1, var(0));
    push_var(a);
    push_frame(block_175);
    a = number(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(4);
    fp = sp - 5;
    goto enter;
block_175:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_174);
    a = var(6);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_174:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_173);
    a = var(7);
    push_var(a);
    a = constant_env[35];
    push_var(a);
    a = closure_env[3];
    fp = sp - 5;
    goto enter;
block_173:
    if (a.bits == false_value.bits) goto block_171;
    a = var(5);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_171:
    push_frame(block_172);
    a = constant_env[39];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_172:
    goto pop_frame;
entry_20:
    push_frame(block_170);
    a = var(1);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_170:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = c;
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(2);
    push_var(a);
    a = var(3);
    push_var(a);
    a = closure_env[0];
    memmove(stack+fp+3, stack+sp-4, 4*sizeof(struct value));
    sp = fp + 7;
    goto enter;
entry_19:
    a = var(3);
    push_var(a);
    push_frame(block_169);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_169:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(5);
    switch (value_label(&heap, a)) {
    case 1:
        goto block_168;
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_167;
    default:
        halt();
    }
block_168:
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_167:
block_166:
    push_frame(block_165);
    a = var(7);
    a = module_fetch(&heap, a, 21);
    push_var(a);
    a = var(1);
    push_var(a);
    a = constant_env[38];
    fp = sp - 5;
    goto enter;
block_165:
    if (a.bits == false_value.bits) goto block_164;
    a = var(2);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_164:
    a = true_value;
    if (a.bits == false_value.bits) goto block_157;
    push_frame(block_159);
    a = var(7);
    a = module_fetch(&heap, a, 22);
    switch (value_label(&heap, a)) {
    case 18:
        goto block_163;
    case 19:
        goto block_161;
    default:
        halt();
    }
block_163:
    push_frame(block_162);
    a = var(7);
    a = module_fetch(&heap, a, 21);
    push_var(a);
    a = number(1);
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_162:
    goto block_160;
block_161:
    a = var(7);
    a = module_fetch(&heap, a, 21);
    goto block_160;
block_160:
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(0);
    fp = sp - 5;
    goto enter;
block_159:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_158);
    a = var(2);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(7);
    push_var(a);
    a = closure_env[0];
    fp = sp - 6;
    goto enter;
block_158:
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(9);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-4, 4*sizeof(struct value));
    sp = fp + 7;
    goto enter;
block_157:
    halt();
entry_18:
    push_frame(block_156);
    a = var(2);
    a = module_fetch(&heap, a, 20);
    push_var(a);
    a = constant_env[16];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_156:
    if (a.bits == false_value.bits) goto block_152;
    a = var(0);
    switch (value_label(&heap, a)) {
    case 27:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 2);
        sp += 2;
        goto block_155;
    default:
        goto block_153;
    }
block_155:
    a = var(3);
    push_var(a);
    push_frame(block_154);
    a = var(4);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 28);
    fp = sp - 5;
    goto enter;
block_154:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    goto pop_frame;
block_153:
    a = var(0);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    goto pop_frame;
block_152:
    a = var(2);
    a = module_fetch(&heap, a, 20);
    a = alloc_labeled_value(&heap, 29, a);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(1);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(0);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 27, a);
    goto pop_frame;
entry_17:
    push_frame(block_151);
    a = var(2);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_151:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_150:
    push_frame(block_149);
    a = var(3);
    push_var(a);
    a = constant_env[15];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_149:
    if (a.bits == false_value.bits) goto block_142;
    push_frame(block_148);
    a = var(4);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_148:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_147);
    a = var(6);
    push_var(a);
    a = closure_env[5];
    fp = sp - 4;
    goto enter;
block_147:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_146);
    a = var(7);
    push_var(a);
    a = constant_env[9];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_146:
    if (a.bits == false_value.bits) goto block_144;
    a = var(5);
    push_var(a);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    goto block_143;
block_144:
    push_frame(block_145);
    a = constant_env[37];
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_145:
block_143:
    pop_vars(4);
    goto block_137;
block_142:
    a = true_value;
    if (a.bits == false_value.bits) goto block_138;
    push_frame(block_140);
    push_frame(block_141);
    a = var(3);
    push_var(a);
    a = var(4);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_141:
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_140:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(5);
    a = alloc_labeled_value(&heap, 17, a);
    push_var(a);
    push_frame(block_139);
    a = var(6);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_139:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(7);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    pop_vars(5);
    goto block_137;
block_138:
    halt();
block_137:
    pop_vars(2);
    open_tuple(&heap, &stack[sp], a, 3);
    sp += 3;
    push_frame(block_136);
    a = var(1);
    push_var(a);
    a = var(5);
    push_var(a);
    a = var(0);
    fp = sp - 5;
    goto enter;
block_136:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(4);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_135;
    case 7:
        goto block_134;
    default:
        halt();
    }
block_135:
    a = var(3);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    goto block_133;
block_134:
    a = var(3);
    push_var(a);
    a = labeled_empty_tuple(1);
    push_var(a);
    a = var(4);
    push_var(a);
    a = var(6);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 25, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    goto block_133;
block_133:
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_16:
    push_frame(block_132);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_132:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(3);
    a = alloc_labeled_value(&heap, 17, a);
    push_var(a);
    push_frame(block_131);
    a = var(4);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_131:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_130);
    a = var(1);
    push_var(a);
    a = var(7);
    push_var(a);
    a = var(0);
    fp = sp - 5;
    goto enter;
block_130:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(6);
    switch (value_label(&heap, a)) {
    case 26:
        goto block_129;
    case 7:
        goto block_127;
    default:
        halt();
    }
block_129:
    push_frame(block_128);
    a = constant_env[36];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_128:
    goto block_125;
block_127:
    push_frame(block_126);
    a = var(6);
    push_var(a);
    a = alloc_closure(&heap, 1, 1, &&entry_15 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[1]);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 23);
    fp = sp - 5;
    goto enter;
block_126:
    a = var(5);
    push_var(a);
    a = var(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(8);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 25, a);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 24, a);
    goto block_125;
block_125:
    push_var(a);
    a = var(10);
    push_var(a);
    a = var(9);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_15:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 17:
        goto block_124;
    default:
        goto block_123;
    }
block_124:
    a = empty_tuple;
    goto pop_frame;
block_123:
    push_frame(block_122);
    a = constant_env[36];
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_122:
    goto pop_frame;
entry_14:
    push_frame(block_121);
    a = var(0);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_121:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_120:
    push_frame(block_119);
    a = var(1);
    push_var(a);
    a = constant_env[35];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_119:
    if (a.bits == false_value.bits) goto block_117;
    a = labeled_empty_tuple(1);
    push_var(a);
    push_frame(block_118);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_118:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_81;
block_117:
    push_frame(block_116);
    a = var(1);
    push_var(a);
    a = constant_env[34];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_116:
    if (a.bits == false_value.bits) goto block_115;
    a = constant_env[16];
    push_var(a);
    a = number(0);
    push_var(a);
    a = labeled_empty_tuple(19);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_81;
block_115:
    push_frame(block_114);
    a = var(1);
    push_var(a);
    a = constant_env[32];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_114:
    if (a.bits == false_value.bits) goto block_113;
    a = constant_env[33];
    push_var(a);
    a = number(1);
    push_var(a);
    a = labeled_empty_tuple(19);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_81;
block_113:
    push_frame(block_112);
    a = var(1);
    push_var(a);
    a = constant_env[29];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_112:
    if (a.bits == false_value.bits) goto block_106;
    push_frame(block_111);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_111:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_110);
    a = var(3);
    push_var(a);
    a = constant_env[29];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_110:
    if (a.bits == false_value.bits) goto block_108;
    a = constant_env[30];
    push_var(a);
    a = number(2);
    push_var(a);
    a = labeled_empty_tuple(19);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_107;
block_108:
    push_frame(block_109);
    a = constant_env[31];
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_109:
block_107:
    pop_vars(2);
    goto block_81;
block_106:
    push_frame(block_105);
    a = var(1);
    push_var(a);
    a = constant_env[23];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_105:
    if (a.bits == false_value.bits) goto block_104;
    a = constant_env[28];
    push_var(a);
    a = number(3);
    push_var(a);
    a = labeled_empty_tuple(18);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_81;
block_104:
    push_frame(block_103);
    a = var(1);
    push_var(a);
    a = constant_env[25];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_103:
    if (a.bits == false_value.bits) goto block_96;
    a = var(2);
    push_var(a);
    push_frame(block_102);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_102:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_101:
    push_frame(block_100);
    a = var(4);
    push_var(a);
    a = constant_env[23];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_100:
    if (a.bits == false_value.bits) goto block_99;
    a = constant_env[27];
    push_var(a);
    a = number(3);
    push_var(a);
    a = labeled_empty_tuple(18);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_97;
block_99:
    a = true_value;
    if (a.bits == false_value.bits) goto block_98;
    a = constant_env[26];
    push_var(a);
    a = number(3);
    push_var(a);
    a = labeled_empty_tuple(18);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_97;
block_98:
    halt();
block_97:
    pop_vars(3);
    goto block_81;
block_96:
    push_frame(block_95);
    a = var(1);
    push_var(a);
    a = constant_env[21];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_95:
    if (a.bits == false_value.bits) goto block_88;
    a = var(2);
    push_var(a);
    push_frame(block_94);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_94:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_93:
    push_frame(block_92);
    a = var(4);
    push_var(a);
    a = constant_env[23];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_92:
    if (a.bits == false_value.bits) goto block_91;
    a = constant_env[24];
    push_var(a);
    a = number(3);
    push_var(a);
    a = labeled_empty_tuple(18);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(5);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_89;
block_91:
    a = true_value;
    if (a.bits == false_value.bits) goto block_90;
    a = constant_env[22];
    push_var(a);
    a = number(3);
    push_var(a);
    a = labeled_empty_tuple(18);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_89;
block_90:
    halt();
block_89:
    pop_vars(3);
    goto block_81;
block_88:
    push_frame(block_87);
    a = var(1);
    push_var(a);
    a = constant_env[19];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_87:
    if (a.bits == false_value.bits) goto block_86;
    a = constant_env[20];
    push_var(a);
    a = number(4);
    push_var(a);
    a = labeled_empty_tuple(18);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_81;
block_86:
    push_frame(block_85);
    a = var(1);
    push_var(a);
    a = constant_env[17];
    push_var(a);
    a = closure_env[1];
    fp = sp - 5;
    goto enter;
block_85:
    if (a.bits == false_value.bits) goto block_84;
    a = constant_env[18];
    push_var(a);
    a = number(5);
    push_var(a);
    a = labeled_empty_tuple(18);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_81;
block_84:
    a = true_value;
    if (a.bits == false_value.bits) goto block_82;
    a = constant_env[16];
    push_var(a);
    a = number(6);
    push_var(a);
    a = labeled_empty_tuple(18);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-3], 3);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    push_frame(block_83);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_83:
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto block_81;
block_82:
    halt();
block_81:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(3);
    switch (value_label(&heap, a)) {
    case 1:
        goto block_80;
    case 3:
        a = remove_label(&heap, a);
        open_tuple(&heap, &stack[sp], a, 3);
        sp += 3;
        goto block_79;
    default:
        halt();
    }
block_80:
    a = labeled_empty_tuple(1);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_79:
    a = var(5);
    push_var(a);
    a = var(6);
    push_var(a);
    a = var(7);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-3], 3, 4);
    pop_vars(3);
    a = alloc_labeled_value(&heap, 3, a);
    push_var(a);
    a = var(8);
    push_var(a);
    a = var(4);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
entry_13:
    a = alloc_closure(&heap, 2, 5, &&entry_12 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[2]);
    closure_store(&heap, a, 3, closure_env[3]);
    closure_store(&heap, a, 4, closure_env[4]);
    push_var(a);
    push_frame(block_78);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    fp = sp - 5;
    goto enter;
block_78:
    goto pop_frame;
entry_12:
    push_frame(block_77);
    a = var(1);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_77:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 12:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_76;
    case 8:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_74;
    default:
        halt();
    }
block_76:
    push_frame(block_75);
    a = var(4);
    a = alloc_labeled_value(&heap, 17, a);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_75:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_74:
block_73:
    push_frame(block_72);
    a = var(4);
    push_var(a);
    a = constant_env[9];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_72:
    if (a.bits == false_value.bits) goto block_70;
    push_frame(block_71);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_71:
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_70:
    push_frame(block_69);
    a = var(4);
    push_var(a);
    a = constant_env[6];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_69:
    if (a.bits == false_value.bits) goto block_67;
    push_frame(block_68);
    a = labeled_empty_tuple(16);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_68:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_67:
    push_frame(block_66);
    a = var(4);
    push_var(a);
    a = constant_env[15];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_66:
    if (a.bits == false_value.bits) goto block_63;
    push_frame(block_65);
    a = var(3);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_65:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    push_frame(block_64);
    a = var(5);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_64:
    push_var(a);
    a = var(6);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_63:
    a = true_value;
    if (a.bits == false_value.bits) goto block_61;
    push_frame(block_62);
    a = constant_env[14];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_62:
    goto pop_frame;
block_61:
    halt();
entry_11:
    push_frame(block_60);
    a = var(1);
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_60:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 8:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_59;
    default:
        goto block_54;
    }
block_59:
    push_frame(block_58);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_58:
    if (a.bits == false_value.bits) goto block_55;
    a = var(3);
    goto pop_frame;
block_55:
    push_frame(block_56);
    push_frame(block_57);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[9];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(4);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[12];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(0);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[13];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 15);
    fp = sp - 4;
    goto enter;
block_57:
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_56:
    goto pop_frame;
block_54:
    push_frame(block_52);
    push_frame(block_53);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = constant_env[9];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = var(0);
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = constant_env[11];
    push_var(a);
    a = stack[sp-1];
    stack[sp-1] = stack[sp-2];
    stack[sp-2] = a;
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 15);
    fp = sp - 4;
    goto enter;
block_53:
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_52:
    goto pop_frame;
entry_10:
    push_frame(block_51);
    a = var(0);
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_51:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(1);
    switch (value_label(&heap, a)) {
    case 12:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_50;
    default:
        goto block_49;
    }
block_50:
    a = var(3);
    push_var(a);
    a = var(2);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_49:
    push_frame(block_48);
    a = constant_env[10];
    push_var(a);
    a = closure_env[0];
    fp = sp - 4;
    goto enter;
block_48:
    goto pop_frame;
entry_9:
    a = alloc_closure(&heap, 2, 4, &&entry_8 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[2]);
    closure_store(&heap, a, 3, closure_env[3]);
    push_var(a);
    push_frame(block_47);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    fp = sp - 5;
    goto enter;
block_47:
    goto pop_frame;
entry_8:
    push_frame(block_46);
    a = var(1);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_46:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 12:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_45;
    case 8:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_43;
    default:
        halt();
    }
block_45:
    push_frame(block_44);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_44:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_43:
block_42:
    push_frame(block_41);
    a = var(4);
    push_var(a);
    a = constant_env[6];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_41:
    if (a.bits == false_value.bits) goto block_39;
    push_frame(block_40);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_40:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_39:
    push_frame(block_38);
    a = var(4);
    push_var(a);
    a = constant_env[9];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_38:
    if (a.bits == false_value.bits) goto block_36;
    push_frame(block_37);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_37:
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_36:
    a = true_value;
    if (a.bits == false_value.bits) goto block_34;
    push_frame(block_35);
    a = constant_env[8];
    push_var(a);
    a = closure_env[2];
    fp = sp - 4;
    goto enter;
block_35:
    goto pop_frame;
block_34:
    halt();
entry_7:
    a = alloc_closure(&heap, 2, 4, &&entry_6 - &&entry_0);
    closure_store(&heap, a, 0, closure_env[0]);
    closure_store(&heap, a, 1, closure_env[1]);
    closure_store(&heap, a, 2, closure_env[2]);
    closure_store(&heap, a, 3, closure_env[3]);
    push_var(a);
    push_frame(block_33);
    a = labeled_empty_tuple(26);
    push_var(a);
    a = var(0);
    push_var(a);
    a = var(1);
    fp = sp - 5;
    goto enter;
block_33:
    goto pop_frame;
entry_6:
    push_frame(block_32);
    a = var(1);
    push_var(a);
    a = closure_env[3];
    fp = sp - 4;
    goto enter;
block_32:
    open_tuple(&heap, &stack[sp], a, 2);
    sp += 2;
block_31:
    push_frame(block_30);
    a = var(2);
    push_var(a);
    a = constant_env[7];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_30:
    if (a.bits == false_value.bits) goto block_28;
    push_frame(block_29);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 14);
    fp = sp - 4;
    goto enter;
block_29:
    a = alloc_labeled_value(&heap, 13, a);
    push_var(a);
    a = var(3);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    goto pop_frame;
block_28:
    push_frame(block_27);
    a = var(2);
    push_var(a);
    a = constant_env[6];
    push_var(a);
    a = closure_env[2];
    fp = sp - 5;
    goto enter;
block_27:
    if (a.bits == false_value.bits) goto block_25;
    push_frame(block_26);
    a = constant_env[6];
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_26:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_25:
    a = true_value;
    if (a.bits == false_value.bits) goto block_20;
    a = var(2);
    switch (value_label(&heap, a)) {
    case 12:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_24;
    default:
        goto block_22;
    }
block_24:
    push_frame(block_23);
    a = var(4);
    push_var(a);
    a = var(0);
    push_var(a);
    a = constant_env[5];
    fp = sp - 5;
    goto enter;
block_23:
    push_var(a);
    a = var(3);
    push_var(a);
    a = c;
    memmove(stack+fp+3, stack+sp-2, 2*sizeof(struct value));
    sp = fp + 5;
    goto enter;
block_22:
    push_frame(block_21);
    a = constant_env[4];
    push_var(a);
    a = closure_env[1];
    fp = sp - 4;
    goto enter;
block_21:
    goto pop_frame;
block_20:
    halt();
entry_5:
    push_frame(block_16);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    push_frame(block_17);
    push_frame(block_19);
    a = var(0);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 11);
    fp = sp - 4;
    goto enter;
block_19:
    push_var(a);
    push_frame(block_18);
    a = number(1);
    push_var(a);
    a = constant_env[3];
    fp = sp - 4;
    goto enter;
block_18:
    push_var(a);
    a = constant_env[2];
    fp = sp - 5;
    goto enter;
block_17:
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 10);
    fp = sp - 6;
    goto enter;
block_16:
    goto pop_frame;
entry_4:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 8:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_15;
    default:
        goto block_13;
    }
block_15:
    push_frame(block_14);
    a = var(1);
    push_var(a);
    a = var(2);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 9);
    fp = sp - 5;
    goto enter;
block_14:
    goto pop_frame;
block_13:
    a = false_value;
    goto pop_frame;
entry_3:
    a = var(0);
    switch (value_label(&heap, a)) {
    case 7:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_12;
    default:
        halt();
    }
block_12:
    a = var(1);
    goto pop_frame;
entry_2:
    push_frame(block_11);
    a = var(0);
    push_var(a);
    a = closure_env[4];
    fp = sp - 4;
    goto enter;
block_11:
    push_var(a);
    push_frame(block_10);
    a = var(1);
    a = module_fetch(&heap, a, 4);
    push_var(a);
    a = closure_env[3];
    a = module_fetch(&heap, a, 5);
    fp = sp - 4;
    goto enter;
block_10:
    push_var(a);
    push_frame(block_9);
    a = var(2);
    push_var(a);
    a = closure_env[2];
    a = module_fetch(&heap, a, 5);
    fp = sp - 4;
    goto enter;
block_9:
    push_var(a);
    push_frame(block_8);
    a = var(3);
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 5);
    fp = sp - 4;
    goto enter;
block_8:
    push_var(a);
    push_frame(block_7);
    a = var(4);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 6);
    fp = sp - 4;
    goto enter;
block_7:
    goto pop_frame;
entry_1:
    push_frame(block_6);
    a = var(0);
    push_var(a);
    a = number(1);
    push_var(a);
    a = closure_env[0];
    a = module_fetch(&heap, a, 0);
    fp = sp - 5;
    goto enter;
block_6:
    switch (value_label(&heap, a)) {
    case 3:
        a = remove_label(&heap, a);
        push_var(a);
        goto block_5;
    case 1:
        goto block_4;
    default:
        halt();
    }
block_5:
    a = var(1);
    pop_vars(1);
    goto block_2;
block_4:
    push_frame(block_3);
    a = constant_env[0];
    push_var(a);
    a = closure_env[1];
    a = module_fetch(&heap, a, 2);
    fp = sp - 4;
    goto enter;
block_3:
    goto block_2;
block_2:
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_module(&heap, &stack[sp-1], 1, 0);
    pop_vars(1);
    goto pop_frame;
prim_cons:
    a = var(0);
    push_var(a);
    a = var(1);
    push_var(a);
    a = alloc_tuple(&heap, &stack[sp-2], 2);
    pop_vars(2);
    a = alloc_labeled_value(&heap, 7, a);
    goto pop_frame;
prim_file_read_all:
    a = prim_file_read_all(&heap, var(0));
    goto pop_frame;
prim_file_write:
    a = prim_file_write(&heap, var(0), var(1));
    goto pop_frame;
prim_file_close:
    a = prim_file_close(&heap, var(0));
    goto pop_frame;
prim_file_open:
    a = prim_file_open(&heap, var(0));
    goto pop_frame;
prim_file_create:
    a = prim_file_create(&heap, var(0));
    goto pop_frame;
prim_print_line:
    a = prim_print_line(&heap, var(0));
    goto pop_frame;
prim_string_compare:
    a = prim_string_compare(&heap, var(0), var(1));
    goto pop_frame;
prim_string_clip:
    a = prim_string_clip(&heap, var(0), var(1), var(2));
    goto pop_frame;
prim_string_fetch:
    a = prim_string_fetch(&heap, var(0), var(1));
    goto pop_frame;
prim_string_length:
    a = prim_string_length(&heap, var(0));
    goto pop_frame;
prim_string_equal:
    a = prim_string_equal(&heap, var(0), var(1));
    goto pop_frame;
prim_string_append:
    a = prim_string_append(&heap, var(0), var(1));
    goto pop_frame;
prim_greater_or_equal:
    a = prim_greater_or_equal(&heap, var(0), var(1));
    goto pop_frame;
prim_show_integer:
    a = prim_show_integer(&heap, var(0));
    goto pop_frame;
prim_ref_new:
    a = prim_ref_new(&heap, var(0));
    goto pop_frame;
prim_ref_store:
    a = prim_ref_store(&heap, var(0), var(1));
    goto pop_frame;
prim_ref_fetch:
    a = prim_ref_fetch(&heap, var(0));
    goto pop_frame;
prim_less_or_equal:
    a = prim_less_or_equal(&heap, var(0), var(1));
    goto pop_frame;
prim_greater:
    a = prim_greater(&heap, var(0), var(1));
    goto pop_frame;
prim_multiply:
    a = prim_multiply(&heap, var(0), var(1));
    goto pop_frame;
prim_equal:
    a = prim_equal(&heap, var(0), var(1));
    goto pop_frame;
prim_less:
    a = prim_less(&heap, var(0), var(1));
    goto pop_frame;
prim_negate:
    a = prim_negate(&heap, var(0));
    goto pop_frame;
prim_add:
    a = prim_add(&heap, var(0), var(1));
    goto pop_frame;
prim_die:
    a = prim_die(&heap, var(0));
    goto pop_frame;
enter:
    {
        c = a;
        if (!has_tag(c, TAG_CLOSURE)) halt;
        struct closure *closure = (struct closure *)address(&heap, c);
        if (closure->num_params != sp - (fp + 3)) halt();
        closure_env = closure->free_values;
        goto *(&&entry_0 + closure->code_offset);
    }
pop_frame:
    {
        struct value *frame = &stack[fp];
        sp = fp;
        c = frame[0];
        fp = frame[1].bits;
        struct closure *closure = (struct closure *)address(&heap, c);
        closure_env = closure->free_values;
        goto *(&&entry_0 + (int32_t)frame[2].bits);
    }
}