// File: /workspace/github_c_makefile_star2_O3/minoki[P]icfpc2006/run_directthreaded.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,
    };
    void **program = NULL;
    while (1) {
        free(program);
        program = malloc(sizeof(void *) * arr0->length);
        for (uint32_t i = 0; i < arr0->length; ++i) {
            uint32_t op = arr0->data[i];
            program[i] = operations[op >> 28];
        }
        goto *program[pc];
    OP_CondMove:
        {
            uint32_t op = arr0->data[pc];
            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;
            goto *program[pc];
        }
    OP_ArrayIndex:
        {
            uint32_t op = arr0->data[pc];
            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;
            goto *program[pc];
        }
    OP_ArrayAmendment:
        {
            uint32_t op = arr0->data[pc];
            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];
            if (UNLIKELY(i == 0)) {
                program[reg[b]] = operations[reg[c] >> 28];
            }
            ++pc;
            goto *program[pc];
        }
    OP_Add:
        {
            uint32_t op = arr0->data[pc];
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            reg[a] = reg[b] + reg[c];
            ++pc;
            goto *program[pc];
        }
    OP_Mul:
        {
            uint32_t op = arr0->data[pc];
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            reg[a] = reg[b] * reg[c];
            ++pc;
            goto *program[pc];
        }
    OP_Div:
        {
            uint32_t op = arr0->data[pc];
            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;
            goto *program[pc];
        }
    OP_NotAnd:
        {
            uint32_t op = arr0->data[pc];
            uint32_t a = (op >> 6) & 7;
            uint32_t b = (op >> 3) & 7;
            uint32_t c = op & 7;
            reg[a] = ~(reg[b] & reg[c]);
            ++pc;
            goto *program[pc];
        }
    OP_Halt:
        fflush(stdout);
        fprintf(stderr, "HALT\n");
        return 0;
    OP_Alloc:
        {
            uint32_t op = arr0->data[pc];
            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;
            goto *program[pc];
        }
    OP_Abandon:
        {
            uint32_t op = arr0->data[pc];
            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;
            goto *program[pc];
        }
    OP_Output:
        {
            uint32_t op = arr0->data[pc];
            uint32_t c = op & 7;
            assert(reg[c] <= 255);
            putchar(reg[c]);
            ++pc;
            goto *program[pc];
        }
    OP_Input:
        {
            uint32_t op = arr0->data[pc];
            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;
            goto *program[pc];
        }
    OP_LoadProgram:
        {
            uint32_t op = arr0->data[pc];
            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);
                continue;
            }
            pc = reg[c];
            assert(pc < arr0->length);
            goto *program[pc];
        }
    OP_Orthography:
        {
            uint32_t op = arr0->data[pc];
            uint32_t a = (op >> 25) & 7;
            uint32_t value = op & ((UINT32_C(1) << 25) - 1);
            reg[a] = value;
            ++pc;
            goto *program[pc];
        }
    OP_Invalid:
        {
            uint32_t op = arr0->data[pc];
            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 0x1291
movq %rsi, %rdi
callq 0x1160
movl $0x1, %eax
jmp 0x18e0
movq 0x8(%rsi), %rdi
leaq 0xd7b(%rip), %rsi       # 0x2017
callq 0x1130
testq %rax, %rax
je 0x1ae2
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1110
testl %eax, %eax
jne 0x1b01
movq %rbx, %rdi
callq 0x10d0
testq %rax, %rax
js 0x1b20
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1110
testl %eax, %eax
jne 0x1b3f
movq %r15, %rdi
callq 0x10f0
testq %rax, %rax
je 0x1b5e
movq %rax, %r14
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1060
cmpq %r15, %rax
jne 0x1b7d
movq %rbx, %rdi
callq 0x1070
testb $0x3, %r15b
jne 0x1b9c
leaq 0x4(%r15), %rdi
callq 0x10f0
testq %rax, %rax
je 0x1bbb
movq %rax, %r13
movq %r15, %rax
shrq $0x2, %rax
movl %eax, (%r13)
testq %r15, %r15
je 0x1368
xorl %ecx, %ecx
movl (%r14,%rcx,4), %edx
bswapl %edx
movl %edx, 0x4(%r13,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x1355
movq %r14, %rdi
callq 0x1030
movq 0x2c79(%rip), %rax      # 0x3ff0
movq (%rax), %rdi
leaq 0xd34(%rip), %rsi       # 0x20b5
movq $0x0, 0x8(%rsp)
movq %r15, %rdx
xorl %eax, %eax
callq 0x10c0
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movl $0x1, %eax
movq %rax, 0x30(%rsp)
movl $0x1, %edi
movl $0x8, %esi
callq 0x10a0
movq %rax, %r14
movq %r13, (%rax)
movl (%r13), %r15d
leaq 0x2995(%rip), %rbx      # 0x3d60
movq $0x0, 0x50(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x48(%rsp)
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
callq 0x1030
movl %r15d, %r12d
leaq (,%r12,8), %rdi
callq 0x10f0
movq %rax, 0x8(%rsp)
testl %r15d, %r15d
movq %r13, 0x40(%rsp)
je 0x1430
xorl %eax, %eax
movl 0x4(%r13,%rax,4), %ecx
shrl $0x1c, %ecx
movq (%rbx,%rcx,8), %rcx
movq 0x8(%rsp), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x1413
movq 0x38(%rsp), %r12
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %eax
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x0, 0x10(%rsp,%rcx,4)
je 0x1463
movl %eax, %ecx
shrl %ecx
andl $0x1c, %ecx
movl 0x10(%rsp,%rcx), %ecx
shrl $0x4, %eax
andl $0x1c, %eax
movl %ecx, 0x10(%rsp,%rax)
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %eax
movl %eax, %ecx
shrl %ecx
andl $0x1c, %ecx
movl 0x10(%rsp,%rcx), %ecx
cmpq %rcx, 0x30(%rsp)
jbe 0x19ea
movq (%r14,%rcx,8), %rcx
testq %rcx, %rcx
je 0x196e
movl %eax, %edx
andl $0x7, %edx
movl 0x10(%rsp,%rdx,4), %edx
cmpl (%rcx), %edx
jae 0x19cb
shrl $0x6, %eax
andl $0x7, %eax
movl 0x4(%rcx,%rdx,4), %ecx
movl %ecx, 0x10(%rsp,%rax,4)
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %eax
movl %eax, %ecx
shrl $0x4, %ecx
andl $0x1c, %ecx
movl 0x10(%rsp,%rcx), %ecx
cmpq %rcx, 0x30(%rsp)
jbe 0x1a09
movq (%r14,%rcx,8), %rdx
testq %rdx, %rdx
je 0x198d
movl %eax, %esi
shrl $0x3, %esi
andl $0x7, %esi
movl 0x10(%rsp,%rsi,4), %esi
cmpl (%rdx), %esi
jae 0x1a28
andl $0x7, %eax
movl 0x10(%rsp,%rax,4), %eax
movl %eax, 0x4(%rdx,%rsi,4)
testq %rcx, %rcx
je 0x1518
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
shrl $0x1c, %eax
movq (%rbx,%rax,8), %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%rsi,8)
jmp 0x150d
movl 0x4(%r13,%rbp,4), %eax
movl %eax, %ecx
andl $0x7, %ecx
movl %eax, %edx
shrl %edx
andl $0x1c, %edx
movl 0x10(%rsp,%rcx,4), %ecx
addl 0x10(%rsp,%rdx), %ecx
shrl $0x4, %eax
andl $0x1c, %eax
movl %ecx, 0x10(%rsp,%rax)
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %eax
movl %eax, %ecx
andl $0x7, %ecx
movl %eax, %edx
shrl %edx
andl $0x1c, %edx
movl 0x10(%rsp,%rcx,4), %ecx
imull 0x10(%rsp,%rdx), %ecx
shrl $0x4, %eax
andl $0x1c, %eax
movl %ecx, 0x10(%rsp,%rax)
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %ecx
movl %ecx, %eax
andl $0x7, %eax
movl 0x10(%rsp,%rax,4), %esi
testl %esi, %esi
je 0x194f
movl %ecx, %eax
shrl %eax
andl $0x1c, %eax
movl 0x10(%rsp,%rax), %eax
xorl %edx, %edx
divl %esi
shrl $0x4, %ecx
andl $0x1c, %ecx
movl %eax, 0x10(%rsp,%rcx)
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %eax
movl %eax, %ecx
andl $0x7, %ecx
movl %eax, %edx
shrl %edx
andl $0x1c, %edx
movl 0x10(%rsp,%rcx,4), %ecx
andl 0x10(%rsp,%rdx), %ecx
notl %ecx
shrl $0x4, %eax
andl $0x1c, %eax
movl %ecx, 0x10(%rsp,%rax)
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movq %r14, %rbx
movl 0x4(%r13,%rbp,4), %eax
movl %eax, %r15d
shrl $0x3, %r15d
andl $0x7, %r15d
andl $0x7, %eax
movl 0x10(%rsp,%rax,4), %r13d
cmpq 0x48(%rsp), %r12
je 0x1632
movq 0x30(%rsp), %r14
movq %r12, %rax
movl -0x4(%r12), %r12d
movl $0x0, -0x4(%rax)
addq $-0x4, %rax
movq %rax, 0x38(%rsp)
jmp 0x165e
movq %r12, 0x38(%rsp)
movq 0x30(%rsp), %r12
leaq 0x8(,%r12,8), %rsi
movq %r12, %r14
incq %r14
movq %rbx, %rdi
callq 0x1120
movq %rax, %rbx
testq %rax, %rax
je 0x1ac3
leal 0x1(%r13), %edi
movl $0x4, %esi
callq 0x10a0
testq %rax, %rax
je 0x1911
movl %r13d, (%rax)
movl %r12d, %ecx
movq %rax, (%rbx,%rcx,8)
movl %r12d, 0x10(%rsp,%r15,4)
incq %rbp
movq %r14, 0x30(%rsp)
movq %rbx, %r14
movq 0x40(%rsp), %r13
movq 0x8(%rsp), %rax
leaq 0x26c0(%rip), %rbx      # 0x3d60
movq 0x38(%rsp), %r12
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %eax
andl $0x7, %eax
movl 0x10(%rsp,%rax,4), %r15d
cmpq %r15, 0x30(%rsp)
jbe 0x1a47
testl %r15d, %r15d
je 0x1930
movq (%r14,%r15,8), %rdi
testq %rdi, %rdi
je 0x19ac
callq 0x1030
movq $0x0, (%r14,%r15,8)
movq %r12, %r13
movq 0x48(%rsp), %rdi
subq %rdi, %r13
movq %r13, %rax
sarq $0x2, %rax
movq 0x50(%rsp), %rdx
movl %edx, %ecx
cmpq %rcx, %rax
jne 0x1751
movq %r14, %rbx
leal (%rdx,%rdx), %r14d
testl %edx, %edx
movl $0x20, %eax
cmovel %eax, %r14d
leaq (,%r14,4), %rsi
movq %rdx, %r12
callq 0x1120
movq %rax, 0x48(%rsp)
addq %rax, %r13
movl %r14d, %edx
subl %r12d, %edx
shlq $0x2, %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x1090
movq %r14, 0x50(%rsp)
movq %rbx, %r14
leaq 0x2612(%rip), %rbx      # 0x3d60
movq %r13, %r12
movq 0x40(%rsp), %r13
movl %r15d, (%r12)
addq $0x4, %r12
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %eax
andl $0x7, %eax
movl 0x10(%rsp,%rax,4), %edi
cmpl $0x100, %edi            # imm = 0x100
jae 0x1a66
callq 0x1040
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %r15d
andl $0x7, %r15d
movq 0x282f(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
callq 0x1100
callq 0x10b0
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $-0x1, %eax
je 0x17c5
movl %eax, %ecx
cmpl $0x100, %eax            # imm = 0x100
jae 0x1aa4
movl %ecx, 0x10(%rsp,%r15,4)
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %eax
movl %eax, %ecx
andl $0x1ffffff, %ecx        # imm = 0x1FFFFFF
shrl $0x17, %eax
andl $0x1c, %eax
movl %ecx, 0x10(%rsp,%rax)
incq %rbp
movq 0x8(%rsp), %rax
jmpq *(%rax,%rbp,8)
movl 0x4(%r13,%rbp,4), %eax
movl %eax, %r15d
andl $0x7, %r15d
shrl %eax
andl $0x1c, %eax
movl 0x10(%rsp,%rax), %eax
testq %rax, %rax
jne 0x1827
movl %r15d, %eax
movl 0x10(%rsp,%rax,4), %ebp
cmpl (%r13), %ebp
jb 0x1435
jmp 0x1a85
cmpq %rax, 0x30(%rsp)
jbe 0x1bda
movq (%r14,%rax,8), %rbp
testq %rbp, %rbp
je 0x1c18
movl (%rbp), %r13d
incl %r13d
shlq $0x2, %r13
movq %r13, %rdi
callq 0x10f0
testq %rax, %rax
je 0x1bf9
movq %r12, 0x38(%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rax, %r13
callq 0x10e0
movq 0x40(%rsp), %rdi
callq 0x1030
movq %r13, (%r14)
movl 0x10(%rsp,%r15,4), %ebp
movl (%r13), %r15d
cmpl %r15d, %ebp
jb 0x13e8
leaq 0x8ed(%rip), %rdi       # 0x2184
leaq 0x786(%rip), %rsi       # 0x2024
leaq 0x794(%rip), %rcx       # 0x2039
movl $0x10e, %edx            # imm = 0x10E
callq 0x1080
movq 0x271a(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
callq 0x1100
movq 0x272b(%rip), %rax      # 0x3ff0
movq (%rax), %rcx
leaq 0x854(%rip), %rdi       # 0x2123
movl $0x5, %esi
movl $0x1, %edx
callq 0x1140
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%r13,%rbp,4), %edx
movq 0x26f5(%rip), %rax      # 0x3ff0
movq (%rax), %rdi
leaq 0x891(%rip), %rsi       # 0x2196
xorl %eax, %eax
callq 0x10c0
callq 0x1050
leaq 0x811(%rip), %rdi       # 0x2129
leaq 0x705(%rip), %rsi       # 0x2024
leaq 0x713(%rip), %rcx       # 0x2039
movl $0xc9, %edx
callq 0x1080
leaq 0x801(%rip), %rdi       # 0x2138
leaq 0x6e6(%rip), %rsi       # 0x2024
leaq 0x6f4(%rip), %rcx       # 0x2039
movl $0xd6, %edx
callq 0x1080
leaq 0x7c1(%rip), %rdi       # 0x2117
leaq 0x6c7(%rip), %rsi       # 0x2024
leaq 0x6d5(%rip), %rcx       # 0x2039
movl $0xa5, %edx
callq 0x1080
leaq 0x76f(%rip), %rdi       # 0x20e4
leaq 0x6a8(%rip), %rsi       # 0x2024
leaq 0x6b6(%rip), %rcx       # 0x2039
movl $0x73, %edx
callq 0x1080
leaq 0x750(%rip), %rdi       # 0x20e4
leaq 0x689(%rip), %rsi       # 0x2024
leaq 0x697(%rip), %rcx       # 0x2039
movl $0x82, %edx
callq 0x1080
leaq 0x78c(%rip), %rdi       # 0x213f
leaq 0x66a(%rip), %rsi       # 0x2024
leaq 0x678(%rip), %rcx       # 0x2039
movl $0xd7, %edx
callq 0x1080
leaq 0x71d(%rip), %rdi       # 0x20ef
leaq 0x64b(%rip), %rsi       # 0x2024
leaq 0x659(%rip), %rcx       # 0x2039
movl $0x74, %edx
callq 0x1080
leaq 0x6e4(%rip), %rdi       # 0x20d5
leaq 0x62c(%rip), %rsi       # 0x2024
leaq 0x63a(%rip), %rcx       # 0x2039
movl $0x71, %edx
callq 0x1080
leaq 0x6c5(%rip), %rdi       # 0x20d5
leaq 0x60d(%rip), %rsi       # 0x2024
leaq 0x61b(%rip), %rcx       # 0x2039
movl $0x80, %edx
callq 0x1080
leaq 0x6d4(%rip), %rdi       # 0x2103
leaq 0x5ee(%rip), %rsi       # 0x2024
leaq 0x5fc(%rip), %rcx       # 0x2039
movl $0x83, %edx
callq 0x1080
leaq 0x687(%rip), %rdi       # 0x20d5
leaq 0x5cf(%rip), %rsi       # 0x2024
leaq 0x5dd(%rip), %rcx       # 0x2039
movl $0xd5, %edx
callq 0x1080
leaq 0x6e1(%rip), %rdi       # 0x214e
leaq 0x5b0(%rip), %rsi       # 0x2024
leaq 0x5be(%rip), %rcx       # 0x2039
movl $0xe9, %edx
callq 0x1080
leaq 0x6f8(%rip), %rdi       # 0x2184
leaq 0x591(%rip), %rsi       # 0x2024
leaq 0x59f(%rip), %rcx       # 0x2039
movl $0x112, %edx            # imm = 0x112
callq 0x1080
leaq 0x6b1(%rip), %rdi       # 0x215c
leaq 0x572(%rip), %rsi       # 0x2024
leaq 0x580(%rip), %rcx       # 0x2039
movl $0xf7, %edx
callq 0x1080
leaq 0x662(%rip), %rdi       # 0x212c
leaq 0x553(%rip), %rsi       # 0x2024
leaq 0x561(%rip), %rcx       # 0x2039
movl $0xc3, %edx
callq 0x1080
leaq 0x531(%rip), %rdi       # 0x201a
leaq 0x534(%rip), %rsi       # 0x2024
leaq 0x542(%rip), %rcx       # 0x2039
movl $0x1b, %edx
callq 0x1080
leaq 0x548(%rip), %rdi       # 0x2050
leaq 0x515(%rip), %rsi       # 0x2024
leaq 0x523(%rip), %rcx       # 0x2039
movl $0x1d, %edx
callq 0x1080
leaq 0x539(%rip), %rdi       # 0x2060
leaq 0x4f6(%rip), %rsi       # 0x2024
leaq 0x504(%rip), %rcx       # 0x2039
movl $0x1f, %edx
callq 0x1080
leaq 0x50a(%rip), %rdi       # 0x2050
leaq 0x4d7(%rip), %rsi       # 0x2024
leaq 0x4e5(%rip), %rcx       # 0x2039
movl $0x22, %edx
callq 0x1080
leaq 0x505(%rip), %rdi       # 0x206a
leaq 0x4b8(%rip), %rsi       # 0x2024
leaq 0x4c6(%rip), %rcx       # 0x2039
movl $0x24, %edx
callq 0x1080
leaq 0x4f9(%rip), %rdi       # 0x207d
leaq 0x499(%rip), %rsi       # 0x2024
leaq 0x4a7(%rip), %rcx       # 0x2039
movl $0x26, %edx
callq 0x1080
leaq 0x4f0(%rip), %rdi       # 0x2093
leaq 0x47a(%rip), %rsi       # 0x2024
leaq 0x488(%rip), %rcx       # 0x2039
movl $0x29, %edx
callq 0x1080
leaq 0x4e6(%rip), %rdi       # 0x20a8
leaq 0x45b(%rip), %rsi       # 0x2024
leaq 0x469(%rip), %rcx       # 0x2039
movl $0x2b, %edx
callq 0x1080
leaq 0x4f4(%rip), %rdi       # 0x20d5
leaq 0x43c(%rip), %rsi       # 0x2024
leaq 0x44a(%rip), %rcx       # 0x2039
movl $0x104, %edx            # imm = 0x104
callq 0x1080
leaq 0x571(%rip), %rdi       # 0x2171
leaq 0x41d(%rip), %rsi       # 0x2024
leaq 0x42b(%rip), %rcx       # 0x2039
movl $0x108, %edx            # imm = 0x108
callq 0x1080
leaq 0x520(%rip), %rdi       # 0x213f
leaq 0x3fe(%rip), %rsi       # 0x2024
leaq 0x40c(%rip), %rcx       # 0x2039
movl $0x105, %edx            # imm = 0x105
callq 0x1080