// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run.c
// Function: main
int main(int argc, char *argv[])
{
    const char *filename = NULL;
    char *presupplied_input = NULL;
    bool discard_initial_output = false;
    for (int i = 1; i < argc; ++i) {
        if (strcmp(argv[i], "--input") == 0) {
            if (i + 1 < argc) {
                ++i;
                size_t len0 = presupplied_input == NULL ? 0 : strlen(presupplied_input);
                size_t len1 = strlen(argv[i]);
                presupplied_input = realloc(presupplied_input, len0 + len1 + 2);
                memcpy(presupplied_input + len0, argv[i], len1);
                presupplied_input[len0 + len1] = '\n';
                presupplied_input[len0 + len1 + 1] = '\0';
            }
        } else if (strcmp(argv[i], "--discard-initial-output") == 0) {
            discard_initial_output = true;
        } else if (strcmp(argv[i], "--help") == 0) {
            return usage(argv[0]);
        } else {
            filename = argv[i];
        }
    }
    if (filename == NULL) {
        return usage(argv[0]);
    }
    void *rawprogram = NULL;
    size_t rawprogsize = 0;
    {
        FILE *f = fopen(filename, "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 *program = malloc(sizeof(uint32_t) + rawprogsize);
    assert(program != NULL);
    program->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];
            program->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] = program;
    size_t arraycount = 1;
    uint32_t *freelist = NULL, *freelist_end = NULL;
    uint32_t freelist_capacity = 0;
    while (1) {
        assert(pc < program->length);
        uint32_t op = program->data[pc];
        ++pc;
        switch (op >> 28) {
        case 0: /* Conditional Move */
            {
                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];
                }
                break;
            }
        case 1: /* Array Index */
            {
                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]];
                break;
            }
        case 2: /* Array Amendment */
            {
                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];
                break;
            }
        case 3: /* Addition */
            {
                uint32_t a = (op >> 6) & 7;
                uint32_t b = (op >> 3) & 7;
                uint32_t c = op & 7;
                reg[a] = reg[b] + reg[c];
                break;
            }
        case 4: /* Multiplication */
            {
                uint32_t a = (op >> 6) & 7;
                uint32_t b = (op >> 3) & 7;
                uint32_t c = op & 7;
                reg[a] = reg[b] * reg[c];
                break;
            }
        case 5: /* Division */
            {
                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];
                break;
            }
        case 6: /* Not-And */
            {
                uint32_t a = (op >> 6) & 7;
                uint32_t b = (op >> 3) & 7;
                uint32_t c = op & 7;
                reg[a] = ~(reg[b] & reg[c]);
                break;
            }
        case 7: /* Halt */
            fflush(stdout);
            fprintf(stderr, "<<<HALT>>>\n");
            return 0;
        case 8: /* Allocation */
            {
                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;
                break;
            }
        case 9: /* Abandonment */
            {
                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;
                break;
            }
        case 10: /* Output */
            {
                uint32_t c = op & 7;
                assert(reg[c] <= 255);
                if (!discard_initial_output || presupplied_input == NULL || *presupplied_input == '\0') {
                    putchar(reg[c]);
                }
                break;
            }
        case 11: /* Input */
            {
                uint32_t c = op & 7;
                int ch;
                if (presupplied_input == NULL || *presupplied_input == '\0') {
                    fflush(stdout);
                    ch = getchar();
                } else {
                    ch = (unsigned char)*presupplied_input++;
                }
                if (ch == EOF) {
                    reg[c] = (uint32_t)(-1);
                } else {
                    assert(0 <= ch && ch <= 255);
                    reg[c] = (uint32_t)ch;
                }
                break;
            }
        case 12: /* Load Program */
            {
                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(program);
                    program = newprogram;
                    arr[0] = newprogram;
                }
                pc = reg[c];
                break;
            }
        case 13: /* Orthography */
            {
                uint32_t a = (op >> 25) & 7;
                uint32_t value = op & ((UINT32_C(1) << 25) - 1);
                reg[a] = value;
                break;
            }
        default:
            fflush(stdout);
            fprintf(stderr, "<<<Invalid Instruction: %08X>>>\n", op);
            abort();
        }
    }
}

