LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x7de0
movq -0x58(%rbp), %rdi
callq 0x7d10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x59(%rbp)
jne 0x5152
jmp 0x5166
movq -0x58(%rbp), %rdi
callq 0x76d0
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x516f
jmp 0x51db
movq -0x58(%rbp), %rdi
callq 0x76d0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0xb4, %rsi
callq 0x7e00
jmp 0x518d
movq -0x58(%rbp), %rdi
callq 0x76d0
movq %rax, %rsi
addq $0xf0, %rsi
leaq -0x38(%rbp), %rdi
callq 0x7d30
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7d60
leaq -0x38(%rbp), %rdi
callq 0x78c0
jmp 0x513b
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7e90
jmp 0x522f
movq -0x58(%rbp), %rdi
callq 0x7d10
testb $0x1, %al
jne 0x51ea
jmp 0x51fa
movq -0x58(%rbp), %rdi
callq 0x76d0
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x5203
movq -0x50(%rbp), %rdi
callq 0x7e70
movq -0x50(%rbp), %rsi
leaq -0x39(%rbp), %rdi
callq 0x5240
jmp 0x5212
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x5225
movq -0x50(%rbp), %rdi
callq 0x7e90
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22f0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0xfffffffe, -0x14(%rbp) # imm = 0xFFFFFFFE
cmpl $0xa, -0x14(%rbp)
jge 0x536a
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x535a
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x52c7
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0x52c7
jmp 0x534c
movq -0x10(%rbp), %rdi
callq 0x76d0
movq %rax, %rdi
addq $0x104, %rdi            # imm = 0x104
movl -0x14(%rbp), %eax
addl $0x3, %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x7a20
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x7a50
movb $0x0, (%rax)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7d90
movq -0x10(%rbp), %rdi
callq 0x76d0
movq %rax, %rdi
addq $0x138, %rdi            # imm = 0x138
movl -0x14(%rbp), %eax
addl $0x3, %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x7b30
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x7b60
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x7d60
leaq -0x28(%rbp), %rdi
callq 0x78c0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x52a8
jmp 0x535c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5297
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movl $0x0, -0x4(%rbp)
movq 0x32a1f(%rip), %rdi     # 0x37fc8
movq %rdi, -0x2f0(%rbp)
leaq 0x32c29(%rip), %rsi     # 0x381e0
callq 0x21a0
movq %rax, %rdi
movq 0x329e2(%rip), %rsi     # 0x37fa8
callq 0x21e0
movq -0x2f0(%rbp), %rdi
callq 0x2120
leaq -0x20(%rbp), %rdi
movq %rdi, -0x2e8(%rbp)
callq 0x7fa0
movq -0x2e8(%rbp), %rsi
movq 0x329e3(%rip), %rdi     # 0x37fd8
callq 0x27c0
jmp 0x55fc
leaq -0x180(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7fc0
jmp 0x560e
movl $0x0, -0x184(%rbp)
movslq -0x184(%rbp), %rax
movq %rax, -0x2f8(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8110
movq %rax, %rcx
movq -0x2f8(%rbp), %rax
cmpq %rcx, %rax
jae 0x5764
movq 0x3298f(%rip), %rdi     # 0x37fd8
leaq -0x2d4(%rbp), %rsi
callq 0x2860
jmp 0x5657
movq 0x3297a(%rip), %rdi     # 0x37fd8
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x20c0
movb %al, -0x2f9(%rbp)
jmp 0x5675
movb -0x2f9(%rbp), %al
testb $0x1, %al
jne 0x5681
jmp 0x56e5
movq 0x32968(%rip), %rdi     # 0x37ff0
leaq 0x20bbc(%rip), %rsi     # 0x2624b
callq 0x21b0
movq %rax, -0x308(%rbp)
jmp 0x569d
movq -0x308(%rbp), %rdi
movq 0x328fd(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x56b2
jmp 0x5764
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x578c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa8e0
jmp 0x578c
leaq -0x180(%rbp), %rdi
leaq -0x2d4(%rbp), %rsi
callq 0x8140
movq %rax, -0x310(%rbp)
jmp 0x5701
movq -0x310(%rbp), %rax
movq %rax, -0x2dc(%rbp)
movq 0x328b2(%rip), %rdi     # 0x37fc8
leaq -0x2dc(%rbp), %rsi
callq 0x28e0
movq %rax, -0x318(%rbp)
jmp 0x572b
movq -0x318(%rbp), %rdi
movq 0x3286f(%rip), %rsi     # 0x37fa8
callq 0x21e0
jmp 0x5740
movq 0x32881(%rip), %rdi     # 0x37fc8
callq 0x2120
jmp 0x574e
jmp 0x5750
movl -0x184(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x184(%rbp)
jmp 0x5618
movl $0x0, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
callq 0xa8e0
leaq -0x20(%rbp), %rdi
callq 0xa970
movl -0x4(%rbp), %eax
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xa970
movq -0x28(%rbp), %rdi
callq 0x22f0
nop
// File: kmyk[P]codevs-for-student-2016/Main.cpp
// Function: std::istream& primitive::operator>><3ul, 3ul>(std::istream&, primitive::blocks_t<3ul, 3ul>&)
istream & operator >> (istream & in, blocks_t<H, W> & a) {
        repeat_reverse (y, H) {
            repeat (x, W) {
                int c; in >> c; a.at[x][y] = c;
                assert ((a.at[x][y] == 0 and 0 == empty_block)
                        or (1 <= a.at[x][y] and a.at[x][y] <= 9)
                        or (a.at[x][y] == 11 and 11 == obstacle_block));
            }
        }
        string s; in >> s; assert (s == "END");
        return in;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6487
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x3, %rax
jae 0x647a
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x2110
movl -0x1c(%rbp), %eax
movb %al, -0x4d(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x6600
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6630
movb -0x4d(%rbp), %cl
movb %cl, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6434
jmp 0x647c
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6427
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2260
movq -0x58(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x2250
jmp 0x64a3
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2348
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2348
movq -0x48(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: kmyk[P]codevs-for-student-2016/Main.cpp
// Function: std::array<int, 10ul> simulation::make_height_map<16ul, 10ul>(primitive::blocks_t<16ul, 10ul> const&)
array<int,W> make_height_map(blocks_t<H,W> const & field) {
        array<int,W> h;
        repeat (x,W) {
            int y = 0;
            while (y < H and field.at[x][y] != empty_block) ++ y;
            h[x] = y;
        }
        return h;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0xa, %rax
jae 0x69d7
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x10, %rcx
movb %al, -0x21(%rbp)
jae 0x69a0
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x68e0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x6910
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x69a9
jmp 0x69b4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x696c
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x67f0
movl -0x28(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x695b
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xb0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x1c6c0
xorb $-0x1, %al
testb $0x1, %al
jne 0x6a35
jmp 0x6b44
movq -0xb0(%rbp), %rdx
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1c700
leaq -0x48(%rbp), %rdi
callq 0x1cad0
testb $0x1, %al
jne 0x6a58
jmp 0x6a64
movl $0x3, -0x4c(%rbp)
jmp 0x6b14
movl -0x2c(%rbp), %eax
incl %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x1cb10
jmp 0x6a7f
movq -0xb0(%rbp), %rdx
leaq -0x90(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x1cd50
movq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x1cd90
movq -0xb8(%rbp), %rdi
callq 0x1cdf0
movq -0xb0(%rbp), %rcx
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0x1ce10
jmp 0x6add
movq -0xb0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x70d0
leaq -0xa8(%rbp), %rdi
callq 0x6850
movl -0x2c(%rbp), %edi
movl -0x50(%rbp), %esi
callq 0x2d90
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1d0d0
movl -0x4c(%rbp), %eax
testl %eax, %eax
je 0x6b28
jmp 0x6b26
jmp 0x6b44
jmp 0x6a1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1d0d0
jmp 0x6b5d
movl -0x28(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xf, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xeb5c
movslq -0x14(%rbp), %rax
cmpq $0xf, %rax
je 0xeaab
movq -0x8(%rbp), %rdi
movq 0x29502(%rip), %rsi     # 0x37fa8
callq 0x21e0
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0xa, %rax
jae 0xeb4c
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x68e0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6910
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xeaef
jmp 0xeae5
movl -0x1c(%rbp), %eax
subl $0xb, %eax
je 0xeaff
jmp 0xeb0f
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x2230
jmp 0xeb3c
movq -0x8(%rbp), %rdi
movl $0x23, %esi
callq 0x2230
jmp 0xeb3c
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x68e0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6910
movq -0x28(%rbp), %rdi
movsbl (%rax), %esi
callq 0x22d0
jmp 0xeb3e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xeab2
jmp 0xeb4e
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xea87
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH09_SequentialContainers/examples/refreshIter.cc
// Function: printVec(std::vector<int, std::allocator<int>> const&)
void printVec(const vector<int>& vi)
{
    // print the vector's elements
    auto iter = vi.begin();
    while (iter != vi.end())
        cout << *iter++ << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1520
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x14e0
testb $0x1, %al
jne 0x1279
jmp 0x12b0
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x1550
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1590
movl (%rax), %esi
movq 0x4d3e(%rip), %rdi      # 0x5fd8
callq 0x10e0
movq %rax, %rdi
movq 0x4d1f(%rip), %rsi      # 0x5fc8
callq 0x10b0
jmp 0x1259
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movabsq $0x900000008, %rax      # imm = 0x900000008
movq %rax, -0x40(%rbp)
movups 0x1d2d(%rip), %xmm0     # 0x3014
movaps %xmm0, -0x50(%rbp)
movups 0x1d12(%rip), %xmm0     # 0x3004
movaps %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0xa, -0x28(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x15b0
movq -0xb0(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x15d0
jmp 0x1330
leaq -0x61(%rbp), %rdi
callq 0x1650
leaq -0x20(%rbp), %rdi
callq 0x1240
jmp 0x1344
leaq -0x20(%rbp), %rdi
callq 0x1670
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x16e0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x16a0
testb $0x1, %al
jne 0x137a
jmp 0x1476
leaq -0x80(%rbp), %rdi
callq 0x1710
movl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x142f
leaq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x1930
movq -0xc0(%rbp), %rdi
callq 0x1710
movq %rax, %rdx
movq -0x98(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1730
movq %rax, -0xb8(%rbp)
jmp 0x13d5
movq -0xb8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rdi
movl $0x2, %esi
callq 0x1970
jmp 0x1471
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x1650
jmp 0x149d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1a00
jmp 0x149d
leaq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1930
movq -0xa8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1990
movq %rax, -0xc8(%rbp)
jmp 0x1458
movq -0xc8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x1351
leaq -0x20(%rbp), %rdi
callq 0x1240
jmp 0x1481
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1a00
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x10f0
nopw %cs:(%rax,%rax)
// File: romkatv[P]hcproxy/src/parser.cc
// Function: hcproxy::(anonymous namespace)::ParseEventHandler::OnEvent(hcproxy::EventLoop*, int)
void OnEvent(EventLoop* loop, int events) override {
    if (HasBits(events, EPOLLERR)) {
      LOG(WARN) << "[" << fd() << "] error reading request data: " << Errno(SockError(fd()));
      Finish(loop, "");
    } else if (HasBits(events, EPOLLIN)) {
      if (std::optional<std::string_view> host_port = Read()) {
        Finish(loop, *host_port);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0x14(%rbp), %edi
movl $0x8, %esi
callq 0x1ba40
testb $0x1, %al
jne 0x19ce7
jmp 0x19e4a
leaq 0xca46f(%rip), %rsi     # 0xe415d
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x32, %edx
movl $0x1, %ecx
callq 0x1bb40
movq -0xa0(%rbp), %rdi
callq 0x194e0
movq %rax, %rdi
leaq 0xca4c2(%rip), %rsi     # 0xe41e0
callq 0x1bb10
movq %rax, -0x98(%rbp)
jmp 0x19d2c
movq -0x90(%rbp), %rdi
callq 0x1bb70
movl %eax, -0xa4(%rbp)
jmp 0x19d40
movq -0x98(%rbp), %rdi
movl -0xa4(%rbp), %eax
movl %eax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x1bad0
movq %rax, -0xb0(%rbp)
jmp 0x19d62
movq -0xb0(%rbp), %rdi
leaq 0xca472(%rip), %rsi     # 0xe41e2
callq 0x1baa0
movq %rax, -0xb8(%rbp)
jmp 0x19d7e
movq -0x90(%rbp), %rdi
callq 0x1bb70
movl %eax, -0xbc(%rbp)
jmp 0x19d92
movl -0xbc(%rbp), %edi
callq 0x31b40
movl %eax, -0xc0(%rbp)
jmp 0x19da5
movl -0xc0(%rbp), %edi
callq 0x1bb90
movl %eax, -0xc4(%rbp)
jmp 0x19db8
movq -0xb8(%rbp), %rdi
movl -0xc4(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x1ba60
movq %rax, -0xd0(%rbp)
jmp 0x19dda
movq -0xd0(%rbp), %rsi
leaq -0x4d(%rbp), %rdi
callq 0x194f0
jmp 0x19dec
leaq -0x38(%rbp), %rdi
callq 0x1bbb0
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0xcaea5(%rip), %rsi     # 0xe4cb0
callq 0x1bbf0
movq -0x90(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x1a060
jmp 0x19ec4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1bbb0
jmp 0x19ecd
movl -0x14(%rbp), %edi
movl $0x1, %esi
callq 0x1ba40
testb $0x1, %al
jne 0x19e5d
jmp 0x19ec2
movq -0x90(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1a0c0
leaq -0x78(%rbp), %rdi
callq 0x1bc40
testb $0x1, %al
jne 0x19e7c
jmp 0x19ec0
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1bc60
movq -0x90(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movq (%rax), %rcx
movq %rcx, -0x88(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x1a060
jmp 0x19ec2
jmp 0x19ec4
addq $0xe0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xe1080
nopw %cs:(%rax,%rax)
// File: romkatv[P]hcproxy/src/connector.cc
// Function: hcproxy::Connector::Connect(addrinfo const&, std::function<void (int)>)
void Connector::Connect(const addrinfo& addr, Callback cb) {
  CHECK(cb);
  int fd = ConnectAsync(addr);
  if (fd < 0) {
    cb(fd);
    return;
  }
  auto* eh = new ConnectEventHandler(fd, std::move(cb));
  event_loop_.ScheduleOrRun([this, eh]() { event_loop_.Add(eh, EPOLLOUT); });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdx, -0xd0(%rbp)
movq %rdi, %rax
movq -0xd0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x1ef80
movb $0x0, -0x39(%rbp)
testb $0x1, %al
jne 0x1ded9
jmp 0x1dede
jmp 0x1df64
leaq 0xc67b4(%rip), %rsi     # 0xe4699
leaq -0x38(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movl $0x55, %edx
movl $0x3, %ecx
callq 0x194b0
movq -0xe0(%rbp), %rdi
movb $0x1, -0x39(%rbp)
callq 0x194e0
movq %rax, -0xd8(%rbp)
jmp 0x1df18
movq -0xd8(%rbp), %rdi
leaq 0xc6245(%rip), %rsi     # 0xe416b
callq 0x19450
movq %rax, -0xe8(%rbp)
jmp 0x1df34
movq -0xe8(%rbp), %rdi
leaq 0xcb449(%rip), %rsi     # 0xe938b
callq 0x19450
movq %rax, -0xf0(%rbp)
jmp 0x1df50
movq -0xf0(%rbp), %rsi
leaq -0x4d(%rbp), %rdi
callq 0x194f0
jmp 0x1df62
jmp 0x1df64
testb $0x1, -0x39(%rbp)
jne 0x1df6c
jmp 0x1df89
leaq -0x38(%rbp), %rdi
callq 0x19500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x1dfaf
jmp 0x1dfb8
movq -0x10(%rbp), %rdi
callq 0x1e0f0
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jge 0x1dfbd
movq -0xc8(%rbp), %rdi
movl -0x54(%rbp), %esi
callq 0x1efa0
jmp 0x1e090
leaq -0x38(%rbp), %rdi
callq 0x19500
jmp 0x1e0e4
movl $0x58, %edi
callq 0x35bb0
movq -0xc8(%rbp), %rsi
movq %rax, -0x108(%rbp)
movq %rax, -0x110(%rbp)
movb $0x1, -0x81(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0xfc(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x1efe0
movq -0x108(%rbp), %rdi
movl -0xfc(%rbp), %esi
movq -0xf8(%rbp), %rdx
callq 0x1e6e0
jmp 0x1e017
movb $0x0, -0x81(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1f070
movq -0x110(%rbp), %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq (%rax), %rcx
movq %rcx, -0x120(%rbp)
movq %rax, -0xb8(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0xb8(%rbp), %rsi
callq 0x1e730
movq -0x120(%rbp), %rdi
movq -0x118(%rbp), %rsi
callq 0x33990
jmp 0x1e084
leaq -0xa8(%rbp), %rdi
callq 0x1af20
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1f070
testb $0x1, -0x81(%rbp)
jne 0x1e0b9
jmp 0x1e0ca
movq -0x110(%rbp), %rdi
movl $0x58, %esi
callq 0x34c20
jmp 0x1e0e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x1af20
movq -0x48(%rbp), %rdi
callq 0xe1080
nopl (%rax)
// File: romkatv[P]hcproxy/src/dns.cc
// Function: hcproxy::(anonymous namespace)::Describe[abi:cxx11](addrinfo const&)
std::string Describe(const addrinfo& head) {
  std::ostringstream strm;
  for (const addrinfo* p = &head; p; p = p->ai_next) {
    if (p != &head) strm << ", ";
    strm << IpPort(*p);
  }
  return strm.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa7c00
movq -0x10(%rbp), %rax
movq %rax, -0x190(%rbp)
cmpq $0x0, -0x190(%rbp)
je 0x204e0
movq -0x190(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x2049d
leaq 0xc45a1(%rip), %rsi     # 0xe4a0e
leaq -0x188(%rbp), %rdi
callq 0x9f9e0
jmp 0x2047b
jmp 0x2049d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xa4500
jmp 0x20511
movq -0x190(%rbp), %rsi
leaq -0x1a8(%rbp), %rdi
callq 0x24f60
jmp 0x204b2
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x25070
jmp 0x204c7
jmp 0x204c9
movq -0x190(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x190(%rbp)
jmp 0x2044b
movq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xa88f0
jmp 0x204f5
leaq -0x188(%rbp), %rdi
callq 0xa4500
movq -0x1b0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0xe1080
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x10, %rsi
leaq -0x10(%rbp), %rdi
callq 0x25ff0
jmp 0x252a3
movq -0x38(%rbp), %rax
movb $0x1, 0x8(%rax)
leaq -0x10(%rbp), %rdi
callq 0x26020
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x421c0
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
callq 0x421b0
movq -0x38(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26050
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26080
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x260b0
testb $0x1, %al
jne 0x25309
jmp 0x2532e
leaq -0x20(%rbp), %rdi
callq 0x260f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xb2880
jmp 0x25321
jmp 0x25323
leaq -0x20(%rbp), %rdi
callq 0x26110
jmp 0x252f6
movq -0x38(%rbp), %rdi
addq $0xb8, %rdi
callq 0x25f70
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
callq 0x25fd0
movq -0x38(%rbp), %rdi
addq $0x68, %rdi
callq 0x42180
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0x42180
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x19680
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x80(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x88(%rbp)
movq $0x0, -0x20(%rbp)
addq $0x10, %rsi
leaq -0x30(%rbp), %rdi
callq 0x21420
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rsi
movq %rcx, %rax
addq $0x98, %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rcx), %rax
incq %rax
movq %rax, (%rcx)
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x26180
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x26130
jmp 0x25400
leaq -0x60(%rbp), %rdi
callq 0x26210
movq -0x88(%rbp), %rdi
addq $0x98, %rdi
callq 0x26230
movq %rax, -0x90(%rbp)
jmp 0x25425
movq -0x88(%rbp), %rcx
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rax
cmpq (%rcx), %rax
jne 0x254a1
movq -0x88(%rbp), %rax
testb $0x1, 0x9(%rax)
je 0x2545d
movq -0x88(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x98(%rbp)
jmp 0x2546f
movq -0x88(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x254a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x26210
jmp 0x254bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x254bc
leaq -0x30(%rbp), %rdi
callq 0x21920
cmpq $0x0, -0x20(%rbp)
je 0x254c7
movq -0x20(%rbp), %rdi
callq 0x421b0
jmp 0x254c7
leaq -0x30(%rbp), %rdi
callq 0x21920
jmp 0x254d0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xe1080
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
je 0x290fd
leaq 0x1083c6(%rip), %rdi    # 0x131440
leaq 0xbbc25(%rip), %rsi     # 0xe4ca6
callq 0x9f9e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x9f9e0
movq %rax, %rdi
leaq 0xbbc0f(%rip), %rsi     # 0xe4cae
callq 0x9f9e0
movq %rax, %rdi
leaq 0xbbc03(%rip), %rsi     # 0xe4cb1
callq 0x9f9e0
movq %rax, %rdi
leaq 0xbbc28(%rip), %rsi     # 0xe4ce5
callq 0x9f9e0
movq %rax, %rdi
leaq 0xbc3d3(%rip), %rsi     # 0xe549f
callq 0x9f9e0
movq %rax, %rdi
leaq 0xbbc19(%rip), %rsi     # 0xe4cf4
callq 0x9f9e0
movq %rax, %rdi
leaq 0x761d6(%rip), %rsi     # 0x9f2c0
callq 0x9e4d0
movl $0x1, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x291e0
movq -0x110(%rbp), %rdi
callq 0x29290
jmp 0x2911e
leaq 0xbbbc0(%rip), %rsi     # 0xe4ce5
leaq -0x100(%rbp), %rdi
movl $0x72, %edx
movl $0x3, %ecx
callq 0x194b0
jmp 0x2913d
leaq -0x100(%rbp), %rdi
callq 0x194e0
movq %rax, -0x118(%rbp)
jmp 0x29152
movq -0x118(%rbp), %rdi
leaq 0xbbba4(%rip), %rsi     # 0xe4d04
callq 0x1dba0
movq %rax, -0x120(%rbp)
jmp 0x2916e
movq -0x120(%rbp), %rsi
leaq -0x101(%rbp), %rdi
callq 0x194f0
jmp 0x29183
leaq -0x100(%rbp), %rdi
callq 0x19500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x291c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x19500
leaq -0xd0(%rbp), %rdi
callq 0x297a0
movq -0xd8(%rbp), %rdi
callq 0xe1080
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x24(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x15100
movq -0x68(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %edi
movl -0xc(%rbp), %edx
movl $0x1, %esi
leaq -0x24(%rbp), %rcx
callq 0x154f0
movb $0x0, -0x49(%rbp)
cmpl $0x0, %eax
jne 0x2c0e4
jmp 0x2c174
leaq 0xb8cbd(%rip), %rsi     # 0xe4da8
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x23, %edx
movl $0x3, %ecx
callq 0x194b0
movq -0x78(%rbp), %rdi
movb $0x1, -0x49(%rbp)
callq 0x194e0
movq %rax, -0x70(%rbp)
jmp 0x2c115
movq -0x70(%rbp), %rdi
leaq 0xb8cc9(%rip), %rsi     # 0xe4de9
callq 0x2c8b0
movq %rax, -0x80(%rbp)
jmp 0x2c12b
movq -0x80(%rbp), %rdi
leaq 0xbd255(%rip), %rsi     # 0xe938b
callq 0x19450
movq %rax, -0x88(%rbp)
jmp 0x2c144
callq 0x1c0c0
jmp 0x2c14b
movq -0x88(%rbp), %rdi
callq 0x1c050
movq %rax, -0x90(%rbp)
jmp 0x2c160
movq -0x90(%rbp), %rsi
leaq -0x5f(%rbp), %rdi
callq 0x194f0
jmp 0x2c172
jmp 0x2c174
testb $0x1, -0x49(%rbp)
jne 0x2c17c
jmp 0x2c199
leaq -0x48(%rbp), %rdi
callq 0x19500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x2c1b2
jmp 0x2c1bb
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x90, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x19500
jmp 0x2c1bd
movq -0x58(%rbp), %rdi
callq 0xe1080
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq 0x20(%rax), %rax
movb $0x0, -0x31(%rbp)
cmpq $0x0, %rax
jbe 0x2c200
jmp 0x2c286
leaq 0xb8ba1(%rip), %rsi     # 0xe4da8
leaq -0x30(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x28, %edx
movl $0x3, %ecx
callq 0x194b0
movq -0x98(%rbp), %rdi
movb $0x1, -0x31(%rbp)
callq 0x194e0
movq %rax, -0x90(%rbp)
jmp 0x2c23a
movq -0x90(%rbp), %rdi
leaq 0xb8bd3(%rip), %rsi     # 0xe4e1b
callq 0x1c430
movq %rax, -0xa0(%rbp)
jmp 0x2c256
movq -0xa0(%rbp), %rdi
leaq 0xbd127(%rip), %rsi     # 0xe938b
callq 0x19450
movq %rax, -0xa8(%rbp)
jmp 0x2c272
movq -0xa8(%rbp), %rsi
leaq -0x45(%rbp), %rdi
callq 0x194f0
jmp 0x2c284
jmp 0x2c286
testb $0x1, -0x31(%rbp)
jne 0x2c28e
jmp 0x2c2b2
leaq -0x30(%rbp), %rdi
callq 0x19500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x2c38d
jmp 0x2c396
movq -0x88(%rbp), %rax
movl (%rax), %edi
movl -0xc(%rbp), %edx
movl $0x2, %esi
leaq -0x51(%rbp), %rcx
callq 0x154f0
movb $0x0, -0x79(%rbp)
cmpl $0x0, %eax
jne 0x2c2da
jmp 0x2c37c
leaq 0xb8ac7(%rip), %rsi     # 0xe4da8
leaq -0x78(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movl $0x2a, %edx
movl $0x3, %ecx
callq 0x194b0
movq -0xb8(%rbp), %rdi
movb $0x1, -0x79(%rbp)
callq 0x194e0
movq %rax, -0xb0(%rbp)
jmp 0x2c314
movq -0xb0(%rbp), %rdi
leaq 0xb8b0b(%rip), %rsi     # 0xe4e2d
callq 0x2c8b0
movq %rax, -0xc0(%rbp)
jmp 0x2c330
movq -0xc0(%rbp), %rdi
leaq 0xbd04d(%rip), %rsi     # 0xe938b
callq 0x19450
movq %rax, -0xc8(%rbp)
jmp 0x2c34c
callq 0x1c0c0
jmp 0x2c353
movq -0xc8(%rbp), %rdi
callq 0x1c050
movq %rax, -0xd0(%rbp)
jmp 0x2c368
movq -0xd0(%rbp), %rsi
leaq -0x7c(%rbp), %rdi
callq 0x194f0
jmp 0x2c37a
jmp 0x2c37c
testb $0x1, -0x79(%rbp)
jne 0x2c384
jmp 0x2c3ac
leaq -0x78(%rbp), %rdi
callq 0x19500
leaq -0x30(%rbp), %rdi
callq 0x19500
jmp 0x2c3d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x79(%rbp)
jne 0x2c3c8
jmp 0x2c3d1
movq -0x88(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0x19500
jmp 0x2c3d3
movq -0x40(%rbp), %rdi
callq 0xe1080
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x20(%rax), %rax
movb $0x0, -0x39(%rbp)
cmpq $0x0, %rax
jbe 0x2c417
jmp 0x2c49d
leaq 0xb898a(%rip), %rsi     # 0xe4da8
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x2f, %edx
movl $0x3, %ecx
callq 0x194b0
movq -0xa0(%rbp), %rdi
movb $0x1, -0x39(%rbp)
callq 0x194e0
movq %rax, -0x98(%rbp)
jmp 0x2c451
movq -0x98(%rbp), %rdi
leaq 0xb89bc(%rip), %rsi     # 0xe4e1b
callq 0x1c430
movq %rax, -0xa8(%rbp)
jmp 0x2c46d
movq -0xa8(%rbp), %rdi
leaq 0xbcf10(%rip), %rsi     # 0xe938b
callq 0x19450
movq %rax, -0xb0(%rbp)
jmp 0x2c489
movq -0xb0(%rbp), %rsi
leaq -0x4d(%rbp), %rdi
callq 0x194f0
jmp 0x2c49b
jmp 0x2c49d
testb $0x1, -0x39(%rbp)
jne 0x2c4a5
jmp 0x2c4c9
leaq -0x38(%rbp), %rdi
callq 0x19500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x2c5ce
jmp 0x2c5d7
leaq -0x59(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x15100
movq -0x90(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x59(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x55(%rbp)
movl (%rax), %edi
movl -0xc(%rbp), %edx
movl $0x3, %esi
leaq -0x59(%rbp), %rcx
callq 0x154f0
movb $0x0, -0x81(%rbp)
cmpl $0x0, %eax
jne 0x2c512
jmp 0x2c5ba
leaq 0xb888f(%rip), %rsi     # 0xe4da8
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl $0x33, %edx
movl $0x3, %ecx
callq 0x194b0
movq -0xc0(%rbp), %rdi
movb $0x1, -0x81(%rbp)
callq 0x194e0
movq %rax, -0xb8(%rbp)
jmp 0x2c54f
movq -0xb8(%rbp), %rdi
leaq 0xb8902(%rip), %rsi     # 0xe4e5f
callq 0x2c8b0
movq %rax, -0xc8(%rbp)
jmp 0x2c56b
movq -0xc8(%rbp), %rdi
leaq 0xbce12(%rip), %rsi     # 0xe938b
callq 0x19450
movq %rax, -0xd0(%rbp)
jmp 0x2c587
callq 0x1c0c0
jmp 0x2c58e
movq -0xd0(%rbp), %rdi
callq 0x1c050
movq %rax, -0xd8(%rbp)
jmp 0x2c5a3
movq -0xd8(%rbp), %rsi
leaq -0x84(%rbp), %rdi
callq 0x194f0
jmp 0x2c5b8
jmp 0x2c5ba
testb $0x1, -0x81(%rbp)
jne 0x2c5c5
jmp 0x2c5f0
leaq -0x80(%rbp), %rdi
callq 0x19500
leaq -0x38(%rbp), %rdi
callq 0x19500
jmp 0x2c604
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x81(%rbp)
jne 0x2c5f9
jmp 0x2c602
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x80(%rbp), %rdi
callq 0x19500
jmp 0x2c604
movq -0x48(%rbp), %rdi
callq 0xe1080
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movb %dl, %al
movq %rsi, -0x10(%rbp)
movb %al, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq 0x20(%rdi), %rax
movq %rax, -0x70(%rbp)
addq $0x8, %rdi
callq 0x2c8e0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jbe 0x2c685
movq -0x78(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x20(%rax), %rsi
callq 0x2c910
movq -0x78(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x80(%rbp)
addq $0x8, %rdi
callq 0x2c9a0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x2c910
leaq -0x10(%rbp), %rdi
callq 0x2c9d0
testb $0x1, %al
jne 0x2c694
jmp 0x2c6d3
movl $0x0, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2caa0
movq %rax, %rdi
callq 0x2ca30
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2cac0
movl %eax, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x2c9f0
movl (%rax), %eax
movl %eax, -0x84(%rbp)
jmp 0x2c6e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x84(%rbp)
jmp 0x2c6e0
movq -0x78(%rbp), %rdi
movl -0x84(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl (%rdi), %eax
movl %eax, -0x94(%rbp)
addq $0x8, %rdi
callq 0x2cae0
movq -0x78(%rbp), %rdi
movq %rax, -0x90(%rbp)
addq $0x8, %rdi
callq 0x2c8e0
movl -0x94(%rbp), %edi
movq -0x90(%rbp), %rsi
movl %eax, %edx
movl -0x1c(%rbp), %ecx
callq 0x156e0
movq -0x78(%rbp), %rcx
movl %eax, 0x28(%rcx)
movb $0x0, -0x51(%rbp)
cmpl $0x0, %eax
jl 0x2c73e
jmp 0x2c7e0
leaq 0xb8663(%rip), %rsi     # 0xe4da8
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movl $0x3c, %edx
movl $0x3, %ecx
callq 0x194b0
movq -0xa8(%rbp), %rdi
movb $0x1, -0x51(%rbp)
callq 0x194e0
movq %rax, -0xa0(%rbp)
jmp 0x2c778
movq -0xa0(%rbp), %rdi
leaq 0xb870b(%rip), %rsi     # 0xe4e91
callq 0x2cb00
movq %rax, -0xb0(%rbp)
jmp 0x2c794
movq -0xb0(%rbp), %rdi
leaq 0xbcbe9(%rip), %rsi     # 0xe938b
callq 0x19450
movq %rax, -0xb8(%rbp)
jmp 0x2c7b0
callq 0x1c0c0
jmp 0x2c7b7
movq -0xb8(%rbp), %rdi
callq 0x1c050
movq %rax, -0xc0(%rbp)
jmp 0x2c7cc
movq -0xc0(%rbp), %rsi
leaq -0x67(%rbp), %rdi
callq 0x194f0
jmp 0x2c7de
jmp 0x2c7e0
testb $0x1, -0x51(%rbp)
jne 0x2c7e8
jmp 0x2c805
leaq -0x50(%rbp), %rdi
callq 0x19500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x2c80e
jmp 0x2c817
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x19500
jmp 0x2c819
movq -0x60(%rbp), %rdi
callq 0xe1080
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: romkatv[P]hcproxy/src/forwarder.cc
// Function: hcproxy::Forwarder::Forward(int, int)
void Forwarder::Forward(int client_fd, int server_fd) {
  CHECK(client_fd >= 0);
  CHECK(server_fd >= 0);
  event_loop_.ScheduleOrRun(
      [=]() { LinkEventHandler::New(&event_loop_, client_fd, server_fd, opt_); });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0xc(%rbp), %eax
movb $0x0, -0x31(%rbp)
cmpl $0x0, %eax
jl 0x2d9f1
jmp 0x2da77
leaq 0xb7584(%rip), %rsi     # 0xe4f7c
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movl $0x13e, %edx            # imm = 0x13E
movl $0x3, %ecx
callq 0x194b0
movq -0xb8(%rbp), %rdi
movb $0x1, -0x31(%rbp)
callq 0x194e0
movq %rax, -0xb0(%rbp)
jmp 0x2da2b
movq -0xb0(%rbp), %rdi
leaq 0xb7554(%rip), %rsi     # 0xe4f8d
callq 0x195f0
movq %rax, -0xc0(%rbp)
jmp 0x2da47
movq -0xc0(%rbp), %rdi
leaq 0xbb936(%rip), %rsi     # 0xe938b
callq 0x19450
movq %rax, -0xc8(%rbp)
jmp 0x2da63
movq -0xc8(%rbp), %rsi
leaq -0x45(%rbp), %rdi
callq 0x194f0
jmp 0x2da75
jmp 0x2da77
testb $0x1, -0x31(%rbp)
jne 0x2da7f
jmp 0x2daa3
leaq -0x30(%rbp), %rdi
callq 0x19500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x2db4b
jmp 0x2db54
movl -0x10(%rbp), %eax
movb $0x0, -0x69(%rbp)
cmpl $0x0, %eax
jl 0x2dab4
jmp 0x2db3a
leaq 0xb74c1(%rip), %rsi     # 0xe4f7c
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movl $0x13f, %edx            # imm = 0x13F
movl $0x3, %ecx
callq 0x194b0
movq -0xd8(%rbp), %rdi
movb $0x1, -0x69(%rbp)
callq 0x194e0
movq %rax, -0xd0(%rbp)
jmp 0x2daee
movq -0xd0(%rbp), %rdi
leaq 0xb74a0(%rip), %rsi     # 0xe4f9c
callq 0x195f0
movq %rax, -0xe0(%rbp)
jmp 0x2db0a
movq -0xe0(%rbp), %rdi
leaq 0xbb873(%rip), %rsi     # 0xe938b
callq 0x19450
movq %rax, -0xe8(%rbp)
jmp 0x2db26
movq -0xe8(%rbp), %rsi
leaq -0x6a(%rbp), %rdi
callq 0x194f0
jmp 0x2db38
jmp 0x2db3a
testb $0x1, -0x69(%rbp)
jne 0x2db42
jmp 0x2db6d
leaq -0x68(%rbp), %rdi
callq 0x19500
leaq -0x30(%rbp), %rdi
callq 0x19500
jmp 0x2dbff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x69(%rbp)
jne 0x2dbdc
jmp 0x2dbe5
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0xf8(%rbp)
movq %rax, -0xa0(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x98(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x94(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0x2dc10
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x33990
jmp 0x2dbc7
leaq -0x90(%rbp), %rdi
callq 0x1af20
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x19500
jmp 0x2dbff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1af20
movq -0x40(%rbp), %rdi
callq 0xe1080
nopl (%rax,%rax)
// File: romkatv[P]hcproxy/src/forwarder.cc
// Function: hcproxy::(anonymous namespace)::LinkEventHandler::OnEvent(hcproxy::EventLoop*, int)
void OnEvent(EventLoop* loop, int events) override {
    // Returns true if some data has been transferred and the link isn't broken.
    auto Process = [&]() -> bool {
      if (HasBits(events, EPOLLERR)) {
        LOG(INFO) << "[" << fd() << "] (" << name_ << ") "
                  << "connection broke: " << Errno(SockError(fd()));
        Terminate(loop);
        return false;
      }
      return (HasBits(events, EPOLLOUT) && ForwardFromOther(loop)) |
             (HasBits(events, EPOLLIN) && other_->ForwardFromOther(loop));
    };
    other_->IncRef();
    if (Process()) {
      Refresh(loop);
      other_->Refresh(loop);
    }
    other_->DecRef();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x14(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x58(%rax), %rdi
callq 0x31860
leaq -0x30(%rbp), %rdi
callq 0x2f4e0
testb $0x1, %al
jne 0x2f277
jmp 0x2f295
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2f750
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2f750
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x31940
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: romkatv[P]hcproxy/src/forwarder.cc
// Function: hcproxy::(anonymous namespace)::LinkEventHandler::OnTimeout(hcproxy::EventLoop*)
void OnTimeout(EventLoop* loop) override {
    LOG(INFO) << "[" << fd() << "] (" << name_ << ") timed out waiting for IO";
    other_->IncRef();
    Terminate(loop);
    other_->DecRef();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq 0xb5caa(%rip), %rsi     # 0xe4f7c
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0xc6, %edx
xorl %ecx, %ecx
callq 0x1c360
movq -0x58(%rbp), %rdi
callq 0x194e0
movq %rax, %rdi
leaq 0xb4ee7(%rip), %rsi     # 0xe41e0
callq 0x1bb10
movq %rax, -0x50(%rbp)
jmp 0x2f304
movq -0x60(%rbp), %rdi
callq 0x1bb70
movl %eax, -0x64(%rbp)
jmp 0x2f312
movq -0x50(%rbp), %rdi
movl -0x64(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x1bad0
movq %rax, -0x70(%rbp)
jmp 0x2f32b
movq -0x70(%rbp), %rdi
leaq 0xb5cb4(%rip), %rsi     # 0xe4fea
callq 0x22810
movq %rax, -0x78(%rbp)
jmp 0x2f341
movq -0x78(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x38, %rsi
callq 0x1db60
movq %rax, -0x80(%rbp)
jmp 0x2f358
movq -0x80(%rbp), %rdi
leaq 0xb5e26(%rip), %rsi     # 0xe5189
callq 0x31a40
movq %rax, -0x88(%rbp)
jmp 0x2f371
movq -0x88(%rbp), %rsi
leaq -0x41(%rbp), %rdi
callq 0x194f0
leaq -0x30(%rbp), %rdi
callq 0x1c390
movq -0x60(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x31860
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2f790
movq -0x60(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x31940
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c390
movq -0x38(%rbp), %rdi
callq 0xe1080
nopl (%rax,%rax)