LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: simulation::drop_pack(primitive::blocks_t<19ul, 10ul>&, std::array<int, 10ul>&, primitive::blocks_t<3ul, 3ul> const&, primitive::output_t const&)
vector<point_t> drop_pack(blocks_t<height + pack_size, width> & field, array<int,width> & height_map, pack_t const & a_pack, output_t const & output) {
        vector<point_t> modified_blocks;
        pack_t pack = rotate(a_pack, output.rotate); // お邪魔ブロックは既に置かれているとする
        repeat (dy, 3) repeat (dx, 3) {
            if (pack.at[dx][dy] != empty_block) {
                int nx = output.x + dx;
                assert (0 <= nx and nx < width);
                field.at[nx][height_map[nx]] = pack.at[dx][dy];
                if (field.at[nx][height_map[nx]] != obstacle_block) {
                    modified_blocks.push_back(point(height_map[nx], nx));
                }
                ++ height_map[nx];
            }
        }
        return modified_blocks;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
movq (%rcx), %rdi
movl 0x4(%r8), %edx
movzbl 0x8(%rcx), %esi
callq 0x279c
leaq 0x28(%rsp), %rbp
movq %rax, (%rbp)
movb %dl, 0x8(%rbp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rbp, 0x18(%rsp)
xorl %r13d, %r13d
movb (%rbp), %al
testb %al, %al
je 0x2a9f
movslq (%r14), %rcx
leaq (%rcx,%r13), %rbx
leaq (%rbx,%rbx,8), %rdx
leaq (%rbx,%rdx,2), %rdx
addq %r12, %rdx
movslq (%r15,%rbx,4), %rsi
movb %al, (%rsi,%rdx)
movslq (%r15,%rbx,4), %rax
cmpb $0xb, (%rax,%rdx)
je 0x2a99
movl %ecx, %ecx
addq %r13, %rcx
movl %eax, %eax
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc09e
movl (%r15,%rbx,4), %eax
incl %eax
movl %eax, (%r15,%rbx,4)
incq %r13
addq $0x3, %rbp
cmpq $0x3, %r13
jne 0x2a49
movq 0x10(%rsp), %rax
incq %rax
movq 0x18(%rsp), %rbp
incq %rbp
cmpq $0x3, %rax
jne 0x2a3c
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2af6
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x2170
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: simulation::estimate_with_erasing(primitive::blocks_t<16ul, 10ul> const&)
result_t estimate_with_erasing(field_t const & field) {
        vector<pair<result_t, int> > acc = estimate_with_erasing_all(field);
        return whole(max_element, acc, [&](pair<result_t, int> const & a, pair<result_t, int> const & b) {
            return make_tuple(a.first.chain, - a.second, a.first.score) < make_tuple(b.first.chain, - b.second, b.first.score);
        })->first;
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2dab
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rax, %rdi
sete %dl
leaq 0xc(%rdi), %rcx
cmpq %rax, %rcx
sete %sil
orb %dl, %sil
movq %rdi, %rdx
je 0x317e
movq (%rdx), %rbx
testq %rdi, %rdi
je 0x3175
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rdi, %rdx
movl 0x4(%rdx), %esi
movl 0x4(%rcx), %r8d
cmpl %r8d, %esi
jge 0x3192
movq %rcx, %rdx
jmp 0x3194
jle 0x319f
addq $0xc, %rcx
cmpq %rax, %rcx
jne 0x3181
jmp 0x3160
movl 0x8(%rdx), %esi
movl 0x8(%rcx), %r8d
cmpl %esi, %r8d
jl 0x318d
movl (%rcx), %esi
setle %r8b
cmpl %esi, (%rdx)
setl %sil
andb %r8b, %sil
cmpb $0x1, %sil
je 0x318d
jmp 0x3194
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: step_photon(std::shared_ptr<photon_t> const&, primitive::blocks_t<3ul, 3ul> const&, primitive::output_t)
shared_ptr<photon_t> step_photon(shared_ptr<photon_t> const & pho, pack_t const & pack, output_t output) {
    if (not pho->cached[output.x+pack_size-1][output.rotate]) {
        int numbers = count_number_blocks(pack);
        int consumed = count_consumed_obstacles(pack, pho->obstacles);
        pack_t filled_pack = fill_obstacles(pack, consumed);
        step_photon_inner(pho, numbers, consumed, filled_pack, output.x, output.rotate);
    }
    return pho->next[output.x+pack_size-1][output.rotate];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq (%rsi), %rax
shlq $0x20, %rcx
movabsq $0x200000000, %r12      # imm = 0x200000000
addq %rcx, %r12
movq %r12, %rcx
sarq $0x1e, %rcx
addq %rax, %rcx
sarq $0x20, %r12
movq %r14, %r15
sarq $0x20, %r15
cmpb $0x0, 0x104(%r15,%rcx)
jne 0x3c70
movq %rdi, 0x10(%rsp)
movq %rsi, %rbx
movq %r14, %rcx
shrq $0x20, %rcx
movq %rcx, 0x8(%rsp)
xorl %ecx, %ecx
movq %rdx, %rsi
xorl %ebp, %ebp
xorl %edi, %edi
movb (%rsi,%rdi), %r8b
testb %r8b, %r8b
setne %r9b
cmpb $0xb, %r8b
setne %r8b
andb %r9b, %r8b
movzbl %r8b, %r8d
addl %r8d, %ebp
incq %rdi
cmpq $0x3, %rdi
jne 0x3bcd
incq %rcx
addq $0x3, %rsi
cmpq $0x3, %rcx
jne 0x3bcb
movl 0x8(%rax), %eax
xorl %esi, %esi
movq %rdx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpb $0x1, (%rdi,%r8)
adcl $0x0, %ecx
incq %r8
cmpq $0x3, %r8
jne 0x3c0d
incq %rsi
addq $0x3, %rdi
cmpq $0x3, %rsi
jne 0x3c0a
cmpl %eax, %ecx
cmovll %ecx, %eax
xorl %r13d, %r13d
testl %eax, %eax
cmovgl %eax, %r13d
movq (%rdx), %rdi
movzbl 0x8(%rdx), %esi
movl %r13d, %edx
callq 0x289d
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movb %dl, 0x8(%rcx)
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %r14d, %r8d
movq 0x8(%rsp), %r9
callq 0x393d
movq (%rbx), %rax
movq 0x10(%rsp), %rdi
shlq $0x6, %r12
addq %rax, %r12
shlq $0x4, %r15
movq 0x138(%r15,%r12), %rax
movq %rax, (%rdi)
movq 0x140(%r15,%r12), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x3cac
movq 0x11322(%rip), %rcx     # 0x14fc0
cmpb $0x0, (%rcx)
je 0x3ca8
incl 0x8(%rax)
jmp 0x3cac
lock
incl 0x8(%rax)
movq %rdi, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: step_photon_all(std::shared_ptr<photon_t> const&, primitive::blocks_t<3ul, 3ul> const&)
void step_photon_all(shared_ptr<photon_t> const & pho, pack_t const & pack) {
    int numbers = count_number_blocks(pack);
    int consumed = count_consumed_obstacles(pack, pho->obstacles);
    pack_t filled_pack = fill_obstacles(pack, consumed);
    repeat_from (x, - pack_size + 1, width) repeat (r, 4) {
        step_photon_inner(pho, numbers, consumed, filled_pack, x, r);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rsi, %rcx
xorl %ebp, %ebp
xorl %edx, %edx
movb (%rcx,%rdx), %dil
testb %dil, %dil
setne %r8b
cmpb $0xb, %dil
setne %dil
andb %r8b, %dil
movzbl %dil, %edi
addl %edi, %ebp
incq %rdx
cmpq $0x3, %rdx
jne 0x3cd8
incq %rax
addq $0x3, %rcx
cmpq $0x3, %rax
jne 0x3cd6
movq (%rbx), %rax
movl 0x8(%rax), %r14d
xorl %eax, %eax
movq %rsi, %rdx
xorl %ecx, %ecx
xorl %edi, %edi
cmpb $0x1, (%rdx,%rdi)
adcl $0x0, %ecx
incq %rdi
cmpq $0x3, %rdi
jne 0x3d1a
incq %rax
addq $0x3, %rdx
cmpq $0x3, %rax
jne 0x3d18
cmpl %r14d, %ecx
cmovll %ecx, %r14d
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
movq (%rsi), %rdi
movzbl 0x8(%rsi), %esi
movl %r14d, %edx
callq 0x289d
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movb %dl, 0x8(%r15)
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
xorl %r13d, %r13d
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
movq %r15, %rcx
movl %r12d, %r8d
movl %r13d, %r9d
callq 0x393d
incl %r13d
cmpl $0x4, %r13d
jne 0x3d6b
incl %r12d
cmpl $0xa, %r12d
jne 0x3d68
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: evaluate_photon_for_output(std::shared_ptr<photon_t> const&, int, opponent_info_t const&)
double evaluate_photon_for_output(shared_ptr<photon_t> const & pho, int base_turn, opponent_info_t const & oppo) {
    int age = pho->turn - base_turn;
    double acc = 0;
    if (is_effective_firing(pho->result.score, pho->obstacles, age, oppo)) {
        if (pho->obstacles < 40) {
            double k = pow(1 + 0.18, -age+1);
            acc += 400 + k * (1.2 * pho->result.score); // 発火した それが可能でしかも勝てるというのは大きい
            acc -= 5 * pho->dropped_obstacles;
            acc -= 3 * max(0, pho->obstacles);
        } else {
            acc = pho->result.score; // 負けてる時はもう全力で
        }
    } else {
        if (pho->result.chain >= chain_of_fire) {
            double k = pow(1 + 0.18, -age+1);
            acc += k * pho->result.score;
            acc -= 3 * max(0, min(30, pho->obstacles));
        } else {
            acc += max(0.1, 1 - 0.03 * (age - 1)) * pho->evaluation.score;
        }
    }
    return acc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movl (%rcx), %eax
movl 0x8(%rcx), %edi
subl %esi, %eax
movl 0xbc(%rcx), %esi
movl 0x24(%rdx), %r8d
movl %r8d, %r9d
shrl $0x1f, %r9d
addl %r8d, %r9d
sarl %r9d
movl $0x3c, %r10d
subl %r9d, %r10d
cmpl $0x50, %r8d
movl $0x14, %r8d
cmovll %r10d, %r8d
leal 0x14(%rdi), %r9d
cmpl %r8d, %r9d
cmovgl %r9d, %r8d
leal (%r8,%r8,4), %r8d
addl 0x20(%rdx), %r8d
cmpl %esi, %r8d
jge 0x3e9a
cmpl $0x27, %edi
jg 0x3efa
movl $0x1, %ecx
subl %eax, %ecx
cvtsi2sd %ecx, %xmm1
movsd 0xb3ab(%rip), %xmm0     # 0xf200
callq 0x2220
movq (%rbx), %rax
xorps %xmm1, %xmm1
cvtsi2sdl 0xbc(%rax), %xmm1
mulsd 0xb398(%rip), %xmm1     # 0xf208
mulsd %xmm0, %xmm1
addsd 0xb394(%rip), %xmm1     # 0xf210
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
movl 0x8(%rax), %ecx
movl 0xc(%rax), %eax
leal (%rax,%rax,4), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
jmp 0x3ee3
cmpl $0x6, 0xc0(%rcx)
jl 0x3f00
movl $0x1, %ecx
subl %eax, %ecx
cvtsi2sd %ecx, %xmm1
movsd 0xb34a(%rip), %xmm0     # 0xf200
callq 0x2220
movq (%rbx), %rax
xorps %xmm1, %xmm1
cvtsi2sdl 0xbc(%rax), %xmm1
mulsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
movl 0x8(%rax), %eax
cmpl $0x1e, %eax
movl $0x1e, %ecx
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
leal (%rax,%rax,2), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
jmp 0x3f2e
cvtsi2sd %esi, %xmm0
jmp 0x3f2e
decl %eax
cvtsi2sd %eax, %xmm1
mulsd 0xb2da(%rip), %xmm1     # 0xf1e8
addsd 0xb2da(%rip), %xmm1     # 0xf1f0
maxsd 0xb2da(%rip), %xmm1     # 0xf1f8
mulsd 0xc8(%rcx), %xmm1
xorpd %xmm0, %xmm0
addsd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: outputs_photon_from(std::shared_ptr<photon_t>, int)
vector<output_t> outputs_photon_from(shared_ptr<photon_t> pho, int turn) {
    vector<output_t> outputs;
    while (pho and pho->turn > turn) {
        outputs.push_back(pho->output);
        pho = pho->parent.lock();
    }
    if (not pho or pho->turn != turn) outputs.clear();
    whole(reverse, outputs);
    return outputs;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x4068
movq %rsi, %r14
cmpl %ebp, (%rdx)
jle 0x406c
addq $0xb4, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x400a
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4012
movq %rbx, %rdi
callq 0xe5c2
movq (%r14), %rdx
movq 0xf8(%rdx), %rcx
testq %rcx, %rcx
je 0x4042
movl 0x8(%rcx), %eax
testl %eax, %eax
je 0x4042
leal 0x1(%rax), %esi
lock
cmpxchgl %esi, 0x8(%rcx)
jne 0x4024
movl 0x8(%rcx), %eax
testl %eax, %eax
je 0x4044
movq 0xf0(%rdx), %rdx
jmp 0x4046
xorl %ecx, %ecx
xorl %edx, %edx
movq %rdx, (%r14)
movq 0x8(%r14), %rdi
movq %rcx, 0x8(%r14)
testq %rdi, %rdi
je 0x405e
callq 0x730e
movq (%r14), %rdx
testq %rdx, %rdx
jne 0x3fe4
movq (%rbx), %rax
jmp 0x4077
xorl %eax, %eax
jmp 0x4077
movq (%rbx), %rax
jne 0x4077
movq 0x8(%rbx), %rcx
jmp 0x4086
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x4086
movq %rax, 0x8(%rbx)
jmp 0x40c2
cmpq %rcx, %rax
setne %dl
addq $-0x8, %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x40c2
addq $0x8, %rax
movq -0x8(%rax), %rdx
movq (%rcx), %rsi
movq %rsi, -0x8(%rax)
movq %rdx, (%rcx)
addq $-0x8, %rcx
leaq 0x8(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x40a4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x40e1
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2170
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: prune_photon(std::shared_ptr<photon_t> const&, primitive::output_t)
void prune_photon(shared_ptr<photon_t> const & pho, output_t output) {
    assert (pho);
    repeat_from (x, - pack_size + 1, width) repeat (r, 4) {
        if (x == output.x and r == output.rotate) continue;
        pho->cached[x+pack_size-1][r] = false;
        pho->next[x+pack_size-1][r] = nullptr;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq %esi, %rax
movq %rax, (%rsp)
movq %rsi, %r15
shrq $0x20, %r15
movq $-0x2, %r12
movl $0x104, %r13d           # imm = 0x104
movl $0x140, %ebp            # imm = 0x140
movq %r12, 0x10(%rsp)
xorq (%rsp), %r12
movq %rbp, 0x8(%rsp)
xorl %r14d, %r14d
movq %r15, %rax
xorq %r14, %rax
orq %r12, %rax
je 0x4158
movq (%rbx), %rax
leaq (%rax,%r13), %rcx
movb $0x0, (%r14,%rcx)
movq (%rax,%rbp), %rdi
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rax,%rbp)
testq %rdi, %rdi
je 0x4158
callq 0x730e
incq %r14
addq $0x10, %rbp
cmpq $0x4, %r14
jne 0x412b
movq 0x10(%rsp), %r12
incq %r12
addq $0x4, %r13
movq 0x8(%rsp), %rbp
addq $0x40, %rbp
cmpq $0xa, %r12
jne 0x411a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: main
int main() {
    cout << ai_name << endl;
    cout.flush();
    config_t config; cin >> config;
    AI ai(config);
    repeat (i, config.packs.size()) {
        input_t input; cin >> input;
        if (not cin) {
#ifndef RELEASE
            cerr << "error: input failed" << endl;
#endif
            break;
        }
        output_t output = ai.think(input);
        cout << output << endl;
        cout.flush();
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
movq 0x10ee2(%rip), %rsi     # 0x15160
movq 0x10ee3(%rip), %rdx     # 0x15168
movq 0x10d3c(%rip), %rbx     # 0x14fc8
movq %rbx, %rdi
callq 0x2180
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2100
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0x10cfa(%rip), %rbx     # 0x14fd8
movq %rbx, %rdi
callq 0x2620
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x4f6a
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x43e5
xorl %r15d, %r15d
leaq 0x178(%rsp), %r14
movq 0x10cb4(%rip), %r12     # 0x14fc8
movabsq $-0x71c71c71c71c71c7, %r13 # imm = 0x8E38E38E38E38E39
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26b9
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x439f
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x5088
movq %rax, 0x20(%rsp)
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2718
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbp, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r12, %rdi
callq 0x2100
incq %r15
movq 0x8(%rsp), %rax
subq (%rsp), %rax
imulq %r13, %rax
cmpq %r15, %rax
ja 0x431e
jmp 0x43e5
movq 0x10c4a(%rip), %rbx     # 0x14ff0
leaq 0xaede(%rip), %rsi      # 0xf28b
movl $0x13, %edx
movq %rbx, %rdi
callq 0x2180
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq 0x10c18(%rip), %rdi     # 0x14ff0
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x28(%rsp), %rdi
callq 0x7266
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4405
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
xorl %eax, %eax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x441b
movq %rax, %rbx
jmp 0x4431
jmp 0x4424
jmp 0x4424
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x7266
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4447
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: simulation::result_t simulation::simulate<19ul, 10ul>(primitive::blocks_t<19ul, 10ul>&, std::array<int, 10ul>&, std::vector<point_t, std::allocator<point_t>>, int)
result_t simulate(blocks_t<H,W> & field, array<int,W> & height_map, vector<point_t> modified_blocks, int initial_chain) {
        // 2. ブロックの消滅&落下処理
        int score = 0;
        int chain = initial_chain;
        while (not modified_blocks.empty()) {
            // 検査
            vector<pair<point_t,int> > erases = collect_erases(field, modified_blocks);
            if (erases.empty()) break; // 消滅なし
            ++ chain; // ここでincrement
            // 消滅&落下
            int erase_count; tie(erase_count, modified_blocks) = apply_erases(field, erases);
            modified_blocks = erase_blocks(field, height_map, modified_blocks);
            score += calculate_score(chain, erase_count);
        }
        // 3. 4. 5. 6. お邪魔ブロック関連処理
        // nop
        // 7. ターン終了
        result_t result;
        result.score = score;
        result.chain = chain;
        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, 0x48(%rsp)
movq %rdi, %r12
xorl %ebx, %ebx
leaq 0x30(%rsp), %rbp
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x48af
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xc211
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq %rax, %r15
je 0x488f
leaq 0x10(%rsp), %rdi
movq %r12, %r13
movq %r12, %rsi
movq %rbp, %r12
movq %rbp, %rdx
callq 0xc4a1
movl 0x10(%rsp), %ebp
movq (%r14), %rdi
movq 0x10(%r14), %rsi
movups 0x18(%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%r14)
leaq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
testq %rdi, %rdi
je 0x47fb
subq %rdi, %rsi
callq 0x2170
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x47fb
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
movq 0x48(%rsp), %rdx
movq %r14, %rcx
callq 0xc693
movq (%r14), %rdi
movq 0x10(%r14), %rsi
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0x485e
subq %rdi, %rsi
callq 0x2170
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x485e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x8(%rsp), %rax
incl %eax
movq %rax, 0x8(%rsp)
cltq
movl %ebp, %ecx
shrl $0x1f, %ecx
addl %ebp, %ecx
sarl %ecx
leaq 0xa814(%rip), %rdx      # 0xf090
imull (%rdx,%rax,4), %ecx
addl %ecx, %ebx
movq 0x30(%rsp), %rdi
movq %r12, %rbp
movq %r13, %r12
jmp 0x4892
movq %r15, %rdi
testq %rdi, %rdi
je 0x48a4
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
cmpq 0x50(%rsp), %r15
jne 0x475e
movq 0x8(%rsp), %rcx
shlq $0x20, %rcx
movl %ebx, %eax
orq %rcx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x48ce
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x48e8
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: std::vector<point_t, std::allocator<point_t>> simulation::erase_blocks<16ul, 10ul>(primitive::blocks_t<16ul, 10ul>&, std::array<int, 10ul>&, std::vector<point_t, std::allocator<point_t>> const&)
vector<point_t> erase_blocks(blocks_t<H,W> & field, array<int,W> & height_map, vector<point_t> const & points_to_erase) {
        auto & at = field.at;
        array<int,W> old_height_map = height_map;
        for (point_t p : points_to_erase) {
            at[p.x][p.y] = empty_block;
            setmin(height_map[p.x], p.y);
        }
        vector<point_t> modified_blocks;
        repeat (x,W) {
            for (int y = height_map[x] + 1; y < old_height_map[x]; ++ y) {
                if (at[x][y] != empty_block) {
                    at[x][height_map[x]] = at[x][y];
                    if (at[x][height_map[x]] != obstacle_block) {
                        modified_blocks.push_back(point(height_map[x], x));
                    }
                    ++ height_map[x];
                    at[x][y] = empty_block;
                }
            }
        }
        return modified_blocks;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq 0x20(%rdx), %rax
movq %rax, 0x40(%rsp)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0x4a18
movq (%rax), %r11
movq %r11, %r10
sarq $0x20, %r10
movq %r10, %r9
shlq $0x4, %r9
addq %rsi, %r9
movslq %r11d, %r8
movb $0x0, (%r8,%r9)
cmpl %r8d, (%rbx,%r10,4)
jle 0x4a12
movl %r11d, (%rbx,%r10,4)
addq $0x8, %rax
jmp 0x49e7
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, (%rsp)
leaq 0x1(%rsi), %r8
xorl %ebp, %ebp
movslq (%rbx,%rbp,4), %r15
movl 0x20(%rsp,%rbp,4), %r14d
leal 0x1(%r15), %eax
cmpl %r14d, %eax
jge 0x4ab4
movq %rbp, %r13
shlq $0x4, %r13
addq (%rsp), %r13
movq %rbp, %rax
shlq $0x20, %rax
movq %rax, 0x10(%rsp)
decl %r14d
movq %r8, 0x8(%rsp)
movb (%r8,%r15), %al
testb %al, %al
je 0x4aac
movslq (%rbx,%rbp,4), %rcx
movb %al, (%r13,%rcx)
movslq (%rbx,%rbp,4), %rax
cmpb $0xb, (%r13,%rax)
je 0x4aa2
movl %eax, %eax
orq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rdi, %r12
leaq 0x18(%rsp), %rsi
callq 0xc09e
movl (%rbx,%rbp,4), %eax
movq %r12, %rdi
movq 0x8(%rsp), %r8
incl %eax
movl %eax, (%rbx,%rbp,4)
movb $0x0, (%r8,%r15)
incq %r15
cmpl %r15d, %r14d
jne 0x4a61
incq %rbp
addq $0x10, %r8
cmpq $0xa, %rbp
jne 0x4a30
movq %rdi, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4af0
movq 0x10(%r12), %rsi
subq %rdi, %rsi
callq 0x2170
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: std::ostream& primitive::operator<<<16ul, 10ul>(std::ostream&, primitive::blocks_t<16ul, 10ul> const&)
ostream & operator << (ostream & out, blocks_t<H, W> const & a) {
        repeat_reverse (y, H) {
            if (y != H-1) out << endl;
            repeat (x, W) {
                switch (a.at[x][y]) {
                    case empty_block: out << ' '; break;
                    case obstacle_block: out << '#'; break;
                    default: out << int(a.at[x][y]); break;
                }
            }
        }
        return out;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0xf, %r13d
leaq 0x7(%rsp), %r15
leaq 0x6(%rsp), %r12
cmpq $0xf, %r13
je 0x78df
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl $0xf, %ebp
movzbl (%r14,%rbp), %eax
cmpl $0xb, %eax
je 0x7904
testl %eax, %eax
jne 0x791b
movb $0x20, 0x6(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x7914
movb $0x23, 0x7(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
jmp 0x7926
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2210
addq $0x10, %rbp
cmpq $0xaf, %rbp
jne 0x78e4
decq %r14
subq $0x1, %r13
jae 0x78b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iZhangHui[P]CppPrimer/CH09_SequentialContainers/examples/refreshIter.cc
// Function: main
int main()
{
    // silly loop to remove even-valued elements
    // and insert a duplicate of odd-valued elements
    vector<int> vi = {0,1,2,3,4,5,6,7,8,9};
    printVec(vi);

    // we call begin, not cbegin because we're changing vi
    auto iter = vi.begin();
    while (iter != vi.end()) {
        if (*iter % 2) {    // if the element is odd
            iter = vi.insert(iter, *iter);  // duplicate  it
            iter += 2; // advance past this element and the new one
        } else
            iter = vi.erase(iter);          // remove even elements
            // don't advance the iterator;
            // iter denotes the element after the one we erased
    }
    printVec(vi);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movups 0xd4f(%rip), %xmm0      # 0x2014
leaq -0x60(%rbp), %rsi
movaps %xmm0, 0x10(%rsi)
movups 0xd30(%rip), %xmm0      # 0x2004
movaps %xmm0, (%rsi)
movabsq $0x900000008, %rax      # imm = 0x900000008
movq %rax, 0x20(%rsi)
leaq -0x30(%rbp), %rbx
leaq -0x11(%rbp), %rcx
movl $0xa, %edx
movq %rbx, %rdi
callq 0x13a8
movq %rbx, %rdi
callq 0x124c
movq -0x30(%rbp), %rbx
movq -0x28(%rbp), %rdx
cmpq %rdx, %rbx
je 0x135b
leaq -0x30(%rbp), %r14
testb $0x1, (%rbx)
jne 0x133d
movq %rbx, %rsi
addq $0x4, %rsi
cmpq %rdx, %rsi
je 0x1333
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x10d0
movq -0x28(%rbp), %rdx
addq $-0x4, %rdx
movq %rdx, -0x28(%rbp)
jmp 0x1356
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x13ee
movq %rax, %rbx
addq $0x8, %rbx
movq -0x28(%rbp), %rdx
cmpq %rdx, %rbx
jne 0x1313
leaq -0x30(%rbp), %rdi
callq 0x124c
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1379
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1388
jmp 0x1388
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x13a0
movq -0x20(%rbp), %rsi
subq %rdi, %rsi
callq 0x10b0
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O3/caelumcao[P]CWebSocketServer/cresponse.cpp
// Function: CResponse::process(int, char const*, unsigned int)
int CResponse::process(int fd, const char *buf, unsigned int len)
{
    char msg[MAXLINE];
    strncpy(msg, buf, len);
    msg[len] = '\0';
    CProtocol cp;
    cp.encode(msg, len);
    return write(fd, msg, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movl %esi, %ebx
leaq 0xc(%rsp), %r14
movl %ecx, (%r14)
movl %ecx, %r15d
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq 0x2130
movb $0x0, 0x10(%rsp,%r15)
leaq 0x1018(%rsp), %r15
movq %r15, %rdi
callq 0x6f56
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6f72
movl (%r14), %edx
movl %ebx, %edi
movq %r12, %rsi
callq 0x20d0
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/logging.cc
// Function: hcproxy::internal_logging::LogStreamBase::Flush()
void LogStreamBase::Flush() {
  std::time_t time = std::time(nullptr);
  char time_str[64];
  if (std::strftime(time_str, sizeof(time_str), "%F %T", std::localtime(&time)) == 0) {
    std::strcpy(time_str, "undef");
  }
  std::string msg = strm_->str();
  std::fprintf(stderr, "[%s %s %s:%d] %s\n", time_str, Str(severity_), file_, line_, msg.c_str());
  strm_.reset();
  errno = errno_;
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x15930
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
callq 0x15880
leaq 0xba8f1(%rip), %rdx     # 0xd02dc
leaq 0x30(%rsp), %rdi
pushq $0x40
popq %rsi
movq %rax, %rcx
callq 0x158c0
testq %rax, %rax
jne 0x15a0f
movw $0x66, 0x34(%rsp)
movl $0x65646e75, 0x30(%rsp) # imm = 0x65646E75
movq 0x18(%rbx), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0x91a30
movq 0xfb460(%rip), %rax     # 0x110e88
movq (%rax), %rdi
movl 0x14(%rbx), %eax
cmpq $0x3, %rax
ja 0x15a44
leaq 0xba8dd(%rip), %rdx     # 0xd0318
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
jmp 0x15a4b
leaq 0xba8c5(%rip), %rcx     # 0xd0310
movq 0x8(%rbx), %r8
movl 0x10(%rbx), %r9d
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq 0xba885(%rip), %rsi     # 0xd02e8
leaq 0x30(%rsp), %rdx
xorl %eax, %eax
callq 0x15870
movq 0x18(%rbx), %rdi
andq $0x0, 0x18(%rbx)
testq %rdi, %rdi
je 0x15a83
movq (%rdi), %rax
callq *0x8(%rax)
movl (%rbx), %ebx
callq 0x15640
movl %ebx, (%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15aa7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x210c0
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/list.cc
// Function: hcproxy::List::AddTail(hcproxy::Node*)
void List::AddTail(Node* node) {
  CHECK(node);
  CHECK(!node->prev_);
  CHECK(!node->next_);
  if (tail_) {
    CHECK(head_);
    CHECK(!tail_->next_);
    tail_->next_ = node;
  } else {
    CHECK(!head_);
    head_ = node;
  }
  node->prev_ = tail_;
  node->next_ = nullptr;
  tail_ = node;
  CHECK(head_ && tail_);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x18545
cmpq $0x0, (%rsi)
jne 0x18591
cmpq $0x0, 0x8(%rsi)
jne 0x185dd
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x18521
testq %rcx, %rcx
je 0x18629
cmpq $0x0, 0x8(%rax)
jne 0x18675
leaq 0x8(%rax), %rdx
jmp 0x1852d
movq %rdi, %rdx
testq %rcx, %rcx
jne 0x186be
movq %rsi, (%rdx)
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movq %rsi, 0x8(%rdi)
addq $0x20, %rsp
popq %rbx
retq
leaq 0xb6ab8(%rip), %rsi     # 0xcf004
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x16, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb6adc(%rip), %rsi     # 0xcf048
movl $0x4, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xbbd49(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x18711
leaq 0xb6a6c(%rip), %rsi     # 0xcf004
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x17, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb6a58(%rip), %rsi     # 0xcf010
movl $0xc, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xbbcfd(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x18711
leaq 0xb6a20(%rip), %rsi     # 0xcf004
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x18, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb6a19(%rip), %rsi     # 0xcf01d
movl $0xc, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xbbcb1(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x18711
leaq 0xb69d4(%rip), %rsi     # 0xcf004
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x1a, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb69e9(%rip), %rsi     # 0xcf039
movl $0x5, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xbbc65(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x18711
leaq 0xb6988(%rip), %rsi     # 0xcf004
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x1b, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb698e(%rip), %rsi     # 0xcf02a
movl $0xd, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xbbc19(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x18711
leaq 0xb693f(%rip), %rsi     # 0xcf004
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x1e, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb6953(%rip), %rsi     # 0xcf038
movl $0x6, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xbbbd0(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x18711
jmp 0x18711
jmp 0x18711
jmp 0x18711
jmp 0x18711
jmp 0x18711
movq %rsp, %rdi
callq 0x18a24
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/parser.cc
// Function: hcproxy::Parser::ParseRequest(int, std::function<void (std::basic_string_view<char, std::char_traits<char>>)>)
void Parser::ParseRequest(int fd, Callback cb) {
  CHECK(fd >= 0);
  CHECK(cb);
  auto* eh = new ParseEventHandler(opt_, fd, std::move(cb));
  event_loop_.ScheduleOrRun([this, eh]() { event_loop_.Add(eh, EPOLLIN); });
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testl %esi, %esi
js 0x18ba6
movq %rdx, %r15
movq %rdi, 0x40(%rsp)
movq 0x10(%rdx), %r12
testq %r12, %r12
je 0x18bf1
movl %esi, %ebp
leaq 0x10(%r15), %r14
movl $0x78, %edi
callq 0x22050
movq %rax, %rbx
movq 0x18(%r15), %r13
movq %r13, 0x18(%rsp)
movups (%r15), %xmm0
movaps %xmm0, (%rsp)
movq %r12, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %rax, %rdi
movl %ebp, %esi
callq 0x19398
leaq 0xf1a14(%rip), %rax     # 0x10a510
movq %rax, (%rbx)
leaq 0x38(%rbx), %r15
movq %r13, 0x50(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, 0x38(%rbx)
movq %r12, 0x48(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rbx, %rdi
addq $0x58, %rdi
movq 0x40(%rsp), %r14
movq (%r14), %rsi
leaq 0x20(%rsp), %rdx
callq 0x19418
movq $0x0, 0x70(%rbx)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x18b53
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%r14), %rdi
leaq 0x48(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, 0x8(%rsi)
leaq 0x7f0(%rip), %rax       # 0x1935a
movq %rax, 0x18(%rsi)
leaq 0x7fb(%rip), %rax       # 0x19370
movq %rax, 0x10(%rsi)
callq 0x20ad2
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x18b97
leaq 0x48(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb6513(%rip), %rsi     # 0xcf0c0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl $0x7e, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb72d2(%rip), %rsi     # 0xcfea1
movl $0x7, %edx
callq 0x8b8f0
movq 0x38(%rsp), %rdi
leaq 0xbb6e6(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x18c48
leaq 0xb64c8(%rip), %rsi     # 0xcf0c0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl $0x7f, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb64b4(%rip), %rsi     # 0xcf0ce
movl $0x2, %edx
callq 0x8b8f0
movq 0x38(%rsp), %rdi
leaq 0xbb69b(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x18c48
jmp 0x18cc7
jmp 0x18cc7
jmp 0x18c48
leaq 0x20(%rsp), %rdi
callq 0x18a24
movq %rax, %r14
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x18cbf
leaq 0x48(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x18cbf
jmp 0x18cc7
movq %rax, %r14
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x18c8b
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x19478
movq 0x10(%rsp), %r12
testq %r12, %r12
jne 0x18ca4
jmp 0x18cb2
jmp 0x18cc7
movq %rax, %r14
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%r12
movl $0x78, %esi
movq %rbx, %rdi
callq 0x210c0
movq %r14, %rdi
callq 0xcc750
movq %rax, %rdi
callq 0x18a37
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/connector.cc
// Function: hcproxy::(anonymous namespace)::ConnectEventHandler::Finish(hcproxy::EventLoop*, int)
void Finish(EventLoop* loop, int err) {
    loop->Remove(this);
    if (err == 0) {
      LOG(INFO) << "[" << fd() << "] connected";
      cb_(fd());
    } else {
      LOG(WARN) << "[" << fd() << "] unable to connect: " << Errno(err);
      CHECK(close(fd()) == 0) << Errno();
      cb_(-1);
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x206de
leaq 0xb51a8(%rip), %rsi     # 0xcf609
movq %rsp, %r14
movq %r14, %rdi
testl %ebp, %ebp
je 0x1a4db
movl $0x47, %edx
movl $0x1, %ecx
callq 0x2003c
movq 0x18(%r14), %rdi
leaq 0xb4cbe(%rip), %rsi     # 0xcf143
movl $0x1, %edx
callq 0x8b8f0
movl 0x18(%rbx), %esi
movq 0x18(%rsp), %rdi
callq 0x8c1c0
movq 0x18(%rsp), %rdi
leaq 0xb5206(%rip), %rsi     # 0xcf6ae
movl $0x15, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
movl %ebp, %esi
callq 0x200db
movq %rsp, %rdi
callq 0x19574
movl 0x18(%rbx), %edi
callq 0x15140
testl %eax, %eax
jne 0x1a54f
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
jmp 0x1a530
movl $0x44, %edx
xorl %ecx, %ecx
callq 0x2003c
movq 0x18(%r14), %rdi
leaq 0xb4c51(%rip), %rsi     # 0xcf143
movl $0x1, %edx
callq 0x8b8f0
movl 0x18(%rbx), %esi
movq 0x18(%rsp), %rdi
callq 0x8c1c0
movq 0x18(%rsp), %rdi
leaq 0xb518d(%rip), %rsi     # 0xcf6a2
movl $0xb, %edx
callq 0x8b8f0
movq %rsp, %r14
movq %r14, %rdi
callq 0x1959e
movl 0x18(%rbx), %eax
movl %eax, (%r14)
cmpq $0x0, 0x48(%rbx)
je 0x1a54a
leaq 0x38(%rbx), %rdi
movq %rsp, %rsi
callq *0x50(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1731e
leaq 0xb50b3(%rip), %rsi     # 0xcf609
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x48, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb514e(%rip), %rsi     # 0xcf6c4
movl $0x10, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb9d3f(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x200db
jmp 0x1a5a7
jmp 0x1a5b3
movq %rsp, %rdi
callq 0x18a24
jmp 0x1a5c0
jmp 0x1a5c0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1959e
jmp 0x1a5cb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19574
movq %rbx, %rdi
callq 0xcc750
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/thread_pool.cc
// Function: hcproxy::ThreadPool::~ThreadPool()
ThreadPool::~ThreadPool() {
  {
    std::lock_guard<std::mutex> lock(mutex_);
    exit_ = true;
  }
  cv_.notify_all();
  sleeper_cv_.notify_one();
  for (std::thread& t : threads_) t.join();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x15820
testl %eax, %eax
jne 0x1c229
movb $0x1, 0x8(%rbx)
movq %r14, %rdi
callq 0x158d0
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x2e600
leaq 0x68(%rbx), %r15
movq %r15, %rdi
callq 0x2e5f0
movq 0xb8(%rbx), %r12
movq 0xc0(%rbx), %r13
cmpq %r13, %r12
je 0x1c1f5
movq %r12, %rdi
callq 0x9eb70
addq $0x8, %r12
jmp 0x1c1e2
leaq 0xb8(%rbx), %rdi
callq 0x1c636
addq $0x98, %rbx
movq %rbx, %rdi
callq 0x1c672
movq %r15, %rdi
callq 0x2e5c0
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2e5c0
movl %eax, %edi
callq 0x173c5
jmp 0x1c232
movq %rax, %rdi
callq 0x18a37
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/thread_pool.cc
// Function: hcproxy::ThreadPool::Schedule(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>, std::function<void ()>)
void ThreadPool::Schedule(Time t, std::function<void()> f) {
  std::condition_variable* wake = nullptr;
  {
    std::unique_lock<std::mutex> lock(mutex_);
    work_.push(Work{std::move(t), ++last_idx_, std::move(f)});
    if (work_.top().idx == last_idx_) wake = have_sleeper_ ? &sleeper_cv_ : &cv_;
  }
  if (wake) wake->notify_one();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rsp, %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x1b4ea
movb $0x1, 0x8(%r14)
leaq 0x98(%rbx), %rdi
leaq 0x20(%rsp), %r14
movq %r12, -0x10(%r14)
movq (%rbx), %rax
incq %rax
movq %rax, (%rbx)
movq %rax, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x18(%r15), %rax
movq %rax, 0x18(%r14)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x1c2bd
movups (%r15), %xmm1
addq $0x10, %r15
movups %xmm1, (%r14)
movq %rax, 0x30(%rsp)
movups %xmm0, (%r15)
leaq 0x10(%rsp), %rsi
callq 0x1cd7e
movq 0x98(%rbx), %rdi
movq 0xa0(%rbx), %rsi
callq 0x1cc4b
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1c2f1
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq 0x98(%rbx), %rax
movq 0x8(%rax), %r14
movq (%rbx), %r15
movb 0x9(%rbx), %bpl
movq %rsp, %rdi
callq 0x1b4d4
cmpq %r15, %r14
jne 0x1c328
leaq 0x38(%rbx), %rax
addq $0x68, %rbx
testb $0x1, %bpl
cmoveq %rax, %rbx
movq %rbx, %rdi
callq 0x2e5f0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1c361
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x1c351
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq %rsp, %rdi
callq 0x1b4d4
movq %rbx, %rdi
callq 0xcc750
movq %rax, %rdi
callq 0x18a37
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/hcproxy.cc
// Function: main
int main(int argc, char* argv[]) {
  if (argc != 1) {
    std::cerr << "Usage: " << argv[0] << "\n\n"
              << "To customize, modify `opt` in `main()` (defined in " << __FILE__ << ")"
              << " and recompile." << std::endl;
    return 1;
  }
  hcproxy::Options opt;
  hcproxy::RunProxy(opt);
  LOG(FATAL) << "RunProxy is not supposed to return";
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
cmpl $0x1, %edi
je 0x1d113
movq %rsi, %r14
leaq 0xf5417(%rip), %rbx     # 0x112440
leaq 0xb2c1a(%rip), %rsi     # 0xcfc4a
movl $0x7, %edx
movq %rbx, %rdi
callq 0x8b8f0
movq (%r14), %r14
testq %r14, %r14
je 0x1d061
movq %r14, %rdi
callq 0x153a0
leaq 0xf53ec(%rip), %rdi     # 0x112440
movq %r14, %rsi
movq %rax, %rdx
callq 0x8b8f0
jmp 0x1d078
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x6c770
leaq 0xb2bd3(%rip), %rsi     # 0xcfc52
movl $0x2, %edx
movq %rbx, %rdi
callq 0x8b8f0
leaq 0xb2bc2(%rip), %rsi     # 0xcfc55
movl $0x33, %edx
movq %rbx, %rdi
callq 0x8b8f0
leaq 0xb2be2(%rip), %rsi     # 0xcfc89
movl $0xe, %edx
movq %rbx, %rdi
callq 0x8b8f0
leaq 0xb3330(%rip), %rsi     # 0xd03eb
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8b8f0
leaq 0xb2bc9(%rip), %rsi     # 0xcfc98
movl $0xf, %edx
movq %rbx, %rdi
callq 0x8b8f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6ca40
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8b3f0
movq %rax, %rdi
callq 0x8a9c0
movl $0x1, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movl $0x2e302e30, (%rax)     # imm = 0x2E302E30
movl $0x302e302e, 0x3(%rax)  # imm = 0x302E302E
movq $0x7, -0x8(%rax)
movb $0x0, 0x7(%rax)
movw $0x22b9, 0x10(%rax)     # imm = 0x22B9
movq $0x40, 0x18(%rax)
movq $0x400, 0x20(%rax)      # imm = 0x400
movabsq $0x12a05f200, %rcx      # imm = 0x12A05F200
movq %rcx, 0x28(%rax)
movq $0x8, 0x30(%rax)
movabsq $0x45d964b800, %rcx     # imm = 0x45D964B800
movq %rcx, 0x38(%rax)
movabsq $0x1176592e00, %rcx     # imm = 0x1176592E00
movq %rcx, 0x40(%rax)
movabsq $0x34630b8a000, %rcx    # imm = 0x34630B8A000
movq %rcx, 0x48(%rax)
movabsq $0x2540be400, %rcx      # imm = 0x2540BE400
movq %rcx, 0x50(%rax)
movq $0x1000, 0x58(%rax)     # imm = 0x1000
movq $0x2000, 0x60(%rax)     # imm = 0x2000
movabsq $0x8bb2c97000, %rcx     # imm = 0x8BB2C97000
movq %rcx, 0x68(%rax)
xorl %ecx, %ecx
movq %rcx, 0x90(%rax)
leaq 0xb8(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq %rcx, 0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x1d209
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d4de
movq %rbx, %rdi
callq 0xcc750
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/epoll.cc
// Function: hcproxy::EPoll::Add(int, int, void*)
void EPoll::Add(int fd, int events, void* data) {
  epoll_event event = {};
  event.events = events;
  event.data.ptr = data;
  CHECK(epoll_ctl(epoll_, EPOLL_CTL_ADD, fd, &event) == 0) << Errno();
  ++total_events_;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl %esi, %eax
movq %rdi, %rbx
leaq 0x24(%rsp), %r8
movl %edx, (%r8)
movq %rcx, 0x4(%r8)
movl (%rdi), %edi
movl $0x1, %esi
movl %eax, %edx
movq %r8, %rcx
callq 0x154e0
testl %eax, %eax
jne 0x1dda7
incq 0x20(%rbx)
addq $0x30, %rsp
popq %rbx
retq
leaq 0xb1f7b(%rip), %rsi     # 0xcfd29
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x23, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb1f9c(%rip), %rsi     # 0xcfd6a
movl $0x31, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb64e7(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x200db
jmp 0x1ddfd
movq %rsp, %rdi
callq 0x18a24
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/epoll.cc
// Function: hcproxy::EPoll::Remove(int)
void EPoll::Remove(int fd) {
  CHECK(total_events_ > 0);
  epoll_event event;
  CHECK(epoll_ctl(epoll_, EPOLL_CTL_DEL, fd, &event) == 0) << Errno();
  --total_events_;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x1de36
movl %esi, %edx
movq %rdi, %rbx
movl (%rdi), %edi
leaq 0x24(%rsp), %rcx
movl $0x2, %esi
callq 0x154e0
testl %eax, %eax
jne 0x1de7f
decq 0x20(%rbx)
addq $0x30, %rsp
popq %rbx
retq
leaq 0xb1eec(%rip), %rsi     # 0xcfd29
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x28, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb1f3f(%rip), %rsi     # 0xcfd9c
movl $0x11, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb6458(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x1ded7
leaq 0xb1ea3(%rip), %rsi     # 0xcfd29
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x2a, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb1f08(%rip), %rsi     # 0xcfdae
movl $0x31, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb640f(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x200db
jmp 0x1ded7
jmp 0x1ded7
movq %rsp, %rdi
callq 0x18a24
nop
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/epoll.cc
// Function: hcproxy::EPoll::Modify(int, int, void*)
void EPoll::Modify(int fd, int events, void* data) {
  CHECK(total_events_ > 0);
  epoll_event event = {};
  event.events = events;
  event.data.ptr = data;
  CHECK(epoll_ctl(epoll_, EPOLL_CTL_MOD, fd, &event) == 0) << Errno();
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x1df15
movl %esi, %eax
leaq 0x24(%rsp), %r8
movl %edx, (%r8)
movq %rcx, 0x4(%r8)
movl (%rdi), %edi
movl $0x3, %esi
movl %eax, %edx
movq %r8, %rcx
callq 0x154e0
testl %eax, %eax
jne 0x1df5e
addq $0x30, %rsp
popq %rbx
retq
leaq 0xb1e0d(%rip), %rsi     # 0xcfd29
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x2f, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb1e60(%rip), %rsi     # 0xcfd9c
movl $0x11, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb6379(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
jmp 0x1dfb6
leaq 0xb1dc4(%rip), %rsi     # 0xcfd29
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x33, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb1e5b(%rip), %rsi     # 0xcfde0
movl $0x31, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb6330(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x200db
jmp 0x1dfb6
jmp 0x1dfb6
movq %rsp, %rdi
callq 0x18a24
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]hcproxy/src/epoll.cc
// Function: hcproxy::EPoll::Wait(std::optional<std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)
void EPoll::Wait(std::optional<Duration> timeout) {
  if (total_events_ > events_.size()) {
    events_.resize(total_events_);
    events_.resize(events_.capacity());
  }
  int ms = timeout ? std::max<int>(0, ceil<milliseconds>(*timeout).count()) : -1;
  CHECK((ready_events_ = epoll_wait(epoll_, events_.data(), events_.size(), ms)) >= 0) << Errno();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %rsi
subq 0x8(%rdi), %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rax
cmpq %rax, %rsi
jbe 0x1e019
leaq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0x1e0ea
movq 0x18(%rbx), %rsi
subq 0x8(%rbx), %rsi
sarq $0x2, %rsi
imulq %r12, %rsi
movq %r15, %rdi
callq 0x1e0ea
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %bpl
je 0x1e05b
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r14, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
xorl %esi, %esi
cmpq %r14, %rax
setl %sil
addl %edx, %esi
xorl %ecx, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
movl (%rbx), %edi
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
subq %rsi, %rax
shrq $0x2, %rax
imull $0xaaaaaaab, %eax, %edx # imm = 0xAAAAAAAB
callq 0x156d0
movl %eax, 0x28(%rbx)
testl %eax, %eax
js 0x1e08b
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb1c97(%rip), %rsi     # 0xcfd29
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x3c, %edx
movl $0x3, %ecx
callq 0x2003c
movq 0x18(%rbx), %rdi
leaq 0xb1d60(%rip), %rsi     # 0xcfe12
movl $0x4d, %edx
callq 0x8b8f0
movq 0x18(%rsp), %rdi
leaq 0xb6203(%rip), %rsi     # 0xd42cb
movl $0x2, %edx
callq 0x8b8f0
movl (%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x200db
jmp 0x1e0e1
movq %rsp, %rdi
callq 0x18a24
nop