// Assembly:
subq $0x1b8, %rsp            # imm = 0x1B8
movl $0x0, 0x1b4(%rsp)
movl %edi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq $0x0, 0x1a0(%rsp)
movq $0x0, 0x198(%rsp)
movb $0x0, 0x197(%rsp)
movl $0x1, 0x190(%rsp)
movl 0x190(%rsp), %eax
cmpl 0x1b0(%rsp), %eax
jge 0x14a5
movq 0x1a8(%rsp), %rax
movslq 0x190(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1d61(%rip), %rsi      # 0x303c
callq 0x10c0
cmpl $0x0, %eax
jne 0x13fd
movl 0x190(%rsp), %eax
addl $0x1, %eax
cmpl 0x1b0(%rsp), %eax
jge 0x13f8
movl 0x190(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x190(%rsp)
cmpq $0x0, 0x198(%rsp)
jne 0x1325
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x1337
movq 0x198(%rsp), %rdi
callq 0x1080
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x188(%rsp)
movq 0x1a8(%rsp), %rax
movslq 0x190(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1080
movq %rax, 0x180(%rsp)
movq 0x198(%rsp), %rdi
movq 0x188(%rsp), %rsi
addq 0x180(%rsp), %rsi
addq $0x2, %rsi
callq 0x1140
movq %rax, 0x198(%rsp)
movq 0x198(%rsp), %rdi
addq 0x188(%rsp), %rdi
movq 0x1a8(%rsp), %rax
movslq 0x190(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x180(%rsp), %rdx
callq 0x1100
movq 0x198(%rsp), %rax
movq 0x188(%rsp), %rcx
addq 0x180(%rsp), %rcx
movb $0xa, (%rax,%rcx)
movq 0x198(%rsp), %rax
movq 0x188(%rsp), %rcx
addq 0x180(%rsp), %rcx
movb $0x0, 0x1(%rax,%rcx)
jmp 0x148d
movq 0x1a8(%rsp), %rax
movslq 0x190(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1c2c(%rip), %rsi      # 0x3044
callq 0x10c0
cmpl $0x0, %eax
jne 0x142c
movb $0x1, 0x197(%rsp)
jmp 0x148b
movq 0x1a8(%rsp), %rax
movslq 0x190(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x1c16(%rip), %rsi      # 0x305d
callq 0x10c0
cmpl $0x0, %eax
jne 0x146d
movq 0x1a8(%rsp), %rax
movq (%rax), %rdi
callq 0x2480
movl %eax, 0x1b4(%rsp)
jmp 0x2469
movq 0x1a8(%rsp), %rax
movslq 0x190(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x1a0(%rsp)
jmp 0x148b
jmp 0x148d
jmp 0x148f
movl 0x190(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x190(%rsp)
jmp 0x12ac
cmpq $0x0, 0x1a0(%rsp)
jne 0x14cc
movq 0x1a8(%rsp), %rax
movq (%rax), %rdi
callq 0x2480
movl %eax, 0x1b4(%rsp)
jmp 0x2469
movq $0x0, 0x178(%rsp)
movq $0x0, 0x170(%rsp)
movq 0x1a0(%rsp), %rdi
leaq 0x1b71(%rip), %rsi      # 0x3064
callq 0x1150
movq %rax, 0x168(%rsp)
cmpq $0x0, 0x168(%rsp)
je 0x150d
jmp 0x152c
leaq 0x1b53(%rip), %rdi      # 0x3067
leaq 0x1b56(%rip), %rsi      # 0x3071
movl $0x36, %edx
leaq 0x1b50(%rip), %rcx      # 0x3077
callq 0x1090
movq 0x168(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1130
movl %eax, 0x164(%rsp)
cmpl $0x0, 0x164(%rsp)
jne 0x1555
jmp 0x1574
leaq 0x1b32(%rip), %rdi      # 0x308e
leaq 0x1b0e(%rip), %rsi      # 0x3071
movl $0x38, %edx
leaq 0x1b08(%rip), %rcx      # 0x3077
callq 0x1090
movq 0x168(%rsp), %rdi
callq 0x10f0
movq %rax, 0x158(%rsp)
cmpq $0x0, 0x158(%rsp)
jl 0x1596
jmp 0x15b5
leaq 0x1b01(%rip), %rdi      # 0x309e
leaq 0x1acd(%rip), %rsi      # 0x3071
movl $0x3a, %edx
leaq 0x1ac7(%rip), %rcx      # 0x3077
callq 0x1090
movq 0x158(%rsp), %rax
movq %rax, 0x170(%rsp)
movq 0x168(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1130
movl %eax, 0x164(%rsp)
cmpl $0x0, 0x164(%rsp)
jne 0x15eb
jmp 0x160a
leaq 0x1a9c(%rip), %rdi      # 0x308e
leaq 0x1a78(%rip), %rsi      # 0x3071
movl $0x3d, %edx
leaq 0x1a72(%rip), %rcx      # 0x3077
callq 0x1090
movq 0x170(%rsp), %rdi
callq 0x1110
movq %rax, 0x178(%rsp)
cmpq $0x0, 0x178(%rsp)
je 0x162c
jmp 0x164b
leaq 0x1a75(%rip), %rdi      # 0x30a8
leaq 0x1a37(%rip), %rsi      # 0x3071
movl $0x3f, %edx
leaq 0x1a31(%rip), %rcx      # 0x3077
callq 0x1090
movq 0x178(%rsp), %rdi
movq 0x170(%rsp), %rdx
movq 0x168(%rsp), %rcx
movl $0x1, %esi
callq 0x1060
movq %rax, 0x150(%rsp)
movq 0x150(%rsp), %rax
cmpq 0x170(%rsp), %rax
jne 0x1689
jmp 0x16a8
leaq 0x1a2b(%rip), %rdi      # 0x30bb
leaq 0x19da(%rip), %rsi      # 0x3071
movl $0x41, %edx
leaq 0x19d4(%rip), %rcx      # 0x3077
callq 0x1090
movq 0x168(%rsp), %rdi
callq 0x1070
movq 0x170(%rsp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x16c9
jmp 0x16e8
leaq 0x1a01(%rip), %rdi      # 0x30d1
leaq 0x199a(%rip), %rsi      # 0x3071
movl $0x44, %edx
leaq 0x1994(%rip), %rcx      # 0x3077
callq 0x1090
movq 0x170(%rsp), %rdi
addq $0x4, %rdi
callq 0x1110
movq %rax, 0x148(%rsp)
cmpq $0x0, 0x148(%rsp)
je 0x170e
jmp 0x172d
leaq 0x1996(%rip), %rdi      # 0x30ab
leaq 0x1955(%rip), %rsi      # 0x3071
movl $0x46, %edx
leaq 0x194f(%rip), %rcx      # 0x3077
callq 0x1090
movq 0x170(%rsp), %rax
shrq $0x2, %rax
movl %eax, %ecx
movq 0x148(%rsp), %rax
movl %ecx, (%rax)
movq 0x178(%rsp), %rax
movq %rax, 0x140(%rsp)
movq $0x0, 0x138(%rsp)
movq 0x138(%rsp), %rax
movq 0x170(%rsp), %rcx
shrq $0x2, %rcx
cmpq %rcx, %rax
jae 0x1853
movq 0x140(%rsp), %rax
movq 0x138(%rsp), %rcx
shlq $0x2, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, 0x134(%rsp)
movq 0x140(%rsp), %rax
movq 0x138(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x1(%rax,%rcx), %eax
movl %eax, 0x130(%rsp)
movq 0x140(%rsp), %rax
movq 0x138(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x2(%rax,%rcx), %eax
movl %eax, 0x12c(%rsp)
movq 0x140(%rsp), %rax
movq 0x138(%rsp), %rcx
shlq $0x2, %rcx
movzbl 0x3(%rax,%rcx), %eax
movl %eax, 0x128(%rsp)
movl 0x134(%rsp), %edx
shll $0x18, %edx
movl 0x130(%rsp), %eax
shll $0x10, %eax
orl %eax, %edx
movl 0x12c(%rsp), %eax
shll $0x8, %eax
orl %eax, %edx
orl 0x128(%rsp), %edx
movq 0x148(%rsp), %rax
movq 0x138(%rsp), %rcx
movl %edx, 0x4(%rax,%rcx,4)
movq 0x138(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x138(%rsp)
jmp 0x1761
movq 0x178(%rsp), %rdi
callq 0x1030
movq 0x3791(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x170(%rsp), %rdx
leaq 0x186d(%rip), %rsi      # 0x30e6
movb $0x0, %al
callq 0x10e0
movq $0x0, 0x120(%rsp)
leaq 0x100(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10a0
movl $0x1, %edi
movl $0x8, %esi
callq 0x10b0
movq %rax, 0xf8(%rsp)
movq 0x148(%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)
movq 0x120(%rsp), %rax
movq 0x148(%rsp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x1912
jmp 0x1931
leaq 0x17f3(%rip), %rdi      # 0x310c
leaq 0x1751(%rip), %rsi      # 0x3071
movl $0x5c, %edx
leaq 0x174b(%rip), %rcx      # 0x3077
callq 0x1090
movq 0x148(%rsp), %rax
movq 0x120(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xd8(%rsp)
movq 0x120(%rsp), %rax
incq %rax
movq %rax, 0x120(%rsp)
movl 0xd8(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0xd, %eax
ja 0x2431
movq 0x8(%rsp), %rax
leaq 0x167f(%rip), %rcx      # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
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 0x19f4
movl 0xd0(%rsp), %eax
movl 0x100(%rsp,%rax,4), %ecx
movl 0xd4(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
jmp 0x2464
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 0x1a5a
jmp 0x1a79
leaq 0x16c0(%rip), %rdi      # 0x3121
leaq 0x1609(%rip), %rsi      # 0x3071
movl $0x70, %edx
leaq 0x1603(%rip), %rcx      # 0x3077
callq 0x1090
movq 0xf8(%rsp), %rax
movl 0xbc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0xb0(%rsp)
cmpq $0x0, 0xb0(%rsp)
je 0x1aa1
jmp 0x1ac0
leaq 0x1688(%rip), %rdi      # 0x3130
leaq 0x15c2(%rip), %rsi      # 0x3071
movl $0x72, %edx
leaq 0x15bc(%rip), %rcx      # 0x3077
callq 0x1090
movl 0xc0(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movq 0xb0(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x1adc
jmp 0x1afb
leaq 0x1658(%rip), %rdi      # 0x313b
leaq 0x1587(%rip), %rsi      # 0x3071
movl $0x73, %edx
leaq 0x1581(%rip), %rcx      # 0x3077
callq 0x1090
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)
jmp 0x2464
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 0x1b89
jmp 0x1ba8
leaq 0x1591(%rip), %rdi      # 0x3121
leaq 0x14da(%rip), %rsi      # 0x3071
movl $0x7d, %edx
leaq 0x14d4(%rip), %rcx      # 0x3077
callq 0x1090
movq 0xf8(%rsp), %rax
movl 0xa0(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x98(%rsp)
cmpq $0x0, 0x98(%rsp)
je 0x1bd0
jmp 0x1bef
leaq 0x1559(%rip), %rdi      # 0x3130
leaq 0x1493(%rip), %rsi      # 0x3071
movl $0x7f, %edx
leaq 0x148d(%rip), %rcx      # 0x3077
callq 0x1090
movl 0xa8(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movq 0x98(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x1c0b
jmp 0x1c2a
leaq 0x153d(%rip), %rdi      # 0x314f
leaq 0x1458(%rip), %rsi      # 0x3071
movl $0x80, %edx
leaq 0x1452(%rip), %rcx      # 0x3077
callq 0x1090
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)
jmp 0x2464
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)
jmp 0x2464
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)
jmp 0x2464
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 0x1d68
jmp 0x1d87
leaq 0x13f4(%rip), %rdi      # 0x3163
leaq 0x12fb(%rip), %rsi      # 0x3071
movl $0x99, %edx
leaq 0x12f5(%rip), %rcx      # 0x3077
callq 0x1090
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)
jmp 0x2464
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)
jmp 0x2464
movq 0x31c7(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1120
movq 0x31d8(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1345(%rip), %rsi      # 0x316f
movb $0x0, %al
callq 0x10e0
movl $0x0, 0x1b4(%rsp)
jmp 0x2469
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 0x1ef8
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 0x1140
movq %rax, 0xf8(%rsp)
cmpq $0x0, 0xf8(%rsp)
je 0x1ed7
jmp 0x1ef6
leaq 0x12a0(%rip), %rdi      # 0x317e
leaq 0x118c(%rip), %rsi      # 0x3071
movl $0xb3, %edx
leaq 0x1186(%rip), %rcx      # 0x3077
callq 0x1090
jmp 0x1f24
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 0x10b0
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x1f48
jmp 0x1f67
leaq 0x122c(%rip), %rdi      # 0x317b
leaq 0x111b(%rip), %rsi      # 0x3071
movl $0xb9, %edx
leaq 0x1115(%rip), %rcx      # 0x3077
callq 0x1090
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)
jmp 0x2464
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 0x1fc8
jmp 0x1fe7
leaq 0x1152(%rip), %rdi      # 0x3121
leaq 0x109b(%rip), %rsi      # 0x3071
movl $0xc3, %edx
leaq 0x1095(%rip), %rcx      # 0x3077
callq 0x1090
cmpl $0x0, 0x48(%rsp)
je 0x1ff0
jmp 0x200f
leaq 0x1193(%rip), %rdi      # 0x318a
leaq 0x1073(%rip), %rsi      # 0x3071
movl $0xc4, %edx
leaq 0x106d(%rip), %rcx      # 0x3077
callq 0x1090
movq 0xf8(%rsp), %rax
movl 0x48(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x2024
jmp 0x2043
leaq 0x1166(%rip), %rdi      # 0x3191
leaq 0x103f(%rip), %rsi      # 0x3071
movl $0xc5, %edx
leaq 0x1039(%rip), %rcx      # 0x3077
callq 0x1090
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 0x2135
cmpl $0x0, 0xdc(%rsp)
jne 0x20a8
movl $0x20, %eax
movl %eax, 0x4(%rsp)
jmp 0x20b5
movl 0xdc(%rsp), %eax
shll %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x44(%rsp)
movq 0xe8(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x1140
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 0x10a0
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)
jmp 0x2464
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl $0xff, 0x100(%rsp,%rax,4)
ja 0x2178
jmp 0x2197
leaq 0x1021(%rip), %rdi      # 0x31a0
leaq 0xeeb(%rip), %rsi       # 0x3071
movl $0xd5, %edx
leaq 0xee5(%rip), %rcx       # 0x3077
callq 0x1090
testb $0x1, 0x197(%rsp)
je 0x21bc
cmpq $0x0, 0x198(%rsp)
je 0x21bc
movq 0x198(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x21cc
movl 0x40(%rsp), %eax
movl 0x100(%rsp,%rax,4), %edi
callq 0x1040
jmp 0x2464
movl 0xd8(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x3c(%rsp)
cmpq $0x0, 0x198(%rsp)
je 0x21fa
movq 0x198(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2214
movq 0x2dd7(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1120
callq 0x10d0
movl %eax, 0x38(%rsp)
jmp 0x2232
movq 0x198(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x198(%rsp)
movzbl (%rax), %eax
movl %eax, 0x38(%rsp)
cmpl $-0x1, 0x38(%rsp)
jne 0x224a
movl 0x3c(%rsp), %eax
movl $0xffffffff, 0x100(%rsp,%rax,4) # imm = 0xFFFFFFFF
jmp 0x228c
xorl %eax, %eax
cmpl 0x38(%rsp), %eax
jg 0x225e
cmpl $0xff, 0x38(%rsp)
jg 0x225e
jmp 0x227d
leaq 0xf49(%rip), %rdi       # 0x31ae
leaq 0xe05(%rip), %rsi       # 0x3071
movl $0xe8, %edx
leaq 0xdff(%rip), %rcx       # 0x3077
callq 0x1090
movl 0x38(%rsp), %ecx
movl 0x3c(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
jmp 0x2464
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 0x23ea
movl 0x2c(%rsp), %eax
cmpq 0xf0(%rsp), %rax
jae 0x22ec
jmp 0x230b
leaq 0xe2e(%rip), %rdi       # 0x3121
leaq 0xd77(%rip), %rsi       # 0x3071
movl $0xf3, %edx
leaq 0xd71(%rip), %rcx       # 0x3077
callq 0x1090
movq 0xf8(%rsp), %rax
movl 0x2c(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x2320
jmp 0x233f
leaq 0xe6a(%rip), %rdi       # 0x3191
leaq 0xd43(%rip), %rsi       # 0x3071
movl $0xf4, %edx
leaq 0xd3d(%rip), %rcx       # 0x3077
callq 0x1090
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 0x1110
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2378
jmp 0x2397
leaq 0xe44(%rip), %rdi       # 0x31c3
leaq 0xceb(%rip), %rsi       # 0x3071
movl $0xf7, %edx
leaq 0xce5(%rip), %rcx       # 0x3077
callq 0x1090
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 0x1100
movq 0x148(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x20(%rsp), %rcx
movq 0xf8(%rsp), %rax
movq %rcx, (%rax)
movl 0x30(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movq %rax, 0x120(%rsp)
jmp 0x2464
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)
jmp 0x2464
movq 0x2ba0(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1120
movq 0x2bb1(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0xd8(%rsp), %edx
leaq 0xd7e(%rip), %rsi       # 0x31d6
movb $0x0, %al
callq 0x10e0
callq 0x1050
jmp 0x18f9
movl 0x1b4(%rsp), %eax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
nopl (%rax,%rax)