// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x1, %edi
jg 0x1292
movq 0x2d82(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rsi), %rdx
leaq 0xdb9(%rip), %rsi       # 0x203c
xorl %eax, %eax
callq 0x10d0
pushq $0x1
popq %rax
jmp 0x198e
movq 0x8(%rsi), %rdi
leaq 0xdb2(%rip), %rsi       # 0x204f
callq 0x1140
testq %rax, %rax
je 0x1bb8
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1120
testl %eax, %eax
jne 0x1bd4
movq %r14, %rdi
callq 0x10e0
testq %rax, %rax
js 0x1bf0
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1120
testl %eax, %eax
jne 0x1c0c
movq %r15, %rdi
callq 0x1100
testq %rax, %rax
je 0x1c28
movq %rax, %r12
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %rsi, 0x40(%rsp)
movq %r15, %rdx
movq %r14, %rcx
callq 0x1060
cmpq %r15, %rax
jne 0x1c44
movq %r14, %rdi
callq 0x1070
testb $0x3, %r15b
jne 0x1c60
leaq 0x4(%r15), %rdi
callq 0x1100
testq %rax, %rax
je 0x1c7c
movq %rax, %r14
movq %r15, %rax
shrq $0x2, %rax
movl %eax, (%r14)
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1366
movl (%r12,%rcx,4), %edx
bswapl %edx
movl %edx, 0x4(%r14,%rcx,4)
incq %rcx
jmp 0x1351
movq %r12, %rdi
callq 0x1030
movq 0x2c83(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd5a(%rip), %rsi       # 0x20d9
movq %r15, %rdx
xorl %eax, %eax
callq 0x10d0
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
pushq $0x8
popq %rsi
pushq $0x1
popq %rdi
callq 0x10b0
movq %rax, 0x30(%rsp)
movq %r14, (%rax)
andq $0x0, (%rsp)
leaq 0xc4f(%rip), %rdi       # 0x2004
movl $0x0, 0xc(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x38(%rsp)
xorl %r8d, %r8d
xorl %ebx, %ebx
movl 0x4(%r14,%rbx,4), %r13d
movl %r13d, %eax
shrl $0x1c, %eax
cmpl $0xd, %eax
ja 0x1afd
incq %rbx
movslq (%rdi,%rax,4), %rax
addq %rdi, %rax
jmpq *%rax
movl %r13d, %eax
andl $0x7, %eax
cmpl $0x0, 0x10(%rsp,%rax,4)
je 0x13d4
movl %r13d, %ebp
shrl $0x6, %ebp
andl $0x7, %ebp
shrl %r13d
andl $0x1c, %r13d
movl 0x10(%rsp,%r13), %eax
jmp 0x1675
movl %r13d, %ebp
shrl $0x19, %ebp
andl $0x7, %ebp
andl $0x1ffffff, %r13d       # imm = 0x1FFFFFF
movl %r13d, 0x10(%rsp,%rbp,4)
je 0x13d4
cmpb $0x0, (%rsp,%rbp)
jne 0x13d4
jmp 0x1780
andl $0x7, %r13d
movl 0x10(%rsp,%r13,4), %ebp
cmpl $0x100, %ebp            # imm = 0x100
jae 0x199d
movq %r8, %r15
cmpl $0x0, 0xc(%rsp)
jg 0x1929
movl %ebp, %edi
callq 0x1040
movq %r15, %r8
leaq 0xb93(%rip), %rdi       # 0x2004
jmp 0x13d4
movl %r13d, %ebp
shrl $0x6, %ebp
movl %r13d, %eax
andl $0x7, %eax
shrl %r13d
andl $0x1c, %r13d
movl 0x10(%rsp,%rax,4), %eax
imull 0x10(%rsp,%r13), %eax
jmp 0x1672
movl %r13d, %eax
shrl %eax
andl $0x1c, %eax
movl 0x10(%rsp,%rax), %eax
testq %rax, %rax
jne 0x1895
andl $0x7, %r13d
movl 0x10(%rsp,%r13,4), %ebx
jmp 0x13d4
andl $0x7, %r13d
movl 0x10(%rsp,%r13,4), %ebp
cmpq %rbp, 0x40(%rsp)
jbe 0x1a89
testl %ebp, %ebp
je 0x1a4b
movq 0x30(%rsp), %r12
movq (%r12,%rbp,8), %rdi
testq %rdi, %rdi
je 0x1aa8
movq %r8, %r15
callq 0x1030
movq %r15, %r8
andq $0x0, (%r12,%rbp,8)
movq 0x38(%rsp), %rsi
movq %rsi, %r13
subq %r15, %r13
movq %r13, %rax
sarq $0x2, %rax
movq 0x48(%rsp), %rdx
movl %edx, %ecx
cmpq %rcx, %rax
jne 0x1567
movq %r14, 0x38(%rsp)
movq %rdx, %r14
leal (%rdx,%rdx), %r12d
testl %r14d, %r14d
pushq $0x20
popq %rax
cmovel %eax, %r12d
leaq (,%r12,4), %rsi
movq %r8, %rdi
callq 0x1130
movq %rax, %r15
addq %rax, %r13
movl %r12d, %edx
subl %r14d, %edx
movq 0x38(%rsp), %r14
shlq $0x2, %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x10a0
movq %r15, %r8
movq %r12, 0x48(%rsp)
movq %r13, %rsi
leaq 0xa96(%rip), %rdi       # 0x2004
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rsp)
jmp 0x13d4
movq %r8, %r15
movq 0x2a50(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1110
callq 0x10c0
pushq $-0x1
popq %rcx
cmpl $-0x1, %eax
je 0x15aa
movl %eax, %ecx
cmpl $0x100, %eax            # imm = 0x100
jae 0x1b7a
andl $0x7, %r13d
movl %ecx, 0x10(%rsp,%r13,4)
cmpb $0x0, (%rsp,%r13)
movq %r15, %r8
leaq 0xa42(%rip), %rdi       # 0x2004
jne 0x13d4
jmp 0x183c
movl %r13d, %eax
shrl $0x4, %eax
andl $0x1c, %eax
movl 0x10(%rsp,%rax), %edx
cmpq %rdx, 0x40(%rsp)
jbe 0x19db
movq 0x30(%rsp), %rax
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x1a13
movl %r13d, %ecx
shrl $0x3, %ecx
andl $0x7, %ecx
movl 0x10(%rsp,%rcx,4), %ecx
cmpl (%rax), %ecx
jae 0x1ac7
andl $0x7, %r13d
movl %r13d, %esi
testq %rdx, %rdx
je 0x187a
movl 0x10(%rsp,%rsi,4), %edx
jmp 0x188c
movl %r13d, %eax
andl $0x7, %eax
movl 0x10(%rsp,%rax,4), %ebp
movq %r8, %r15
movq 0x38(%rsp), %rax
cmpq %r8, %rax
je 0x17bf
movl -0x4(%rax), %r12d
andl $0x0, -0x4(%rax)
addq $-0x4, %rax
movq %rax, 0x38(%rsp)
jmp 0x17ef
movl %r13d, %ebp
shrl $0x6, %ebp
movl %r13d, %eax
andl $0x7, %eax
shrl %r13d
andl $0x1c, %r13d
movl 0x10(%rsp,%rax,4), %eax
addl 0x10(%rsp,%r13), %eax
andl $0x7, %ebp
movl %eax, 0x10(%rsp,%rbp,4)
cmpb $0x0, (%rsp,%rbp)
jne 0x13d4
testl %eax, %eax
je 0x13d4
jmp 0x1780
movl %r13d, %eax
shrl %eax
andl $0x1c, %eax
movl 0x10(%rsp,%rax), %eax
cmpq %rax, 0x40(%rsp)
jbe 0x1a2f
movq 0x30(%rsp), %rcx
movq (%rcx,%rax,8), %rax
testq %rax, %rax
je 0x19f7
movl %r13d, %ecx
andl $0x7, %ecx
movl 0x10(%rsp,%rcx,4), %ecx
cmpl (%rax), %ecx
jae 0x1ae0
shrl $0x6, %r13d
andl $0x7, %r13d
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp,%r13,4)
cmpb $0x0, (%rsp,%r13)
jne 0x13d4
testl %eax, %eax
je 0x13d4
movq 0x28e2(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movq %r8, %r15
jmp 0x1846
movl %r13d, %eax
andl $0x7, %eax
movl 0x10(%rsp,%rax,4), %esi
testl %esi, %esi
je 0x19bc
movl %r13d, %ebp
shrl $0x6, %ebp
andl $0x7, %ebp
shrl %r13d
andl $0x1c, %r13d
movl 0x10(%rsp,%r13), %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %eax, 0x10(%rsp,%rbp,4)
cmpb $0x0, (%rsp,%rbp)
jne 0x13d4
cmpl %ecx, %esi
ja 0x13d4
jmp 0x1780
movl %r13d, %ebp
shrl $0x6, %ebp
andl $0x7, %ebp
movl %r13d, %eax
andl $0x7, %eax
shrl %r13d
andl $0x1c, %r13d
movl 0x10(%rsp,%rax,4), %eax
andl 0x10(%rsp,%r13), %eax
movl %eax, %ecx
notl %ecx
movl %ecx, 0x10(%rsp,%rbp,4)
cmpb $0x0, (%rsp,%rbp)
jne 0x13d4
cmpl $-0x1, %eax
je 0x13d4
movq 0x2851(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movq %r8, %r15
callq 0x1110
movq 0x285f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x95c(%rip), %rsi       # 0x20ff
movl %ebp, %edx
xorl %eax, %eax
callq 0x10d0
leaq 0x851(%rip), %rdi       # 0x2004
movq %r15, %r8
movb $0x1, (%rsp,%rbp)
jmp 0x13d4
movq 0x40(%rsp), %r12
leaq 0x8(,%r12,8), %rsi
movq 0x30(%rsp), %rdi
callq 0x1130
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x1b99
movq %r12, %rax
incq %rax
movq %rax, 0x40(%rsp)
leal 0x1(%rbp), %edi
pushq $0x4
popq %rsi
callq 0x10b0
testq %rax, %rax
je 0x1a6a
shrl $0x3, %r13d
andl $0x7, %r13d
movl %ebp, (%rax)
movl %r12d, %ecx
movq 0x30(%rsp), %rdx
movq %rax, (%rdx,%rcx,8)
movl %r12d, 0x10(%rsp,%r13,4)
cmpb $0x0, (%rsp,%r13)
movq %r15, %r8
leaq 0x7d7(%rip), %rdi       # 0x2004
jne 0x13d4
testl %r12d, %r12d
je 0x13d4
movq 0x2795(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1110
movq 0x27a6(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x8a3(%rip), %rsi       # 0x20ff
movl %r13d, %edx
xorl %eax, %eax
callq 0x10d0
leaq 0x797(%rip), %rdi       # 0x2004
movq %r15, %r8
movb $0x1, (%rsp,%r13)
jmp 0x13d4
movl 0x10(%rsp,%rsi,4), %edx
xorl %esi, %esi
cmpl %edx, 0x4(%rax,%rcx,4)
setne %sil
addl %esi, 0xc(%rsp)
movl %edx, 0x4(%rax,%rcx,4)
jmp 0x13d4
cmpq %rax, 0x40(%rsp)
jbe 0x1b1d
movq 0x30(%rsp), %r12
movq (%r12,%rax,8), %rax
testq %rax, %rax
je 0x1b3c
movq %r8, 0x50(%rsp)
movq %rax, %r15
movl (%rax), %ebx
incl %ebx
shlq $0x2, %rbx
movq %rbx, %rdi
callq 0x1100
testq %rax, %rax
je 0x1b5b
movq %rax, %rbp
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10f0
movq %r14, %rdi
callq 0x1030
movq %rbp, (%r12)
movq 0x26e1(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1110
movq 0x26f2(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0x8da(%rip), %rdi       # 0x21ea
callq 0x1090
movq %rbp, %r14
movq 0x50(%rsp), %r8
leaq 0x6e0(%rip), %rdi       # 0x2004
jmp 0x14ad
movq 0x26a8(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1110
movq 0x26b9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x85a(%rip), %rsi       # 0x21a3
movl 0xc(%rsp), %edx
xorl %eax, %eax
callq 0x10d0
movl $0x0, 0xc(%rsp)
jmp 0x1460
movq 0x2670(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1110
movq 0x2681(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0x7e3(%rip), %rdi       # 0x2164
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7f1(%rip), %rdi       # 0x2195
leaq 0x6b1(%rip), %rsi       # 0x205c
leaq 0x6b8(%rip), %rcx       # 0x206a
movl $0xdb, %edx
callq 0x1080
leaq 0x795(%rip), %rdi       # 0x2158
leaq 0x692(%rip), %rsi       # 0x205c
leaq 0x699(%rip), %rcx       # 0x206a
movl $0x90, %edx
callq 0x1080
leaq 0x734(%rip), %rdi       # 0x2116
leaq 0x673(%rip), %rsi       # 0x205c
leaq 0x67a(%rip), %rcx       # 0x206a
pushq $0x67
jmp 0x1af7
leaq 0x727(%rip), %rdi       # 0x2125
leaq 0x657(%rip), %rsi       # 0x205c
leaq 0x65e(%rip), %rcx       # 0x206a
pushq $0x57
jmp 0x1af7
leaq 0x70b(%rip), %rdi       # 0x2125
leaq 0x63b(%rip), %rsi       # 0x205c
leaq 0x642(%rip), %rcx       # 0x206a
pushq $0x69
jmp 0x1af7
leaq 0x6e0(%rip), %rdi       # 0x2116
leaq 0x61f(%rip), %rsi       # 0x205c
leaq 0x626(%rip), %rcx       # 0x206a
pushq $0x55
jmp 0x1af7
leaq 0x72d(%rip), %rdi       # 0x217f
leaq 0x603(%rip), %rsi       # 0x205c
leaq 0x60a(%rip), %rcx       # 0x206a
movl $0xca, %edx
callq 0x1080
leaq 0x6ff(%rip), %rdi       # 0x2170
leaq 0x5e4(%rip), %rsi       # 0x205c
leaq 0x5eb(%rip), %rcx       # 0x206a
movl $0xba, %edx
callq 0x1080
leaq 0x686(%rip), %rdi       # 0x2116
leaq 0x5c5(%rip), %rsi       # 0x205c
leaq 0x5cc(%rip), %rcx       # 0x206a
movl $0xc9, %edx
callq 0x1080
leaq 0x6d7(%rip), %rdi       # 0x2186
leaq 0x5a6(%rip), %rsi       # 0x205c
leaq 0x5ad(%rip), %rcx       # 0x206a
movl $0xcb, %edx
callq 0x1080
leaq 0x676(%rip), %rdi       # 0x2144
leaq 0x587(%rip), %rsi       # 0x205c
leaq 0x58e(%rip), %rcx       # 0x206a
pushq $0x6a
jmp 0x1af7
leaq 0x649(%rip), %rdi       # 0x2130
leaq 0x56e(%rip), %rsi       # 0x205c
leaq 0x575(%rip), %rcx       # 0x206a
pushq $0x58
popq %rdx
callq 0x1080
movq 0x24f4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x6f0(%rip), %rsi       # 0x21fe
movl %r13d, %edx
xorl %eax, %eax
callq 0x10d0
callq 0x1050
leaq 0x5f2(%rip), %rdi       # 0x2116
leaq 0x531(%rip), %rsi       # 0x205c
leaq 0x538(%rip), %rcx       # 0x206a
movl $0xfc, %edx
callq 0x1080
leaq 0x643(%rip), %rdi       # 0x2186
leaq 0x512(%rip), %rsi       # 0x205c
leaq 0x519(%rip), %rcx       # 0x206a
movl $0xfd, %edx
callq 0x1080
leaq 0x675(%rip), %rdi       # 0x21d7
leaq 0x4f3(%rip), %rsi       # 0x205c
leaq 0x4fa(%rip), %rcx       # 0x206a
movl $0x100, %edx            # imm = 0x100
callq 0x1080
leaq 0x641(%rip), %rdi       # 0x21c2
leaq 0x4d4(%rip), %rsi       # 0x205c
leaq 0x4db(%rip), %rcx       # 0x206a
movl $0xec, %edx
callq 0x1080
leaq 0x5d3(%rip), %rdi       # 0x2173
leaq 0x4b5(%rip), %rsi       # 0x205c
leaq 0x4bc(%rip), %rcx       # 0x206a
movl $0xb4, %edx
callq 0x1080
leaq 0x493(%rip), %rdi       # 0x2052
leaq 0x496(%rip), %rsi       # 0x205c
leaq 0x49d(%rip), %rcx       # 0x206a
pushq $0x15
jmp 0x1af7
leaq 0x4a6(%rip), %rdi       # 0x2081
leaq 0x47a(%rip), %rsi       # 0x205c
leaq 0x481(%rip), %rcx       # 0x206a
pushq $0x17
jmp 0x1af7
leaq 0x49a(%rip), %rdi       # 0x2091
leaq 0x45e(%rip), %rsi       # 0x205c
leaq 0x465(%rip), %rcx       # 0x206a
pushq $0x19
jmp 0x1af7
leaq 0x46e(%rip), %rdi       # 0x2081
leaq 0x442(%rip), %rsi       # 0x205c
leaq 0x449(%rip), %rcx       # 0x206a
pushq $0x1c
jmp 0x1af7
leaq 0x46c(%rip), %rdi       # 0x209b
leaq 0x426(%rip), %rsi       # 0x205c
leaq 0x42d(%rip), %rcx       # 0x206a
pushq $0x1e
jmp 0x1af7
leaq 0x463(%rip), %rdi       # 0x20ae
leaq 0x40a(%rip), %rsi       # 0x205c
leaq 0x411(%rip), %rcx       # 0x206a
pushq $0x20
jmp 0x1af7
leaq 0x45d(%rip), %rdi       # 0x20c4
leaq 0x3ee(%rip), %rsi       # 0x205c
leaq 0x3f5(%rip), %rcx       # 0x206a
pushq $0x23
jmp 0x1af7
leaq 0x41b(%rip), %rdi       # 0x209e
leaq 0x3d2(%rip), %rsi       # 0x205c
leaq 0x3d9(%rip), %rcx       # 0x206a
pushq $0x25
jmp 0x1af7