// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_threaded.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;

    static void * const operations[16] = {
        &&OP_CondMove,
        &&OP_ArrayIndex,
        &&OP_ArrayAmendment,
        &&OP_Add,
        &&OP_Mul,
        &&OP_Div,
        &&OP_NotAnd,
        &&OP_Halt,
        &&OP_Alloc,
        &&OP_Abandon,
        &&OP_Output,
        &&OP_Input,
        &&OP_LoadProgram,
        &&OP_Orthography,
        &&OP_Invalid,
        &&OP_Invalid,
    };
    uint32_t op = 0;
    while (1) {
#define JUMP()                                  \
        do {                                    \
            op = arr0->data[pc];                \
            goto *operations[op >> 28];         \
        } 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();
        }
    OP_Invalid:
        {
            fprintf(stderr, "Invalid Instruction: %08X\n", op);
            abort();
        }
    }
}

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movl $0x0, 0x194(%rsp)
movl %edi, 0x190(%rsp)
movq %rsi, 0x188(%rsp)
cmpl $0x1, 0x190(%rsp)
jg 0x129e
movq 0x3d7e(%rip), %rax      # 0x4ff0
movq (%rax), %rdi
movq 0x188(%rsp), %rax
movq (%rax), %rdx
leaq 0x1d7d(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x10c0
movl $0x1, 0x194(%rsp)
jmp 0x2593
movq $0x0, 0x180(%rsp)
movq $0x0, 0x178(%rsp)
movq 0x188(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x1d4e(%rip), %rsi      # 0x3017
callq 0x1130
movq %rax, 0x170(%rsp)
cmpq $0x0, 0x170(%rsp)
je 0x12e3
jmp 0x1302
leaq 0x1d30(%rip), %rdi      # 0x301a
leaq 0x1d33(%rip), %rsi      # 0x3024
movl $0x1b, %edx
leaq 0x1d36(%rip), %rcx      # 0x3033
callq 0x1080
movq 0x170(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1110
movl %eax, 0x16c(%rsp)
cmpl $0x0, 0x16c(%rsp)
jne 0x132b
jmp 0x134a
leaq 0x1d18(%rip), %rdi      # 0x304a
leaq 0x1ceb(%rip), %rsi      # 0x3024
movl $0x1d, %edx
leaq 0x1cee(%rip), %rcx      # 0x3033
callq 0x1080
movq 0x170(%rsp), %rdi
callq 0x10d0
movq %rax, 0x160(%rsp)
cmpq $0x0, 0x160(%rsp)
jl 0x136c
jmp 0x138b
leaq 0x1ce7(%rip), %rdi      # 0x305a
leaq 0x1caa(%rip), %rsi      # 0x3024
movl $0x1f, %edx
leaq 0x1cad(%rip), %rcx      # 0x3033
callq 0x1080
movq 0x160(%rsp), %rax
movq %rax, 0x178(%rsp)
movq 0x170(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1110
movl %eax, 0x16c(%rsp)
cmpl $0x0, 0x16c(%rsp)
jne 0x13c1
jmp 0x13e0
leaq 0x1c82(%rip), %rdi      # 0x304a
leaq 0x1c55(%rip), %rsi      # 0x3024
movl $0x22, %edx
leaq 0x1c58(%rip), %rcx      # 0x3033
callq 0x1080
movq 0x178(%rsp), %rdi
callq 0x10f0
movq %rax, 0x180(%rsp)
cmpq $0x0, 0x180(%rsp)
je 0x1402
jmp 0x1421
leaq 0x1c5b(%rip), %rdi      # 0x3064
leaq 0x1c14(%rip), %rsi      # 0x3024
movl $0x24, %edx
leaq 0x1c17(%rip), %rcx      # 0x3033
callq 0x1080
movq 0x180(%rsp), %rdi
movq 0x178(%rsp), %rdx
movq 0x170(%rsp), %rcx
movl $0x1, %esi
callq 0x1060
movq %rax, 0x158(%rsp)
movq 0x158(%rsp), %rax
cmpq 0x178(%rsp), %rax
jne 0x145f
jmp 0x147e
leaq 0x1c11(%rip), %rdi      # 0x3077
leaq 0x1bb7(%rip), %rsi      # 0x3024
movl $0x26, %edx
leaq 0x1bba(%rip), %rcx      # 0x3033
callq 0x1080
movq 0x170(%rsp), %rdi
callq 0x1070
movq 0x178(%rsp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x149f
jmp 0x14be
leaq 0x1be7(%rip), %rdi      # 0x308d
leaq 0x1b77(%rip), %rsi      # 0x3024
movl $0x29, %edx
leaq 0x1b7a(%rip), %rcx      # 0x3033
callq 0x1080
movq 0x178(%rsp), %rdi
addq $0x4, %rdi
callq 0x10f0
movq %rax, 0x150(%rsp)
cmpq $0x0, 0x150(%rsp)
je 0x14e4
jmp 0x1503
leaq 0x1bb7(%rip), %rdi      # 0x30a2
leaq 0x1b32(%rip), %rsi      # 0x3024
movl $0x2b, %edx
leaq 0x1b35(%rip), %rcx      # 0x3033
callq 0x1080
movq 0x178(%rsp), %rax
shrq $0x2, %rax
movl %eax, %ecx
movq 0x150(%rsp), %rax
movl %ecx, (%rax)
movq 0x180(%rsp), %rax
movq %rax, 0x148(%rsp)
movq $0x0, 0x140(%rsp)
movq 0x140(%rsp), %rax
movq 0x178(%rsp), %rcx
shrq $0x2, %rcx
cmpq %rcx, %rax
jae 0x1629
movq 0x148(%rsp), %rax
movq 0x140(%rsp), %rcx
shlq $0x2, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x13c(%rsp)
movq 0x148(%rsp), %rax
movq 0x140(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x1(%rax,%rcx), %eax
movl %eax, 0x138(%rsp)
movq 0x148(%rsp), %rax
movq 0x140(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x2(%rax,%rcx), %eax
movl %eax, 0x134(%rsp)
movq 0x148(%rsp), %rax
movq 0x140(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x3(%rax,%rcx), %eax
movl %eax, 0x130(%rsp)
movl 0x13c(%rsp), %edx
shll $0x18, %edx
movl 0x138(%rsp), %eax
shll $0x10, %eax
orl %eax, %edx
movl 0x134(%rsp), %eax
shll $0x8, %eax
orl %eax, %edx
orl 0x130(%rsp), %edx
movq 0x150(%rsp), %rax
movq 0x140(%rsp), %rcx
movl %edx, 0x4(%rax,%rcx,4)
movq 0x140(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x140(%rsp)
jmp 0x1537
movq 0x180(%rsp), %rdi
callq 0x1030
movq 0x39b3(%rip), %rax      # 0x4ff0
movq (%rax), %rdi
movq 0x178(%rsp), %rdx
leaq 0x1a60(%rip), %rsi      # 0x30af
movb $0x0, %al
callq 0x10c0
movq $0x0, 0x128(%rsp)
leaq 0x100(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1090
movl $0x1, %edi
movl $0x8, %esi
callq 0x10a0
movq %rax, 0xf8(%rsp)
movq 0x150(%rsp), %rcx
movq 0xf8(%rsp), %rax
movq %rcx, (%rax)
movq $0x1, 0xf0(%rsp)
movq $0x0, 0xe8(%rsp)
movq $0x0, 0xe0(%rsp)
movl $0x0, 0xdc(%rsp)
movl $0x0, 0xd8(%rsp)
jmp 0x16dc
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3654(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0xd4(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0xd0(%rsp)
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0xcc(%rsp)
movl 0xcc(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x1780
movl 0xd0(%rsp), %eax
movl 0x100(%rsp,%rax,4), %ecx
movl 0xd4(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x359c(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0xc8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0xc4(%rsp)
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0xc0(%rsp)
movl 0xc4(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0xbc(%rsp)
movl 0xbc(%rsp), %eax
cmpq 0xf0(%rsp), %rax
jae 0x1833
jmp 0x1852
leaq 0x1895(%rip), %rdi      # 0x30cf
leaq 0x17e3(%rip), %rsi      # 0x3024
movl $0x6e, %edx
leaq 0x17e6(%rip), %rcx      # 0x3033
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0xbc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0xb0(%rsp)
je 0x187a
jmp 0x1899
leaq 0x185d(%rip), %rdi      # 0x30de
leaq 0x179c(%rip), %rsi      # 0x3024
movl $0x70, %edx
leaq 0x179f(%rip), %rcx      # 0x3033
callq 0x1080
movl 0xc0(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movq 0xb0(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x18b5
jmp 0x18d4
leaq 0x182d(%rip), %rdi      # 0x30e9
leaq 0x1761(%rip), %rsi      # 0x3024
movl $0x71, %edx
leaq 0x1764(%rip), %rcx      # 0x3033
callq 0x1080
movq 0xb0(%rsp), %rax
movl 0xc0(%rsp), %ecx
movl 0x100(%rsp,%rcx,4), %ecx
movl 0x4(%rax,%rcx,4), %ecx
movl 0xc8(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3420(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0xac(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0xa8(%rsp)
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0xa4(%rsp)
movl 0xac(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0xa0(%rsp)
movl 0xa0(%rsp), %eax
cmpq 0xf0(%rsp), %rax
jae 0x19af
jmp 0x19ce
leaq 0x1719(%rip), %rdi      # 0x30cf
leaq 0x1667(%rip), %rsi      # 0x3024
movl $0x7c, %edx
leaq 0x166a(%rip), %rcx      # 0x3033
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0xa0(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x98(%rsp)
cmpq $0x0, 0x98(%rsp)
je 0x19f6
jmp 0x1a15
leaq 0x16e1(%rip), %rdi      # 0x30de
leaq 0x1620(%rip), %rsi      # 0x3024
movl $0x7e, %edx
leaq 0x1623(%rip), %rcx      # 0x3033
callq 0x1080
movl 0xa8(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movq 0x98(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x1a31
jmp 0x1a50
leaq 0x16c5(%rip), %rdi      # 0x30fd
leaq 0x15e5(%rip), %rsi      # 0x3024
movl $0x7f, %edx
leaq 0x15e8(%rip), %rcx      # 0x3033
callq 0x1080
movl 0xa4(%rsp), %eax
movl 0x100(%rsp,%rax,4), %edx
movq 0x98(%rsp), %rax
movl 0xa8(%rsp), %ecx
movl 0x100(%rsp,%rcx,4), %ecx
movl %edx, 0x4(%rax,%rcx,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x32a4(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x94(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x90(%rsp)
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x8c(%rsp)
movl 0x90(%rsp), %eax
movl 0x100(%rsp,%rax,4), %ecx
movl 0x8c(%rsp), %eax
addl 0x100(%rsp,%rax,4), %ecx
movl 0x94(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x31ef(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x88(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x84(%rsp)
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x80(%rsp)
movl 0x84(%rsp), %eax
movl 0x100(%rsp,%rax,4), %ecx
movl 0x80(%rsp), %eax
imull 0x100(%rsp,%rax,4), %ecx
movl 0x88(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3139(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x7c(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x78(%rsp)
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x1c75
jmp 0x1c94
leaq 0x1495(%rip), %rdi      # 0x3111
leaq 0x13a1(%rip), %rsi      # 0x3024
movl $0x9b, %edx
leaq 0x13a4(%rip), %rcx      # 0x3033
callq 0x1080
movl 0x78(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl 0x74(%rsp), %ecx
xorl %edx, %edx
divl 0x100(%rsp,%rcx,4)
movl %eax, %ecx
movl 0x7c(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x3063(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x70(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x6c(%rsp)
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x68(%rsp)
movl 0x6c(%rsp), %eax
movl 0x100(%rsp,%rax,4), %ecx
movl 0x68(%rsp), %eax
andl 0x100(%rsp,%rax,4), %ecx
xorl $-0x1, %ecx
movl 0x70(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2fbd(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movq 0x3218(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1100
movq 0x3229(%rip), %rax      # 0x4ff0
movq (%rax), %rdi
leaq 0x134c(%rip), %rsi      # 0x311d
movb $0x0, %al
callq 0x10c0
movl $0x0, 0x194(%rsp)
jmp 0x2593
movl 0xd8(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x64(%rsp)
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0x5c(%rsp)
movl $0x0, 0x58(%rsp)
movq 0xe0(%rsp), %rax
cmpq 0xe8(%rsp), %rax
jne 0x1e9f
movq 0xf0(%rsp), %rax
movl %eax, 0x58(%rsp)
movq 0xf0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf0(%rsp)
movq 0xf8(%rsp), %rdi
movq 0xf0(%rsp), %rsi
shlq $0x3, %rsi
callq 0x1120
movq %rax, 0xf8(%rsp)
cmpq $0x0, 0xf8(%rsp)
je 0x1e7e
jmp 0x1e9d
leaq 0x12a1(%rip), %rdi      # 0x3126
leaq 0x1198(%rip), %rsi      # 0x3024
movl $0xb7, %edx
leaq 0x119b(%rip), %rcx      # 0x3033
callq 0x1080
jmp 0x1ecb
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, 0xe0(%rsp)
movl -0x4(%rax), %eax
movl %eax, 0x58(%rsp)
movq 0xe0(%rsp), %rax
movl $0x0, (%rax)
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
movl $0x4, %esi
callq 0x10a0
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x1eef
jmp 0x1f0e
leaq 0x122d(%rip), %rdi      # 0x3123
leaq 0x1127(%rip), %rsi      # 0x3024
movl $0xbd, %edx
leaq 0x112a(%rip), %rcx      # 0x3033
callq 0x1080
movl 0x5c(%rsp), %ecx
movq 0x50(%rsp), %rax
movl %ecx, (%rax)
movq 0x50(%rsp), %rdx
movq 0xf8(%rsp), %rax
movl 0x58(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x58(%rsp), %ecx
movl 0x64(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2ddf(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpq 0xf0(%rsp), %rax
jae 0x1fbc
jmp 0x1fdb
leaq 0x110c(%rip), %rdi      # 0x30cf
leaq 0x105a(%rip), %rsi      # 0x3024
movl $0xc8, %edx
leaq 0x105d(%rip), %rcx      # 0x3033
callq 0x1080
cmpl $0x0, 0x48(%rsp)
je 0x1fe4
jmp 0x2003
leaq 0x1147(%rip), %rdi      # 0x3132
leaq 0x1032(%rip), %rsi      # 0x3024
movl $0xc9, %edx
leaq 0x1035(%rip), %rcx      # 0x3033
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0x48(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x2018
jmp 0x2037
leaq 0x111a(%rip), %rdi      # 0x3139
leaq 0xffe(%rip), %rsi       # 0x3024
movl $0xca, %edx
leaq 0x1001(%rip), %rcx      # 0x3033
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0x48(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq 0xf8(%rsp), %rax
movl 0x48(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movq 0xe0(%rsp), %rax
movq 0xe8(%rsp), %rcx
subq %rcx, %rax
sarq $0x2, %rax
movl 0xdc(%rsp), %ecx
cmpq %rcx, %rax
jne 0x2129
cmpl $0x0, 0xdc(%rsp)
jne 0x209c
movl $0x20, %eax
movl %eax, 0xc(%rsp)
jmp 0x20a9
movl 0xdc(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x44(%rsp)
movq 0xe8(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x1120
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
movl 0xdc(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
movl 0x44(%rsp), %eax
subl 0xdc(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1090
movq 0xe8(%rsp), %rax
movl 0xdc(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0xe0(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0xdc(%rsp)
movl 0x48(%rsp), %ecx
movq 0xe0(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0xe0(%rsp)
movl %ecx, (%rax)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2bd6(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl $0xff, 0x100(%rsp,%rax,4)
ja 0x21b9
jmp 0x21d8
leaq 0xf88(%rip), %rdi       # 0x3148
leaq 0xe5d(%rip), %rsi       # 0x3024
movl $0xdb, %edx
leaq 0xe60(%rip), %rcx       # 0x3033
callq 0x1080
movl 0x40(%rsp), %eax
movl 0x100(%rsp,%rax,4), %edi
callq 0x1040
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2b34(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x3c(%rsp)
movq 0x2d81(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
callq 0x1100
callq 0x10b0
movl %eax, 0x38(%rsp)
cmpl $-0x1, 0x38(%rsp)
jne 0x2278
movl 0x3c(%rsp), %eax
movl $0xffffffff, 0x100(%rsp,%rax,4) # imm = 0xFFFFFFFF
jmp 0x22ba
xorl %eax, %eax
cmpl 0x38(%rsp), %eax
jg 0x228c
cmpl $0xff, 0x38(%rsp)
jg 0x228c
jmp 0x22ab
leaq 0xec3(%rip), %rdi       # 0x3156
leaq 0xd8a(%rip), %rsi       # 0x3024
movl $0xe8, %edx
leaq 0xd8d(%rip), %rcx       # 0x3033
callq 0x1080
movl 0x38(%rsp), %ecx
movl 0x3c(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x2a62(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x34(%rsp)
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2465
movl 0x2c(%rsp), %eax
cmpq 0xf0(%rsp), %rax
jae 0x2367
jmp 0x2386
leaq 0xd61(%rip), %rdi       # 0x30cf
leaq 0xcaf(%rip), %rsi       # 0x3024
movl $0xf4, %edx
leaq 0xcb2(%rip), %rcx       # 0x3033
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0x2c(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x239b
jmp 0x23ba
leaq 0xd97(%rip), %rdi       # 0x3139
leaq 0xc7b(%rip), %rsi       # 0x3024
movl $0xf5, %edx
leaq 0xc7e(%rip), %rcx       # 0x3033
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0x2c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x10f0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x23f3
jmp 0x2412
leaq 0xd71(%rip), %rdi       # 0x316b
leaq 0xc23(%rip), %rsi       # 0x3024
movl $0xf8, %edx
leaq 0xc26(%rip), %rcx       # 0x3033
callq 0x1080
movq 0x20(%rsp), %rdi
movq 0xf8(%rsp), %rax
movl 0x2c(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x10e0
movq 0x150(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rax
movq %rax, 0x150(%rsp)
movq 0x20(%rsp), %rcx
movq 0xf8(%rsp), %rax
movq %rcx, (%rax)
movl 0x30(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %rax
movq 0x150(%rsp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x2491
jmp 0x24b0
leaq 0xce6(%rip), %rdi       # 0x317e
leaq 0xb85(%rip), %rsi       # 0x3024
movl $0xff, %edx
leaq 0xb88(%rip), %rcx       # 0x3033
callq 0x1080
jmp 0x24b2
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x287e(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movl 0xd8(%rsp), %eax
shrl $0x19, %eax
andl $0x7, %eax
movl %eax, 0x1c(%rsp)
movl 0xd8(%rsp), %eax
andl $0x1ffffff, %eax        # imm = 0x1FFFFFF
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x27fc(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x25a2
movq 0x2a7a(%rip), %rax      # 0x4ff0
movq (%rax), %rdi
movl 0xd8(%rsp), %edx
leaq 0xc09(%rip), %rsi       # 0x3190
movb $0x0, %al
callq 0x10c0
callq 0x1050
movl 0x194(%rsp), %eax
addq $0x198, %rsp            # imm = 0x198
retq
movq 0x10(%rsp), %rax
jmpq *%rax