// File: /workspace/github_c_makefile_star2_O2/minoki[P]icfpc2006/run_threaded_switch.c
// Function: main
int main(int argc, char *argv[])
{
    if (argc <= 1) {
        fprintf(stderr, "Usage: %s file.um\n", argv[0]);
        return 1;
    }
    void *rawprogram = NULL;
    size_t rawprogsize = 0;
    {
        FILE *f = fopen(argv[1], "rb");
        assert(f != NULL);
        int seekresult = fseek(f, 0, SEEK_END);
        assert(seekresult == 0);
        long size = ftell(f);
        assert(size >= 0);
        rawprogsize = size;
        seekresult = fseek(f, 0, SEEK_SET);
        assert(seekresult == 0);
        rawprogram = malloc(rawprogsize);
        assert(rawprogram != NULL);
        size_t result = fread(rawprogram, 1, rawprogsize, f);
        assert(result == rawprogsize);
        fclose(f);
    }
    assert(rawprogsize % 4 == 0);
    struct array *arr0 = malloc(sizeof(uint32_t) + rawprogsize);
    assert(arr0 != NULL);
    arr0->length = rawprogsize / 4;
    {
        uint8_t *rawprogram_ = (uint8_t *)rawprogram;
        for (size_t i = 0; i < rawprogsize / 4; ++i) {
            uint32_t a = (uint32_t)rawprogram_[4 * i];
            uint32_t b = (uint32_t)rawprogram_[4 * i + 1];
            uint32_t c = (uint32_t)rawprogram_[4 * i + 2];
            uint32_t d = (uint32_t)rawprogram_[4 * i + 3];
            arr0->data[i] = (a << 24) | (b << 16) | (c << 8) | d;
        }
        free(rawprogram);
    }

    fprintf(stderr, "Loaded program. size=%zu bytes\n", rawprogsize);

    size_t pc = 0;
    uint32_t reg[8] = {0};
    struct array **arr = calloc(1, sizeof(struct array *));
    arr[0] = arr0;
    size_t arraycount = 1;
    uint32_t *freelist = NULL, *freelist_end = NULL;
    uint32_t freelist_capacity = 0;

    uint32_t op = 0;
    while (1) {
#define JUMP()                                  \
        do {                                    \
            op = arr0->data[pc];                \
            switch (op >> 28) {                 \
            case 0: goto OP_CondMove;           \
            case 1: goto OP_ArrayIndex;         \
            case 2: goto OP_ArrayAmendment;     \
            case 3: goto OP_Add;                \
            case 4: goto OP_Mul;                \
            case 5: goto OP_Div;                \
            case 6: goto OP_NotAnd;             \
            case 7: goto OP_Halt;               \
            case 8: goto OP_Alloc;              \
            case 9: goto OP_Abandon;            \
            case 10: goto OP_Output;            \
            case 11: goto OP_Input;             \
            case 12: goto OP_LoadProgram;       \
            case 13: goto OP_Orthography;       \
            default: __builtin_unreachable();   \
            }                                   \
        } while (0)
        JUMP();
    OP_CondMove:
        {
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            if (reg[c] != 0) {
                reg[a] = reg[b];
            }
            ++pc;
            JUMP();
        }
    OP_ArrayIndex:
        {
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            uint32_t i = reg[b];
            assert(i < arraycount);
            struct array *ai = arr[i];
            assert(ai != NULL);
            assert(reg[c] < ai->length);
            reg[a] = ai->data[reg[c]];
            ++pc;
            JUMP();
        }
    OP_ArrayAmendment:
        {
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            uint32_t i = reg[a];
            assert(i < arraycount);
            struct array *ai = arr[i];
            assert(ai != NULL);
            assert(reg[b] < ai->length);
            ai->data[reg[b]] = reg[c];
            ++pc;
            JUMP();
        }
    OP_Add:
        {
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            reg[a] = reg[b] + reg[c];
            ++pc;
            JUMP();
        }
    OP_Mul:
        {
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            reg[a] = reg[b] * reg[c];
            ++pc;
            JUMP();
        }
    OP_Div:
        {
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            assert(reg[c] != 0);
            reg[a] = reg[b] / reg[c];
            ++pc;
            JUMP();
        }
    OP_NotAnd:
        {
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            reg[a] = ~(reg[b] & reg[c]);
            ++pc;
            JUMP();
        }
    OP_Halt:
        fflush(stdout);
        fprintf(stderr, "HALT\n");
        return 0;
    OP_Alloc:
        {
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            uint32_t capacity = reg[c];
            uint32_t i = 0;
            if (freelist_end == freelist) {
                i = arraycount;
                ++arraycount;
                arr = realloc(arr, sizeof(struct array *) * arraycount);
                assert(arr != NULL);
            } else {
                i = *(--freelist_end);
                *freelist_end = 0;
            }
            struct array *newarr = calloc(1 + capacity, sizeof(uint32_t));
            assert(newarr != NULL);
            newarr->length = capacity;
            arr[i] = newarr;
            reg[b] = i;
            ++pc;
            JUMP();
        }
    OP_Abandon:
        {
            uint32_t c = op & 7;
            uint32_t i = reg[c];
            assert(i < arraycount);
            assert(i != 0);
            assert(arr[i] != NULL);
            free(arr[i]);
            arr[i] = NULL;
            if (freelist_end - freelist == freelist_capacity) {
                uint32_t freelist_new_capacity = freelist_capacity == 0 ? 32 : freelist_capacity * 2;
                freelist = realloc(freelist, freelist_new_capacity * sizeof(uint32_t));
                memset(freelist + freelist_capacity, 0, (freelist_new_capacity - freelist_capacity) * sizeof(uint32_t));
                freelist_end = freelist + freelist_capacity;
                freelist_capacity = freelist_new_capacity;
            }
            *freelist_end++ = i;
            ++pc;
            JUMP();
        }
    OP_Output:
        {
            uint32_t c = op & 7;
            assert(reg[c] <= 255);
            putchar(reg[c]);
            ++pc;
            JUMP();
        }
    OP_Input:
        {
            uint32_t c = op & 7;
            fflush(stdout);
            int ch = getchar();
            if (ch == EOF) {
                reg[c] = (uint32_t)(-1);
            } else {
                assert(0 <= ch && ch <= 255);
                reg[c] = (uint32_t)ch;
            }
            ++pc;
            JUMP();
        }
    OP_LoadProgram:
        {
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            uint32_t i = reg[b];
            if (UNLIKELY(i != 0)) {
                assert(i < arraycount);
                assert(arr[i] != NULL);
                uint32_t length = arr[i]->length;
                struct array *newprogram = malloc((length + 1) * sizeof(uint32_t));
                assert(newprogram != NULL);
                memcpy(newprogram, arr[i], (length + 1) * sizeof(uint32_t));
                free(arr0);
                arr0 = newprogram;
                arr[0] = newprogram;
            }
            pc = reg[c];
            assert(pc < arr0->length);
            JUMP();
        }
    OP_Orthography:
        {
            uint32_t a = (op >> 25) & 7;
            uint32_t value = op & ((UINT32_C(1) << 25) - 1);
            reg[a] = value;
            ++pc;
            JUMP();
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x1, %edi
jg 0x1272
movq 0x2da2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rsi), %rdx
leaq 0x10b1(%rip), %rsi      # 0x2314
xorl %eax, %eax
callq 0x10b0
pushq $0x1
popq %rax
jmp 0x1d51
movq 0x8(%rsi), %rdi
leaq 0x10aa(%rip), %rsi      # 0x2327
callq 0x1120
testq %rax, %rax
je 0x155a
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1100
testl %eax, %eax
jne 0x1576
movq %r14, %rdi
callq 0x10c0
testq %rax, %rax
js 0x1592
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1100
testl %eax, %eax
jne 0x15ab
movq %r15, %rdi
callq 0x10e0
testq %rax, %rax
je 0x15c4
movq %rax, %r12
pushq $0x1
popq %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1050
cmpq %r15, %rax
jne 0x15dd
movq %r14, %rdi
callq 0x1060
testb $0x3, %r15b
jne 0x15f6
leaq 0x4(%r15), %rdi
callq 0x10e0
testq %rax, %rax
je 0x160f
movq %r15, %rsi
shrq $0x2, %rsi
movl %esi, (%rax)
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x133f
movl (%r12,%rcx,4), %edx
bswapl %edx
movl %edx, 0x4(%rax,%rcx,4)
incq %rcx
jmp 0x132b
movq %r12, %rdi
movq %rax, %r14
callq 0x1030
movq 0x2ca7(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x106b(%rip), %rsi      # 0x23c6
xorl %r13d, %r13d
movq %r15, %rdx
xorl %eax, %eax
callq 0x10b0
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
pushq $0x8
popq %rsi
movq %rbx, 0x18(%rsp)
movq %rbx, %rdi
callq 0x1090
movq %r14, %r8
movq %rax, %rdi
movq %r14, (%rax)
movl 0x4(%r14), %r12d
movl %r12d, %ecx
shrl $0x1c, %ecx
leaq 0xc65(%rip), %rax       # 0x2004
movq %rcx, (%rsp)
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsp), %rbx
jmp 0x1630
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x1977
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
jmp 0x1c83
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x1934
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x188a
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
xorl %ebx, %ebx
jmp 0x1678
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x1b8f
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x1849
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x1798
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x18cc
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x1a56
pushq $0x1
popq %rax
movq %rax, 0x18(%rsp)
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x1bee
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
jmp 0x1c4f
leaq 0xdc9(%rip), %rdi       # 0x232a
leaq 0xdcc(%rip), %rsi       # 0x2334
leaq 0xddb(%rip), %rcx       # 0x234a
pushq $0x1b
jmp 0x1626
leaq 0xde4(%rip), %rdi       # 0x2361
leaq 0xdb0(%rip), %rsi       # 0x2334
leaq 0xdbf(%rip), %rcx       # 0x234a
pushq $0x1d
jmp 0x1626
leaq 0xdd8(%rip), %rdi       # 0x2371
leaq 0xd94(%rip), %rsi       # 0x2334
leaq 0xda3(%rip), %rcx       # 0x234a
pushq $0x1f
jmp 0x1626
leaq 0xdaf(%rip), %rdi       # 0x2361
leaq 0xd7b(%rip), %rsi       # 0x2334
leaq 0xd8a(%rip), %rcx       # 0x234a
pushq $0x22
jmp 0x1626
leaq 0xdb0(%rip), %rdi       # 0x237b
leaq 0xd62(%rip), %rsi       # 0x2334
leaq 0xd71(%rip), %rcx       # 0x234a
pushq $0x24
jmp 0x1626
leaq 0xdaa(%rip), %rdi       # 0x238e
leaq 0xd49(%rip), %rsi       # 0x2334
leaq 0xd58(%rip), %rcx       # 0x234a
pushq $0x26
jmp 0x1626
leaq 0xda7(%rip), %rdi       # 0x23a4
leaq 0xd30(%rip), %rsi       # 0x2334
leaq 0xd3f(%rip), %rcx       # 0x234a
pushq $0x29
jmp 0x1626
leaq 0xda3(%rip), %rdi       # 0x23b9
leaq 0xd17(%rip), %rsi       # 0x2334
leaq 0xd26(%rip), %rcx       # 0x234a
pushq $0x2b
popq %rdx
callq 0x1070
movq %r13, (%rsp)
leaq 0xa05(%rip), %rax       # 0x203c
movl %r12d, %ecx
andl $0x7, %ecx
cmpl $0x0, 0x20(%rsp,%rcx,4)
je 0x165d
movl %r12d, %ecx
shrl %ecx
andl $0x1c, %ecx
movl 0x20(%rsp,%rcx), %ecx
shrl $0x4, %r12d
andl $0x1c, %r12d
movl %ecx, 0x20(%rsp,%r12)
movl 0x8(%r8,%rbx,4), %r12d
incq %rbx
movl %r12d, %ecx
shrl $0x1c, %ecx
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq (%rsp), %r13
leaq 0x9f5(%rip), %rax       # 0x2074
movl %r12d, %ecx
shrl %ecx
andl $0x1c, %ecx
movl 0x20(%rsp,%rcx), %ecx
cmpq %rcx, 0x18(%rsp)
jbe 0x177c
movq (%rdi,%rcx,8), %rcx
testq %rcx, %rcx
je 0x1744
movl %r12d, %edx
andl $0x7, %edx
movl %edx, %edx
movl 0x20(%rsp,%rdx,4), %edx
cmpl (%rcx), %edx
jae 0x1760
shrl $0x6, %r12d
andl $0x7, %r12d
movl 0x4(%rcx,%rdx,4), %ecx
movl %r12d, %edx
movl %ecx, 0x20(%rsp,%rdx,4)
movl 0x8(%r8,%rbx,4), %r12d
incq %rbx
movl %r12d, %ecx
shrl $0x1c, %ecx
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r13, (%rsp)
jmp 0x1798
movq %r13, (%rsp)
jmp 0x1c83
movq %r13, (%rsp)
jmp 0x1b8f
movq %r13, (%rsp)
jmp 0x1c4f
movq %r13, (%rsp)
jmp 0x1a56
movq %r13, (%rsp)
jmp 0x1934
movq %r13, (%rsp)
jmp 0x1977
movq %r13, (%rsp)
jmp 0x1849
movq %r13, (%rsp)
jmp 0x188a
movq %r13, (%rsp)
jmp 0x18cc
movq %r13, (%rsp)
jmp 0x1bee
leaq 0xcaa(%rip), %rdi       # 0x23f5
leaq 0xbe2(%rip), %rsi       # 0x2334
leaq 0xbf1(%rip), %rcx       # 0x234a
pushq $0x6e
jmp 0x1626
leaq 0xc99(%rip), %rdi       # 0x2400
leaq 0xbc6(%rip), %rsi       # 0x2334
leaq 0xbd5(%rip), %rcx       # 0x234a
pushq $0x6f
jmp 0x1626
leaq 0xc63(%rip), %rdi       # 0x23e6
leaq 0xbaa(%rip), %rsi       # 0x2334
leaq 0xbb9(%rip), %rcx       # 0x234a
pushq $0x6c
jmp 0x1626
leaq 0x90d(%rip), %rax       # 0x20ac
movl %r12d, %ecx
shrl $0x4, %ecx
andl $0x1c, %ecx
movl 0x20(%rsp,%rcx), %ecx
cmpq %rcx, 0x18(%rsp)
jbe 0x1811
movq (%rdi,%rcx,8), %rcx
testq %rcx, %rcx
je 0x17f5
movl %r12d, %edx
shrl $0x3, %edx
andl $0x7, %edx
movl %edx, %edx
movl 0x20(%rsp,%rdx,4), %edx
cmpl (%rcx), %edx
jae 0x182d
andl $0x7, %r12d
movl %r12d, %esi
movl 0x20(%rsp,%rsi,4), %esi
movl %esi, 0x4(%rcx,%rdx,4)
movl 0x8(%r8,%rbx,4), %r12d
incq %rbx
movl %r12d, %ecx
shrl $0x1c, %ecx
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0xbf9(%rip), %rdi       # 0x23f5
leaq 0xb31(%rip), %rsi       # 0x2334
leaq 0xb40(%rip), %rcx       # 0x234a
pushq $0x7c
jmp 0x1626
leaq 0xbce(%rip), %rdi       # 0x23e6
leaq 0xb15(%rip), %rsi       # 0x2334
leaq 0xb24(%rip), %rcx       # 0x234a
pushq $0x7a
jmp 0x1626
leaq 0xbe0(%rip), %rdi       # 0x2414
leaq 0xaf9(%rip), %rsi       # 0x2334
leaq 0xb08(%rip), %rcx       # 0x234a
pushq $0x7d
jmp 0x1626
leaq 0x894(%rip), %rax       # 0x20e4
movl %r12d, %ecx
andl $0x7, %ecx
movl %r12d, %edx
shrl %edx
andl $0x1c, %edx
movl 0x20(%rsp,%rcx,4), %ecx
addl 0x20(%rsp,%rdx), %ecx
shrl $0x4, %r12d
andl $0x1c, %r12d
movl %ecx, 0x20(%rsp,%r12)
movl 0x8(%r8,%rbx,4), %r12d
incq %rbx
movl %r12d, %ecx
shrl $0x1c, %ecx
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x88b(%rip), %rax       # 0x211c
movl %r12d, %ecx
andl $0x7, %ecx
movl %r12d, %edx
shrl %edx
andl $0x1c, %edx
movl 0x20(%rsp,%rcx,4), %ecx
imull 0x20(%rsp,%rdx), %ecx
shrl $0x4, %r12d
andl $0x1c, %r12d
movl %ecx, 0x20(%rsp,%r12)
movl 0x8(%r8,%rbx,4), %r12d
incq %rbx
movl %r12d, %ecx
shrl $0x1c, %ecx
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x881(%rip), %rcx       # 0x2154
movl %r12d, %eax
andl $0x7, %eax
movl 0x20(%rsp,%rax,4), %esi
testl %esi, %esi
je 0x1915
movl %r12d, %eax
shrl %eax
andl $0x1c, %eax
movl 0x20(%rsp,%rax), %eax
xorl %edx, %edx
divl %esi
shrl $0x4, %r12d
andl $0x1c, %r12d
movl %eax, 0x20(%rsp,%r12)
movl 0x8(%r8,%rbx,4), %r12d
incq %rbx
movl %r12d, %eax
shrl $0x1c, %eax
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xb0c(%rip), %rdi       # 0x2428
leaq 0xa11(%rip), %rsi       # 0x2334
leaq 0xa20(%rip), %rcx       # 0x234a
movl $0x99, %edx
callq 0x1070
leaq 0x851(%rip), %rax       # 0x218c
movl %r12d, %ecx
andl $0x7, %ecx
movl %r12d, %edx
shrl %edx
andl $0x1c, %edx
movl 0x20(%rsp,%rcx,4), %ecx
andl 0x20(%rsp,%rdx), %ecx
notl %ecx
shrl $0x4, %r12d
andl $0x1c, %r12d
movl %ecx, 0x20(%rsp,%r12)
movl 0x8(%r8,%rbx,4), %r12d
incq %rbx
movl %r12d, %ecx
shrl $0x1c, %ecx
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq %r8, %r15
movl %r12d, %eax
andl $0x7, %eax
movl 0x20(%rsp,%rax,4), %ebp
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x19a6
movq %rdi, %r14
movl -0x4(%rax), %r13d
andl $0x0, -0x4(%rax)
addq $-0x4, %rax
movq %rax, 0x8(%rsp)
jmp 0x19cb
movq 0x18(%rsp), %r13
leaq 0x8(,%r13,8), %rsi
callq 0x1110
testq %rax, %rax
je 0x1a37
movq %rax, %r14
movq %r13, %rax
incq %rax
movq %rax, 0x18(%rsp)
leal 0x1(%rbp), %edi
pushq $0x4
popq %rsi
callq 0x1090
testq %rax, %rax
je 0x1a18
shrl $0x3, %r12d
andl $0x7, %r12d
movl %ebp, (%rax)
movl %r13d, %ecx
movq %r14, %rdi
movq %rax, (%r14,%rcx,8)
movl %r12d, %eax
movl %r13d, 0x20(%rsp,%rax,4)
movq %r15, %r8
movl 0x8(%r15,%rbx,4), %r12d
incq %rbx
movl %r12d, %eax
shrl $0x1c, %eax
leaq 0x7b5(%rip), %rcx       # 0x21c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xa1b(%rip), %rdi       # 0x243a
leaq 0x90e(%rip), %rsi       # 0x2334
leaq 0x91d(%rip), %rcx       # 0x234a
movl $0xbb, %edx
callq 0x1070
leaq 0x9ff(%rip), %rdi       # 0x243d
leaq 0x8ef(%rip), %rsi       # 0x2334
leaq 0x8fe(%rip), %rcx       # 0x234a
movl $0xb5, %edx
callq 0x1070
movq %rdi, 0x40(%rsp)
andl $0x7, %r12d
movl 0x20(%rsp,%r12,4), %r12d
cmpq %r12, 0x18(%rsp)
jbe 0x1b32
testl %r12d, %r12d
movq 0x8(%rsp), %rbp
je 0x1b51
movq %rdi, %r14
movq (%rdi,%r12,8), %rdi
testq %rdi, %rdi
je 0x1b70
movq %r8, %r15
callq 0x1030
andq $0x0, (%r14,%r12,8)
movq %rbp, %r13
movq 0x10(%rsp), %rdx
subq %rdx, %r13
movq %r13, %rax
sarq $0x2, %rax
movq (%rsp), %r8
movl %r8d, %ecx
cmpq %rcx, %rax
jne 0x1b01
leal (%r8,%r8), %ebp
testl %r8d, %r8d
pushq $0x20
popq %rax
cmovel %eax, %ebp
leaq (,%rbp,4), %rsi
movq %rdx, %rdi
movq %r8, %r14
callq 0x1110
movq %rax, 0x10(%rsp)
addq %rax, %r13
movl %ebp, %edx
subl %r14d, %edx
shlq $0x2, %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x1080
movq 0x40(%rsp), %rdi
movq %rbp, (%rsp)
movq %r13, %rbp
jmp 0x1b04
movq %r14, %rdi
movq %r15, %r8
movl %r12d, (%rbp)
addq $0x4, %rbp
movq %rbp, 0x8(%rsp)
movl 0x8(%r15,%rbx,4), %r12d
incq %rbx
movl %r12d, %eax
shrl $0x1c, %eax
leaq 0x6d3(%rip), %rcx       # 0x21fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8ad(%rip), %rdi       # 0x23e6
leaq 0x7f4(%rip), %rsi       # 0x2334
leaq 0x803(%rip), %rcx       # 0x234a
movl $0xc6, %edx
callq 0x1070
leaq 0x8f1(%rip), %rdi       # 0x2449
leaq 0x7d5(%rip), %rsi       # 0x2334
leaq 0x7e4(%rip), %rcx       # 0x234a
movl $0xc7, %edx
callq 0x1070
leaq 0x8d9(%rip), %rdi       # 0x2450
leaq 0x7b6(%rip), %rsi       # 0x2334
leaq 0x7c5(%rip), %rcx       # 0x234a
movl $0xc8, %edx
callq 0x1070
leaq 0x69e(%rip), %r15       # 0x2234
movq %rdi, %r14
andl $0x7, %r12d
movl 0x20(%rsp,%r12,4), %edi
cmpl $0x100, %edi            # imm = 0x100
jae 0x1bcf
movq %r8, %r13
callq 0x1040
movq %r13, %r8
movl 0x8(%r13,%rbx,4), %r12d
incq %rbx
movl %r12d, %eax
shrl $0x1c, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
movq %r14, %rdi
jmpq *%rax
leaq 0x889(%rip), %rdi       # 0x245f
leaq 0x757(%rip), %rsi       # 0x2334
leaq 0x766(%rip), %rcx       # 0x234a
movl $0xd9, %edx
callq 0x1070
pushq $-0x1
popq %rbp
leaq 0x674(%rip), %r13       # 0x226c
movq %r8, %r15
movq %rdi, %r14
movq 0x23d3(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x10f0
callq 0x10a0
movl %ebp, %ecx
cmpl $-0x1, %eax
je 0x1c26
movl %eax, %ecx
cmpl $0x100, %eax            # imm = 0x100
jae 0x1d7f
andl $0x7, %r12d
movl %r12d, %eax
movl %ecx, 0x20(%rsp,%rax,4)
movq %r15, %r8
movl 0x8(%r15,%rbx,4), %r12d
incq %rbx
movl %r12d, %eax
shrl $0x1c, %eax
movslq (%r13,%rax,4), %rax
addq %r13, %rax
movq %r14, %rdi
jmpq *%rax
leaq 0x686(%rip), %rax       # 0x22dc
movl %r12d, %ecx
andl $0x1ffffff, %ecx        # imm = 0x1FFFFFF
shrl $0x17, %r12d
andl $0x1c, %r12d
movl %ecx, 0x20(%rsp,%r12)
movl 0x8(%r8,%rbx,4), %r12d
incq %rbx
movl %r12d, %ecx
shrl $0x1c, %ecx
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x61a(%rip), %r15       # 0x22a4
movl %r12d, %eax
shrl %eax
andl $0x1c, %eax
movl 0x20(%rsp,%rax), %eax
testq %rax, %rax
jne 0x1cc3
andl $0x7, %r12d
movl %r12d, %eax
movl 0x20(%rsp,%rax,4), %ebx
cmpl (%r8), %ebx
jae 0x1d60
movl 0x4(%r8,%rbx,4), %r12d
movl %r12d, %eax
shrl $0x1c, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
cmpq %rax, 0x18(%rsp)
jbe 0x1d9e
movq (%rdi,%rax,8), %rbp
testq %rbp, %rbp
je 0x1dbd
movq %r8, %r14
movq %rdi, %rbx
movl (%rbp), %r13d
incl %r13d
shlq $0x2, %r13
movq %r13, %rdi
callq 0x10e0
testq %rax, %rax
je 0x1ddc
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rax, %r13
callq 0x10d0
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r13, (%rbx)
movq %r13, %r8
jmp 0x1c9b
movq 0x22ad(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x10f0
movq 0x22be(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x6f0(%rip), %rdi       # 0x2434
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
callq 0x1130
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x72e(%rip), %rdi       # 0x2495
leaq 0x5c6(%rip), %rsi       # 0x2334
leaq 0x5d5(%rip), %rcx       # 0x234a
movl $0xfd, %edx
callq 0x1070
leaq 0x6e7(%rip), %rdi       # 0x246d
leaq 0x5a7(%rip), %rsi       # 0x2334
leaq 0x5b6(%rip), %rcx       # 0x234a
movl $0xe6, %edx
callq 0x1070
leaq 0x641(%rip), %rdi       # 0x23e6
leaq 0x588(%rip), %rsi       # 0x2334
leaq 0x597(%rip), %rcx       # 0x234a
movl $0xf2, %edx
callq 0x1070
leaq 0x68c(%rip), %rdi       # 0x2450
leaq 0x569(%rip), %rsi       # 0x2334
leaq 0x578(%rip), %rcx       # 0x234a
movl $0xf3, %edx
callq 0x1070
leaq 0x69f(%rip), %rdi       # 0x2482
leaq 0x54a(%rip), %rsi       # 0x2334
leaq 0x559(%rip), %rcx       # 0x234a
movl $0xf6, %edx
callq 0x1070