// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_verbose.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 *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;
    int arrayamend0 = 0;
    bool modified[8] = {0};
    while (1) {
        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];
                    if (!modified[a] && reg[a] != 0) {
                        fflush(stdout);
                        fprintf(stderr, "<<<REG[%u] modified>>>", (unsigned int)a);
                        modified[a] = true;
                    }
                }
                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]];
                if (!modified[a] && reg[a] != 0) {
                    fflush(stdout);
                    fprintf(stderr, "<<<REG[%u] modified>>>", (unsigned int)a);
                    modified[a] = true;
                }
                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);
                if (i == 0 && ai->data[reg[b]] != reg[c]) {
                    ++arrayamend0;
                }
                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];
                if (!modified[a] && reg[a] != 0) {
                    fflush(stdout);
                    fprintf(stderr, "<<<REG[%u] modified>>>", (unsigned int)a);
                    modified[a] = true;
                }
                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];
                if (!modified[a] && reg[a] != 0) {
                    fflush(stdout);
                    fprintf(stderr, "<<<REG[%u] modified>>>", (unsigned int)a);
                    modified[a] = true;
                }
                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];
                if (!modified[a] && reg[a] != 0) {
                    fflush(stdout);
                    fprintf(stderr, "<<<REG[%u] modified>>>", (unsigned int)a);
                    modified[a] = true;
                }
                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]);
                if (!modified[a] && reg[a] != 0) {
                    fflush(stdout);
                    fprintf(stderr, "<<<REG[%u] modified>>>", (unsigned int)a);
                    modified[a] = true;
                }
                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;
                if (!modified[b] && reg[b] != 0) {
                    fflush(stdout);
                    fprintf(stderr, "<<<REG[%u] modified>>>", (unsigned int)b);
                    modified[b] = true;
                }
                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 (arrayamend0 > 0) {
                    fflush(stdout);
                    fprintf(stderr, "<<<%d Array Amendment on #0>>>", arrayamend0);
                    arrayamend0 = 0;
                }
                putchar(reg[c]);
                break;
            }
        case 11: /* 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;
                }
                if (!modified[c]) {
                    fflush(stdout);
                    fprintf(stderr, "<<<REG[%u] modified>>>", (unsigned int)c);
                    modified[c] = true;
                }
                break;
            }
        case 12: /* Load Program */
            {
                uint32_t b = (op >> 3) & 7;
                uint32_t c = op & 7;
                uint32_t i = reg[b];
                if (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;
                    fflush(stdout);
                    fputs("<<<Load Array #0>>>", stderr);
                }
                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;
                if (!modified[a] && reg[a] != 0) {
                    fflush(stdout);
                    fprintf(stderr, "<<<REG[%u] modified>>>", (unsigned int)a);
                    modified[a] = true;
                }
                break;
            }
        default:
            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 0x12ae
