// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, (%rsp)
movl %edi, 0x8(%rsp)
cmpl $0x2, %edi
setge %r13b
jl 0x1432
movl $0x1, %r12d
xorl %ebp, %ebp
xorl %r14d, %r14d
movq $0x0, 0x58(%rsp)
movslq %r12d, %rax
movq (%rsp), %rcx
movq (%rcx,%rax,8), %r15
movq %r15, %rdi
leaq 0xce4(%rip), %rsi       # 0x203c
callq 0x10c0
testl %eax, %eax
je 0x1396
movq %r15, %rdi
leaq 0xcd9(%rip), %rsi       # 0x2044
callq 0x10c0
testl %eax, %eax
je 0x13b8
movq %r15, %rdi
leaq 0xcdf(%rip), %rsi       # 0x205d
callq 0x10c0
testl %eax, %eax
je 0x1a4f
movl %r12d, %ebx
movq %r15, %rbp
jmp 0x141a
leal 0x1(%r12), %ebx
cmpl 0x8(%rsp), %ebx
jge 0x13bf
testq %r14, %r14
movq %rbp, 0x38(%rsp)
je 0x13c4
movq %r14, %rdi
callq 0x1080
movq %rax, %r15
jmp 0x13c7
movb $0x1, %al
movq %rax, 0x58(%rsp)
movl %r12d, %ebx
jmp 0x141a
xorl %r15d, %r15d
movslq %ebx, %r12
movq (%rsp), %rbp
movq (%rbp,%r12,8), %rdi
callq 0x1080
movq %rax, %r13
addq %r15, %rax
movq %rax, 0x40(%rsp)
leaq (%r15,%r13), %rsi
addq $0x2, %rsi
movq %r14, %rdi
callq 0x1140
movq %rax, %r14
addq %rax, %r15
movq (%rbp,%r12,8), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x1100
movq 0x40(%rsp), %rax
movw $0xa, (%r14,%rax)
movq 0x38(%rsp), %rbp
incl %ebx
movl %ebx, %r12d
cmpl 0x8(%rsp), %ebx
setl %r13b
jl 0x1343
movq %rbp, %rbx
jmp 0x1440
movq $0x0, 0x58(%rsp)
xorl %r14d, %r14d
xorl %ebx, %ebx
xorl %ebp, %ebp
testb $0x1, %r13b
je 0x1459
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %rbx, %rbx
jne 0x146e
movq (%rsp), %rdi
callq 0x11f9
movl $0x1, %ebp
jmp 0x1448
movq %rbx, %rdi
movq %r14, 0x40(%rsp)
leaq 0xbe7(%rip), %rsi       # 0x2064
callq 0x1150
testq %rax, %rax
je 0x1a84
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1130
testl %eax, %eax
jne 0x1aa3
movq %r14, %rdi
callq 0x10f0
testq %rax, %rax
js 0x1ac2
movq %rax, %rbx
movl %ebp, 0x54(%rsp)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1130
testl %eax, %eax
jne 0x1ae1
movq %rbx, %rdi
callq 0x1110
testq %rax, %rax
je 0x1b00
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1060
cmpq %rbx, %rax
jne 0x1b1f
movq %r14, %rdi
callq 0x1070
testb $0x3, %bl
jne 0x1b3e
leaq 0x4(%rbx), %rdi
callq 0x1110
testq %rax, %rax
je 0x1b5d
movq %rax, %r14
movq %rbx, %rax
shrq $0x2, %rax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x154b
xorl %ecx, %ecx
movl (%r15,%rcx,4), %edx
bswapl %edx
movl %edx, 0x4(%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x1538
movq %r15, %rdi
callq 0x1030
movq 0x2a9e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xb82(%rip), %rsi       # 0x20e6
movq $0x0, 0x60(%rsp)
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10e0
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x1, %r13d
movl $0x1, %edi
movl $0x8, %esi
callq 0x10b0
movq %rax, %rbx
movq %r14, (%rax)
leaq 0xa5e(%rip), %rbp       # 0x2004
movq $0x0, 0x8(%rsp)
xorl %r8d, %r8d
xorl %r15d, %r15d
movl (%r14), %eax
cmpq %rax, %r15
jae 0x1a65
movl 0x4(%r14,%r15,4), %r12d
movl %r12d, %eax
shrl $0x1c, %eax
cmpl $0xd, %eax
ja 0x1b7c
incq %r15
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movl %r12d, %ecx
andl $0x7, %ecx
movb $0x1, %al
cmpl $0x0, 0x10(%rsp,%rcx,4)
je 0x18fb
movl %r12d, %ecx
shrl %ecx
andl $0x1c, %ecx
movl 0x10(%rsp,%rcx), %ecx
shrl $0x4, %r12d
andl $0x1c, %r12d
movl %ecx, 0x10(%rsp,%r12)
jmp 0x18fb
movq %r13, (%rsp)
movl %r12d, %eax
andl $0x7, %eax
movl 0x10(%rsp,%rax,4), %r13d
movq %r8, 0x48(%rsp)
movq 0x8(%rsp), %rax
cmpq %r8, %rax
je 0x192c
movq %rbx, %rbp
movl -0x4(%rax), %ebx
movl $0x0, -0x4(%rax)
addq $-0x4, %rax
movq %rax, 0x8(%rsp)
jmp 0x1960
movl %r12d, %eax
shrl %eax
andl $0x1c, %eax
movl 0x10(%rsp,%rax), %eax
testq %rax, %rax
jne 0x19d2
andl $0x7, %r12d
movl 0x10(%rsp,%r12,4), %r15d
jmp 0x18f9
movl %r12d, %eax
andl $0x7, %eax
movl %r12d, %ecx
shrl %ecx
andl $0x1c, %ecx
movl 0x10(%rsp,%rax,4), %eax
imull 0x10(%rsp,%rcx), %eax
jmp 0x17bb
movl %r12d, %eax
shrl $0x4, %eax
andl $0x1c, %eax
movl 0x10(%rsp,%rax), %eax
cmpq %rax, %r13
jbe 0x1c3e
movq (%rbx,%rax,8), %rax
testq %rax, %rax
je 0x1c7c
movl %r12d, %ecx
shrl $0x3, %ecx
andl $0x7, %ecx
movl 0x10(%rsp,%rcx,4), %ecx
cmpl (%rax), %ecx
jae 0x1c5d
andl $0x7, %r12d
movl %r12d, %edx
movl 0x10(%rsp,%rdx,4), %edx
movl %edx, 0x4(%rax,%rcx,4)
jmp 0x18f9
movl %r12d, %eax
andl $0x7, %eax
movl %r12d, %ecx
shrl %ecx
andl $0x1c, %ecx
movl 0x10(%rsp,%rax,4), %eax
addl 0x10(%rsp,%rcx), %eax
jmp 0x17bb
andl $0x7, %r12d
movl 0x10(%rsp,%r12,4), %edi
cmpl $0x100, %edi            # imm = 0x100
jae 0x1b84
testb $0x1, 0x58(%rsp)
je 0x172a
cmpq $0x0, 0x40(%rsp)
je 0x172a
movb $0x1, %al
movq 0x40(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x18fb
movq %r8, %r12
callq 0x1040
movq %r12, %r8
jmp 0x18f9
movl %r12d, %eax
shrl %eax
andl $0x1c, %eax
movl 0x10(%rsp,%rax), %eax
cmpq %rax, %r13
jbe 0x1c9b
movq (%rbx,%rax,8), %rax
testq %rax, %rax
je 0x1cd9
movl %r12d, %ecx
andl $0x7, %ecx
movl 0x10(%rsp,%rcx,4), %ecx
cmpl (%rax), %ecx
jae 0x1cba
shrl $0x6, %r12d
andl $0x7, %r12d
movl 0x4(%rax,%rcx,4), %eax
jmp 0x18f2
movl %r12d, %eax
andl $0x7, %eax
movl 0x10(%rsp,%rax,4), %ecx
testl %ecx, %ecx
je 0x1c1f
movl %r12d, %eax
shrl %eax
andl $0x1c, %eax
movl 0x10(%rsp,%rax), %eax
xorl %edx, %edx
divl %ecx
jmp 0x17bb
movl %r12d, %eax
andl $0x7, %eax
movl %r12d, %ecx
shrl %ecx
andl $0x1c, %ecx
movl 0x10(%rsp,%rax,4), %eax
andl 0x10(%rsp,%rcx), %eax
notl %eax
shrl $0x4, %r12d
jmp 0x189f
andl $0x7, %r12d
movl 0x10(%rsp,%r12,4), %r12d
cmpq %r12, %r13
jbe 0x1ba3
testl %r12d, %r12d
je 0x1be1
movq (%rbx,%r12,8), %rdi
testq %rdi, %rdi
je 0x1bc2
movq %r13, %rbp
movq %r8, %r13
callq 0x1030
movq %rbx, 0x38(%rsp)
movq $0x0, (%rbx,%r12,8)
movq 0x8(%rsp), %rax
movq %r13, %r8
subq %r13, %rax
sarq $0x2, %rax
movq 0x60(%rsp), %rcx
movl %ecx, %ebx
cmpq %rbx, %rax
jne 0x1908
movq %rbp, (%rsp)
movq %rcx, %rbp
leal (%rcx,%rcx), %r13d
testl %ebp, %ebp
movl $0x20, %eax
cmovel %eax, %r13d
leaq (,%r13,4), %rsi
movq %r8, %rdi
callq 0x1140
movq %rax, 0x48(%rsp)
leaq (%rax,%rbx,4), %rbx
movl %r13d, %edx
subl %ebp, %edx
movq (%rsp), %rbp
shlq $0x2, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10a0
movq 0x48(%rsp), %r8
movq %r13, 0x60(%rsp)
jmp 0x190d
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0x18aa
movzbl (%rcx), %eax
testl %eax, %eax
je 0x18aa
incq %rcx
movq %rcx, 0x40(%rsp)
jmp 0x18da
movl %r12d, %eax
andl $0x1ffffff, %eax        # imm = 0x1FFFFFF
shrl $0x17, %r12d
andl $0x1c, %r12d
movl %eax, 0x10(%rsp,%r12)
jmp 0x18f9
movq 0x2727(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movq %rbx, 0x38(%rsp)
movq %rbp, %rbx
movq %r13, %rbp
movq %r8, %r13
callq 0x1120
callq 0x10d0
movq %r13, %r8
movq %rbp, %r13
movq %rbx, %rbp
movq 0x38(%rsp), %rbx
andl $0x7, %r12d
cmpl $-0x1, %eax
je 0x19aa
cmpl $0x100, %eax            # imm = 0x100
jae 0x1cf8
movl %r12d, %ecx
movl %eax, 0x10(%rsp,%rcx,4)
movb $0x1, %al
testb %al, %al
jne 0x15b5
jmp 0x1a46
movq 0x8(%rsp), %rbx
movl %r12d, (%rbx)
addq $0x4, %rbx
movq %rbx, 0x8(%rsp)
movb $0x1, %al
movq 0x38(%rsp), %rbx
movq %rbp, %r13
leaq 0x6da(%rip), %rbp       # 0x2004
jmp 0x18fb
movq %r13, 0x38(%rsp)
movq (%rsp), %r13
leaq 0x8(,%r13,8), %rsi
movq %rbx, %rdi
callq 0x1140
testq %rax, %rax
je 0x1d17
movq %rax, %rbp
movl %r13d, %ebx
incq %r13
movq %r13, (%rsp)
movq 0x38(%rsp), %r13
leal 0x1(%r13), %edi
movl $0x4, %esi
callq 0x10b0
testq %rax, %rax
je 0x1c00
shrl $0x3, %r12d
andl $0x7, %r12d
movl %r13d, (%rax)
movl %ebx, %ecx
movq %rax, (%rbp,%rcx,8)
movl %r12d, %eax
movl %ebx, 0x10(%rsp,%rax,4)
movq %rbp, %rbx
movb $0x1, %al
leaq 0x668(%rip), %rbp       # 0x2004
movq 0x48(%rsp), %r8
movq (%rsp), %r13
jmp 0x18fb
movl $0xffffffff, 0x10(%rsp,%r12,4) # imm = 0xFFFFFFFF
jmp 0x18f9
movq %r8, %r12
callq 0x119b
movq %r12, %r8
xorl %eax, %eax
movl $0x0, 0x54(%rsp)
jmp 0x18fb
movq %r8, 0x48(%rsp)
movq %r13, (%rsp)
cmpq %rax, %r13
jbe 0x1d36
movq %rbx, %r15
movq (%rbx,%rax,8), %r13
testq %r13, %r13
je 0x1d55
movl (%r13), %ebp
incl %ebp
shlq $0x2, %rbp
movq %rbp, %rdi
callq 0x1110
testq %rax, %rax
je 0x1d74
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1100
movq %r14, %rdi
callq 0x1030
movq %rbx, (%r15)
movq %rbx, %r14
movq (%rsp), %r13
movq %r15, %rbx
leaq 0x5c8(%rip), %rbp       # 0x2004
movq 0x48(%rsp), %r8
jmp 0x1665
movl 0x54(%rsp), %ebp
jmp 0x1448
movq %rbp, %rbx
movq (%rsp), %rdi
callq 0x1180
movl $0x1, %ebp
jmp 0x1442
leaq 0x6a0(%rip), %rdi       # 0x210c
leaq 0x5fe(%rip), %rsi       # 0x2071
leaq 0x5fd(%rip), %rcx       # 0x2077
movl $0x5c, %edx
callq 0x1090
leaq 0x5dc(%rip), %rdi       # 0x2067
leaq 0x5df(%rip), %rsi       # 0x2071
leaq 0x5de(%rip), %rcx       # 0x2077
movl $0x36, %edx
callq 0x1090
leaq 0x5e4(%rip), %rdi       # 0x208e
leaq 0x5c0(%rip), %rsi       # 0x2071
leaq 0x5bf(%rip), %rcx       # 0x2077
movl $0x38, %edx
callq 0x1090
leaq 0x5d5(%rip), %rdi       # 0x209e
leaq 0x5a1(%rip), %rsi       # 0x2071
leaq 0x5a0(%rip), %rcx       # 0x2077
movl $0x3a, %edx
callq 0x1090
leaq 0x5a6(%rip), %rdi       # 0x208e
leaq 0x582(%rip), %rsi       # 0x2071
leaq 0x581(%rip), %rcx       # 0x2077
movl $0x3d, %edx
callq 0x1090
leaq 0x5a1(%rip), %rdi       # 0x20a8
leaq 0x563(%rip), %rsi       # 0x2071
leaq 0x562(%rip), %rcx       # 0x2077
movl $0x3f, %edx
callq 0x1090
leaq 0x595(%rip), %rdi       # 0x20bb
leaq 0x544(%rip), %rsi       # 0x2071
leaq 0x543(%rip), %rcx       # 0x2077
movl $0x41, %edx
callq 0x1090
leaq 0x58c(%rip), %rdi       # 0x20d1
leaq 0x525(%rip), %rsi       # 0x2071
leaq 0x524(%rip), %rcx       # 0x2077
movl $0x44, %edx
callq 0x1090
leaq 0x547(%rip), %rdi       # 0x20ab
leaq 0x506(%rip), %rsi       # 0x2071
leaq 0x505(%rip), %rcx       # 0x2077
movl $0x46, %edx
callq 0x1090
movl %r12d, %edi
callq 0x11c8
leaq 0x615(%rip), %rdi       # 0x21a0
leaq 0x4df(%rip), %rsi       # 0x2071
leaq 0x4de(%rip), %rcx       # 0x2077
movl $0xd5, %edx
callq 0x1090
leaq 0x577(%rip), %rdi       # 0x2121
leaq 0x4c0(%rip), %rsi       # 0x2071
leaq 0x4bf(%rip), %rcx       # 0x2077
movl $0xc3, %edx
callq 0x1090
leaq 0x5c8(%rip), %rdi       # 0x2191
leaq 0x4a1(%rip), %rsi       # 0x2071
leaq 0x4a0(%rip), %rcx       # 0x2077
movl $0xc5, %edx
callq 0x1090
leaq 0x5a2(%rip), %rdi       # 0x218a
leaq 0x482(%rip), %rsi       # 0x2071
leaq 0x481(%rip), %rcx       # 0x2077
movl $0xc4, %edx
callq 0x1090
leaq 0x574(%rip), %rdi       # 0x217b
leaq 0x463(%rip), %rsi       # 0x2071
leaq 0x462(%rip), %rcx       # 0x2077
movl $0xb9, %edx
callq 0x1090
leaq 0x53d(%rip), %rdi       # 0x2163
leaq 0x444(%rip), %rsi       # 0x2071
leaq 0x443(%rip), %rcx       # 0x2077
movl $0x99, %edx
callq 0x1090
leaq 0x4dc(%rip), %rdi       # 0x2121
leaq 0x425(%rip), %rsi       # 0x2071
leaq 0x424(%rip), %rcx       # 0x2077
movl $0x7d, %edx
callq 0x1090
leaq 0x4eb(%rip), %rdi       # 0x214f
leaq 0x406(%rip), %rsi       # 0x2071
leaq 0x405(%rip), %rcx       # 0x2077
movl $0x80, %edx
callq 0x1090
leaq 0x4ad(%rip), %rdi       # 0x2130
leaq 0x3e7(%rip), %rsi       # 0x2071
leaq 0x3e6(%rip), %rcx       # 0x2077
movl $0x7f, %edx
callq 0x1090
leaq 0x47f(%rip), %rdi       # 0x2121
leaq 0x3c8(%rip), %rsi       # 0x2071
leaq 0x3c7(%rip), %rcx       # 0x2077
movl $0x70, %edx
callq 0x1090
leaq 0x47a(%rip), %rdi       # 0x213b
leaq 0x3a9(%rip), %rsi       # 0x2071
leaq 0x3a8(%rip), %rcx       # 0x2077
movl $0x73, %edx
callq 0x1090
leaq 0x450(%rip), %rdi       # 0x2130
leaq 0x38a(%rip), %rsi       # 0x2071
leaq 0x389(%rip), %rcx       # 0x2077
movl $0x72, %edx
callq 0x1090
leaq 0x4af(%rip), %rdi       # 0x21ae
leaq 0x36b(%rip), %rsi       # 0x2071
leaq 0x36a(%rip), %rcx       # 0x2077
movl $0xe8, %edx
callq 0x1090
leaq 0x460(%rip), %rdi       # 0x217e
leaq 0x34c(%rip), %rsi       # 0x2071
leaq 0x34b(%rip), %rcx       # 0x2077
movl $0xb3, %edx
callq 0x1090
leaq 0x3e4(%rip), %rdi       # 0x2121
leaq 0x32d(%rip), %rsi       # 0x2071
leaq 0x32c(%rip), %rcx       # 0x2077
movl $0xf3, %edx
callq 0x1090
leaq 0x435(%rip), %rdi       # 0x2191
leaq 0x30e(%rip), %rsi       # 0x2071
leaq 0x30d(%rip), %rcx       # 0x2077
movl $0xf4, %edx
callq 0x1090
leaq 0x448(%rip), %rdi       # 0x21c3
leaq 0x2ef(%rip), %rsi       # 0x2071
leaq 0x2ee(%rip), %rcx       # 0x2077
movl $0xf7, %edx
callq 0x1090