movq 0x3d76(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x188(%rsp), %rax
movq (%rax), %rdx
leaq 0x1da5(%rip), %rsi      # 0x303c
movb $0x0, %al
callq 0x10d0
movl $0x1, 0x194(%rsp)
jmp 0x2568
movq $0x0, 0x180(%rsp)
movq $0x0, 0x178(%rsp)
movq 0x188(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x1d76(%rip), %rsi      # 0x304f
callq 0x1140
movq %rax, 0x170(%rsp)
cmpq $0x0, 0x170(%rsp)
je 0x12f3
jmp 0x1312
leaq 0x1d58(%rip), %rdi      # 0x3052
leaq 0x1d5b(%rip), %rsi      # 0x305c
movl $0x15, %edx
leaq 0x1d5d(%rip), %rcx      # 0x306a
callq 0x1080
movq 0x170(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1120
movl %eax, 0x16c(%rsp)
cmpl $0x0, 0x16c(%rsp)
jne 0x133b
jmp 0x135a
leaq 0x1d3f(%rip), %rdi      # 0x3081
leaq 0x1d13(%rip), %rsi      # 0x305c
movl $0x17, %edx
leaq 0x1d15(%rip), %rcx      # 0x306a
callq 0x1080
movq 0x170(%rsp), %rdi
callq 0x10e0
movq %rax, 0x160(%rsp)
cmpq $0x0, 0x160(%rsp)
jl 0x137c
jmp 0x139b
leaq 0x1d0e(%rip), %rdi      # 0x3091
leaq 0x1cd2(%rip), %rsi      # 0x305c
movl $0x19, %edx
leaq 0x1cd4(%rip), %rcx      # 0x306a
callq 0x1080
movq 0x160(%rsp), %rax
movq %rax, 0x178(%rsp)
movq 0x170(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1120
movl %eax, 0x16c(%rsp)
cmpl $0x0, 0x16c(%rsp)
jne 0x13d1
jmp 0x13f0
leaq 0x1ca9(%rip), %rdi      # 0x3081
leaq 0x1c7d(%rip), %rsi      # 0x305c
movl $0x1c, %edx
leaq 0x1c7f(%rip), %rcx      # 0x306a
callq 0x1080
movq 0x178(%rsp), %rdi
callq 0x1100
movq %rax, 0x180(%rsp)
cmpq $0x0, 0x180(%rsp)
je 0x1412
jmp 0x1431
leaq 0x1c82(%rip), %rdi      # 0x309b
leaq 0x1c3c(%rip), %rsi      # 0x305c
movl $0x1e, %edx
leaq 0x1c3e(%rip), %rcx      # 0x306a
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 0x146f
jmp 0x148e
leaq 0x1c38(%rip), %rdi      # 0x30ae
leaq 0x1bdf(%rip), %rsi      # 0x305c
movl $0x20, %edx
leaq 0x1be1(%rip), %rcx      # 0x306a
callq 0x1080
movq 0x170(%rsp), %rdi
callq 0x1070
movq 0x178(%rsp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x14af
jmp 0x14ce
leaq 0x1c0e(%rip), %rdi      # 0x30c4
leaq 0x1b9f(%rip), %rsi      # 0x305c
movl $0x23, %edx
leaq 0x1ba1(%rip), %rcx      # 0x306a
callq 0x1080
movq 0x178(%rsp), %rdi
addq $0x4, %rdi
callq 0x1100
movq %rax, 0x150(%rsp)
cmpq $0x0, 0x150(%rsp)
je 0x14f4
jmp 0x1513
leaq 0x1ba3(%rip), %rdi      # 0x309e
leaq 0x1b5a(%rip), %rsi      # 0x305c
movl $0x25, %edx
leaq 0x1b5c(%rip), %rcx      # 0x306a
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 0x1639
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 0x1547
movq 0x180(%rsp), %rdi
callq 0x1030
movq 0x39ab(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x178(%rsp), %rdx
leaq 0x1a7a(%rip), %rsi      # 0x30d9
movb $0x0, %al
callq 0x10d0
movq $0x0, 0x128(%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 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)
leaq 0xd0(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10a0
movq 0x150(%rsp), %rax
movq 0x128(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0xcc(%rsp)
movq 0x128(%rsp), %rax
incq %rax
movq %rax, 0x128(%rsp)
movl 0xcc(%rsp), %eax
shrl $0x1c, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0xd, %eax
ja 0x253f
movq 0x8(%rsp), %rax
leaq 0x18b2(%rip), %rcx      # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0xcc(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0xc8(%rsp)
movl 0xcc(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0xc4(%rsp)
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0xc0(%rsp)
movl 0xc0(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x1822
movl 0xc4(%rsp), %eax
movl 0x100(%rsp,%rax,4), %ecx
movl 0xc8(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movl 0xc8(%rsp), %eax
testb $0x1, 0xd0(%rsp,%rax)
jne 0x1820
movl 0xc8(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x1820
movq 0x37ee(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x37ff(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0xc8(%rsp), %edx
leaq 0x18f5(%rip), %rsi      # 0x30ff
movb $0x0, %al
callq 0x10d0
movl 0xc8(%rsp), %eax
movb $0x1, 0xd0(%rsp,%rax)
jmp 0x1822
jmp 0x2563
movl 0xcc(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0xbc(%rsp)
movl 0xcc(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0xb8(%rsp)
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0xb4(%rsp)
movl 0xb8(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0xb0(%rsp)
movl 0xb0(%rsp), %eax
cmpq 0xf0(%rsp), %rax
jae 0x1888
jmp 0x18a7
leaq 0x1887(%rip), %rdi      # 0x3116
leaq 0x17c6(%rip), %rsi      # 0x305c
movl $0x55, %edx
leaq 0x17c8(%rip), %rcx      # 0x306a
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0xb0(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0xa8(%rsp)
cmpq $0x0, 0xa8(%rsp)
je 0x18cf
jmp 0x18ee
leaq 0x184f(%rip), %rdi      # 0x3125
leaq 0x177f(%rip), %rsi      # 0x305c
movl $0x57, %edx
leaq 0x1781(%rip), %rcx      # 0x306a
callq 0x1080
movl 0xb4(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movq 0xa8(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x190a
jmp 0x1929
leaq 0x181f(%rip), %rdi      # 0x3130
leaq 0x1744(%rip), %rsi      # 0x305c
movl $0x58, %edx
leaq 0x1746(%rip), %rcx      # 0x306a
callq 0x1080
movq 0xa8(%rsp), %rax
movl 0xb4(%rsp), %ecx
movl 0x100(%rsp,%rcx,4), %ecx
movl 0x4(%rax,%rcx,4), %ecx
movl 0xbc(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movl 0xbc(%rsp), %eax
testb $0x1, 0xd0(%rsp,%rax)
jne 0x19b0
movl 0xbc(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x19b0
movq 0x365e(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x366f(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0xbc(%rsp), %edx
leaq 0x1765(%rip), %rsi      # 0x30ff
movb $0x0, %al
callq 0x10d0
movl 0xbc(%rsp), %eax
movb $0x1, 0xd0(%rsp,%rax)
jmp 0x2563
movl 0xcc(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0xa4(%rsp)
movl 0xcc(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0xa0(%rsp)
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x9c(%rsp)
movl 0xa4(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0x98(%rsp)
movl 0x98(%rsp), %eax
cmpq 0xf0(%rsp), %rax
jae 0x1a16
jmp 0x1a35
leaq 0x16f9(%rip), %rdi      # 0x3116
leaq 0x1638(%rip), %rsi      # 0x305c
movl $0x67, %edx
leaq 0x163a(%rip), %rcx      # 0x306a
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0x98(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x90(%rsp)
cmpq $0x0, 0x90(%rsp)
je 0x1a5d
jmp 0x1a7c
leaq 0x16c1(%rip), %rdi      # 0x3125
leaq 0x15f1(%rip), %rsi      # 0x305c
movl $0x69, %edx
leaq 0x15f3(%rip), %rcx      # 0x306a
callq 0x1080
movl 0xa0(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movq 0x90(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x1a98
jmp 0x1ab7
leaq 0x16a5(%rip), %rdi      # 0x3144
leaq 0x15b6(%rip), %rsi      # 0x305c
movl $0x6a, %edx
leaq 0x15b8(%rip), %rcx      # 0x306a
callq 0x1080
cmpl $0x0, 0x98(%rsp)
jne 0x1afc
movq 0x90(%rsp), %rax
movl 0xa0(%rsp), %ecx
movl 0x100(%rsp,%rcx,4), %ecx
movl 0x4(%rax,%rcx,4), %eax
movl 0x9c(%rsp), %ecx
cmpl 0x100(%rsp,%rcx,4), %eax
je 0x1afc
movl 0xd8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd8(%rsp)
movl 0x9c(%rsp), %eax
movl 0x100(%rsp,%rax,4), %edx
movq 0x90(%rsp), %rax
movl 0xa0(%rsp), %ecx
movl 0x100(%rsp,%rcx,4), %ecx
movl %edx, 0x4(%rax,%rcx,4)
jmp 0x2563
movl 0xcc(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x8c(%rsp)
movl 0xcc(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x88(%rsp)
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x84(%rsp)
movl 0x88(%rsp), %eax
movl 0x100(%rsp,%rax,4), %ecx
movl 0x84(%rsp), %eax
addl 0x100(%rsp,%rax,4), %ecx
movl 0x8c(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movl 0x8c(%rsp), %eax
testb $0x1, 0xd0(%rsp,%rax)
jne 0x1beb
movl 0x8c(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x1beb
movq 0x3423(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x3434(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0x8c(%rsp), %edx
leaq 0x152a(%rip), %rsi      # 0x30ff
movb $0x0, %al
callq 0x10d0
movl 0x8c(%rsp), %eax
movb $0x1, 0xd0(%rsp,%rax)
jmp 0x2563
movl 0xcc(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x80(%rsp)
movl 0xcc(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x7c(%rsp)
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x78(%rsp)
movl 0x7c(%rsp), %eax
movl 0x100(%rsp,%rax,4), %ecx
movl 0x78(%rsp), %eax
imull 0x100(%rsp,%rax,4), %ecx
movl 0x80(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movl 0x80(%rsp), %eax
testb $0x1, 0xd0(%rsp,%rax)
jne 0x1ca7
movl 0x80(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x1ca7
movq 0x3367(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x3378(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0x80(%rsp), %edx
leaq 0x146e(%rip), %rsi      # 0x30ff
movb $0x0, %al
callq 0x10d0
movl 0x80(%rsp), %eax
movb $0x1, 0xd0(%rsp,%rax)
jmp 0x2563
movl 0xcc(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x74(%rsp)
movl 0xcc(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x70(%rsp)
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x1cec
jmp 0x1d0b
leaq 0x1465(%rip), %rdi      # 0x3158
leaq 0x1362(%rip), %rsi      # 0x305c
movl $0x90, %edx
leaq 0x1364(%rip), %rcx      # 0x306a
callq 0x1080
movl 0x70(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl 0x6c(%rsp), %ecx
xorl %edx, %edx
divl 0x100(%rsp,%rcx,4)
movl %eax, %ecx
movl 0x74(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movl 0x74(%rsp), %eax
testb $0x1, 0xd0(%rsp,%rax)
jne 0x1d83
movl 0x74(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x1d83
movq 0x3285(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x3296(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0x74(%rsp), %edx
leaq 0x138f(%rip), %rsi      # 0x30ff
movb $0x0, %al
callq 0x10d0
movl 0x74(%rsp), %eax
movb $0x1, 0xd0(%rsp,%rax)
jmp 0x2563
movl 0xcc(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x68(%rsp)
movl 0xcc(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x64(%rsp)
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x60(%rsp)
movl 0x64(%rsp), %eax
movl 0x100(%rsp,%rax,4), %ecx
movl 0x60(%rsp), %eax
andl 0x100(%rsp,%rax,4), %ecx
xorl $-0x1, %ecx
movl 0x68(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movl 0x68(%rsp), %eax
testb $0x1, 0xd0(%rsp,%rax)
jne 0x1e2f
movl 0x68(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x1e2f
movq 0x31d9(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x31ea(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0x68(%rsp), %edx
leaq 0x12e3(%rip), %rsi      # 0x30ff
movb $0x0, %al
callq 0x10d0
movl 0x68(%rsp), %eax
movb $0x1, 0xd0(%rsp,%rax)
jmp 0x2563
movq 0x319d(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x31ae(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1310(%rip), %rsi      # 0x3164
movb $0x0, %al
callq 0x10d0
movl $0x0, 0x194(%rsp)
jmp 0x2568
movl 0xcc(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x5c(%rsp)
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0x54(%rsp)
movl $0x0, 0x50(%rsp)
movq 0xe0(%rsp), %rax
cmpq 0xe8(%rsp), %rax
jne 0x1f22
movq 0xf0(%rsp), %rax
movl %eax, 0x50(%rsp)
movq 0xf0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf0(%rsp)
movq 0xf8(%rsp), %rdi
movq 0xf0(%rsp), %rsi
shlq $0x3, %rsi
callq 0x1130
movq %rax, 0xf8(%rsp)
cmpq $0x0, 0xf8(%rsp)
je 0x1f01
jmp 0x1f20
leaq 0x126b(%rip), %rdi      # 0x3173
leaq 0x114d(%rip), %rsi      # 0x305c
movl $0xb4, %edx
leaq 0x114f(%rip), %rcx      # 0x306a
callq 0x1080
jmp 0x1f4e
movq 0xe0(%rsp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, 0xe0(%rsp)
movl -0x4(%rax), %eax
movl %eax, 0x50(%rsp)
movq 0xe0(%rsp), %rax
movl $0x0, (%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
movl $0x4, %esi
callq 0x10b0
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x1f72
jmp 0x1f91
leaq 0x11f7(%rip), %rdi      # 0x3170
leaq 0x10dc(%rip), %rsi      # 0x305c
movl $0xba, %edx
leaq 0x10de(%rip), %rcx      # 0x306a
callq 0x1080
movl 0x54(%rsp), %ecx
movq 0x48(%rsp), %rax
movl %ecx, (%rax)
movq 0x48(%rsp), %rdx
movq 0xf8(%rsp), %rax
movl 0x50(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x50(%rsp), %ecx
movl 0x5c(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movl 0x5c(%rsp), %eax
testb $0x1, 0xd0(%rsp,%rax)
jne 0x2013
movl 0x5c(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x2013
movq 0x2ff5(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x3006(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0x5c(%rsp), %edx
leaq 0x10ff(%rip), %rsi      # 0x30ff
movb $0x0, %al
callq 0x10d0
movl 0x5c(%rsp), %eax
movb $0x1, 0xd0(%rsp,%rax)
jmp 0x2563
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpq 0xf0(%rsp), %rax
jae 0x2045
jmp 0x2064
leaq 0x10ca(%rip), %rdi      # 0x3116
leaq 0x1009(%rip), %rsi      # 0x305c
movl $0xc9, %edx
leaq 0x100b(%rip), %rcx      # 0x306a
callq 0x1080
cmpl $0x0, 0x40(%rsp)
je 0x206d
jmp 0x208c
leaq 0x110b(%rip), %rdi      # 0x317f
leaq 0xfe1(%rip), %rsi       # 0x305c
movl $0xca, %edx
leaq 0xfe3(%rip), %rcx       # 0x306a
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0x40(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x20a1
jmp 0x20c0
leaq 0x10de(%rip), %rdi      # 0x3186
leaq 0xfad(%rip), %rsi       # 0x305c
movl $0xcb, %edx
leaq 0xfaf(%rip), %rcx       # 0x306a
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0x40(%rsp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq 0xf8(%rsp), %rax
movl 0x40(%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 0x21b2
cmpl $0x0, 0xdc(%rsp)
jne 0x2125
movl $0x20, %eax
movl %eax, 0x4(%rsp)
jmp 0x2132
movl 0xdc(%rsp), %eax
shll %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x3c(%rsp)
movq 0xe8(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x1130
movq %rax, 0xe8(%rsp)
movq 0xe8(%rsp), %rdi
movl 0xdc(%rsp), %eax
shlq $0x2, %rax
addq %rax, %rdi
movl 0x3c(%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 0x3c(%rsp), %eax
movl %eax, 0xdc(%rsp)
movl 0x40(%rsp), %ecx
movq 0xe0(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0xe0(%rsp)
movl %ecx, (%rax)
jmp 0x2563
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl $0xff, 0x100(%rsp,%rax,4)
ja 0x21f5
jmp 0x2214
leaq 0xf99(%rip), %rdi       # 0x3195
leaq 0xe59(%rip), %rsi       # 0x305c
movl $0xdb, %edx
leaq 0xe5b(%rip), %rcx       # 0x306a
callq 0x1080
cmpl $0x0, 0xd8(%rsp)
jle 0x2257
movq 0x2db3(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x2dc4(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0xd8(%rsp), %edx
leaq 0xf5e(%rip), %rsi       # 0x31a3
movb $0x0, %al
callq 0x10d0
movl $0x0, 0xd8(%rsp)
movl 0x38(%rsp), %eax
movl 0x100(%rsp,%rax,4), %edi
callq 0x1040
jmp 0x2563
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x34(%rsp)
movq 0x2d57(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
callq 0x10c0
movl %eax, 0x30(%rsp)
cmpl $-0x1, 0x30(%rsp)
jne 0x22aa
movl 0x34(%rsp), %eax
movl $0xffffffff, 0x100(%rsp,%rax,4) # imm = 0xFFFFFFFF
jmp 0x22ec
xorl %eax, %eax
cmpl 0x30(%rsp), %eax
jg 0x22be
cmpl $0xff, 0x30(%rsp)
jg 0x22be
jmp 0x22dd
leaq 0xefd(%rip), %rdi       # 0x31c2
leaq 0xd90(%rip), %rsi       # 0x305c
movl $0xec, %edx
leaq 0xd92(%rip), %rcx       # 0x306a
callq 0x1080
movl 0x30(%rsp), %ecx
movl 0x34(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movl 0x34(%rsp), %eax
testb $0x1, 0xd0(%rsp,%rax)
jne 0x2331
movq 0x2cd7(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x2ce8(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0x34(%rsp), %edx
leaq 0xde1(%rip), %rsi       # 0x30ff
movb $0x0, %al
callq 0x10d0
movl 0x34(%rsp), %eax
movb $0x1, 0xd0(%rsp,%rax)
jmp 0x2563
movl 0xcc(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x2c(%rsp)
movl 0xcc(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x24a2
movl 0x24(%rsp), %eax
cmpq 0xf0(%rsp), %rax
jae 0x237f
jmp 0x239e
leaq 0xd90(%rip), %rdi       # 0x3116
leaq 0xccf(%rip), %rsi       # 0x305c
movl $0xfc, %edx
leaq 0xcd1(%rip), %rcx       # 0x306a
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0x24(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x23b3
jmp 0x23d2
leaq 0xdcc(%rip), %rdi       # 0x3186
leaq 0xc9b(%rip), %rsi       # 0x305c
movl $0xfd, %edx
leaq 0xc9d(%rip), %rcx       # 0x306a
callq 0x1080
movq 0xf8(%rsp), %rax
movl 0x24(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x1100
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x240b
jmp 0x242a
leaq 0xdc5(%rip), %rdi       # 0x31d7
leaq 0xc43(%rip), %rsi       # 0x305c
movl $0x100, %edx            # imm = 0x100
leaq 0xc45(%rip), %rcx       # 0x306a
callq 0x1080
movq 0x18(%rsp), %rdi
movq 0xf8(%rsp), %rax
movl 0x24(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x10f0
movq 0x150(%rsp), %rdi
callq 0x1030
movq 0x18(%rsp), %rax
movq %rax, 0x150(%rsp)
movq 0x18(%rsp), %rcx
movq 0xf8(%rsp), %rax
movq %rcx, (%rax)
movq 0x2b54(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x2b65(%rip), %rax      # 0x4ff8
movq (%rax), %rsi
leaq 0xd4d(%rip), %rdi       # 0x31ea
callq 0x1090
movl 0x28(%rsp), %eax
movl 0x100(%rsp,%rax,4), %eax
movq %rax, 0x128(%rsp)
jmp 0x2563
movl 0xcc(%rsp), %eax
shrl $0x19, %eax
andl $0x7, %eax
movl %eax, 0x14(%rsp)
movl 0xcc(%rsp), %eax
andl $0x1ffffff, %eax        # imm = 0x1FFFFFF
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %eax
movl %ecx, 0x100(%rsp,%rax,4)
movl 0x14(%rsp), %eax
testb $0x1, 0xd0(%rsp,%rax)
jne 0x253d
movl 0x14(%rsp), %eax
cmpl $0x0, 0x100(%rsp,%rax,4)
je 0x253d
movq 0x2acb(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1110
movq 0x2adc(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0x14(%rsp), %edx
leaq 0xbd5(%rip), %rsi       # 0x30ff
movb $0x0, %al
callq 0x10d0
movl 0x14(%rsp), %eax
movb $0x1, 0xd0(%rsp,%rax)
jmp 0x2563
movq 0x2ab2(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl 0xcc(%rsp), %edx
leaq 0xca7(%rip), %rsi       # 0x31fe
movb $0x0, %al
callq 0x10d0
callq 0x1050
jmp 0x16fe
movl 0x194(%rsp), %eax
addq $0x198, %rsp            # imm = 0x198
retq