LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/common.h
// Function: ipd::play(ipd::prisoner_t const&, ipd::prisoner_t const&, int)
int play(const prisoner_t& p1, const prisoner_t& p2, int n) {
    history_t p1_hist, p2_hist;
    int p1_score = 0;

    for (int i = 0; i < n; ++i) {
        auto d1 = p1(p2_hist);
        auto d2 = p2(p1_hist);
        p1_score += score(d1, d2);

        p1_hist.push_front(d1);
        p2_hist.push_front(d2);
    }
    return p1_score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq -0x48(%rbp), %r14
movq %r14, 0x8(%r14)
movq %r14, (%r14)
xorl %r15d, %r15d
movq %r15, 0x10(%r14)
leaq -0x60(%rbp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq %r15, 0x10(%rax)
testl %edx, %edx
jle 0x57c9
movl %edx, %r12d
movq %rdi, %rcx
leaq 0x20(%rdi), %rax
movq %rax, -0x80(%rbp)
movq %rsi, -0x78(%rbp)
leaq 0x20(%rsi), %rax
movq %rax, -0x70(%rbp)
xorl %r15d, %r15d
leaq -0x60(%rbp), %r14
leaq -0x48(%rbp), %rbx
movq %rdi, -0x68(%rbp)
cmpq $0x0, 0x30(%rcx)
je 0x57f4
movq -0x80(%rbp), %rdi
movq %r14, %rsi
callq *0x38(%rcx)
movl %eax, %r13d
movl %r12d, -0x2c(%rbp)
movq -0x78(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x57f9
movq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq *0x38(%rax)
movl %eax, %r14d
orl %r13d, %eax
je 0x5748
movl %r14d, %eax
xorl $0x1, %eax
xorl %r12d, %r12d
movl %r13d, %ecx
orl %eax, %ecx
je 0x574e
movl %r13d, %ecx
xorl $0x1, %ecx
movl $0x5, %r12d
movl %ecx, %edx
orl %r14d, %edx
je 0x574e
xorl %r12d, %r12d
orl %eax, %ecx
sete %r12b
jmp 0x574e
movl $0x3, %r12d
movq -0x48(%rbp), %rbx
movl $0x18, %edi
callq 0x4370
movl %r13d, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4070
incq -0x38(%rbp)
movq -0x60(%rbp), %r13
movl $0x18, %edi
callq 0x4370
addl %r12d, %r15d
movl %r14d, 0x10(%rax)
movq %rax, %rdi
movq %r13, %rsi
callq 0x4070
incq -0x50(%rbp)
movl -0x2c(%rbp), %r12d
decl %r12d
leaq -0x48(%rbp), %rbx
leaq -0x60(%rbp), %r14
movq -0x68(%rbp), %rcx
jne 0x56dd
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x57c5
movq (%rdi), %rbx
callq 0x4350
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x57b5
leaq -0x48(%rbp), %r14
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x57e2
movq (%rdi), %rbx
callq 0x4350
movq %rbx, %rdi
cmpq %r14, %rbx
jne 0x57d2
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4120
callq 0x4120
jmp 0x5804
jmp 0x5804
jmp 0x5804
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x60(%rbp), %r15
cmpq %r15, %rdi
je 0x5824
movq (%rdi), %r14
callq 0x4350
movq %r14, %rdi
cmpq %r15, %r14
jne 0x5814
movq -0x48(%rbp), %rdi
leaq -0x48(%rbp), %r15
cmpq %r15, %rdi
je 0x5841
movq (%rdi), %r14
callq 0x4350
movq %r14, %rdi
cmpq %r15, %r14
jne 0x5831
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/common.h
// Function: ipd::total_score(ipd::prisoner_t const&, std::vector<ipd::prisoner_t, std::allocator<ipd::prisoner_t>> const&, int)
int total_score(const prisoner_t& p, const std::vector<prisoner_t>& ps, int n) {
    int score = 0;
    for (const auto& i: ps)
        score += play(p, i, n);
    return score;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x5886
movl %edx, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x567a
addl %eax, %r15d
addq $0x40, %r12
cmpq %r13, %r12
jne 0x586b
jmp 0x5889
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/common.h
// Function: ipd::play_tourny(std::vector<ipd::prisoner_t, std::allocator<ipd::prisoner_t>> const&, int)
std::vector<score_t>
play_tourny(const std::vector<prisoner_t>& players, int n) {
    std::vector<std::pair<prisoner_t, int>> ret;
    for (auto p1: players) {
        auto score = total_score(p1, players, n);
        ret.push_back({p1, score});
    }
    std::sort(ret.begin(), ret.end(), std::greater<score_t>());
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rbx
movq %rsi, -0x48(%rbp)
movq 0x8(%rsi), %rax
movq %rax, -0x40(%rbp)
cmpq %rax, %rbx
je 0x5a3d
movl %edx, %r14d
leaq -0x80(%rbp), %r15
leaq -0x90(%rbp), %r13
movq %r15, -0x90(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x9ba6
leaq 0x20(%rbx), %rsi
leaq -0x70(%rbp), %rdi
callq 0x92c8
movq %rbx, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r12
xorl %r15d, %r15d
cmpq %r12, %rbx
je 0x5959
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x567a
addl %eax, %r15d
addq $0x40, %rbx
jmp 0x593d
movl %r15d, -0x34(%rbp)
leaq -0xd8(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
leaq -0x34(%rbp), %rdx
callq 0x8316
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x9c94
movq -0x50(%rbp), %rbx
leaq -0x80(%rbp), %r15
movq -0xa8(%rbp), %rax
testq %rax, %rax
je 0x59a4
leaq -0xb8(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0xd8(%rbp), %rdi
leaq -0xc8(%rbp), %rax
cmpq %rax, %rdi
je 0x59bc
callq 0x4350
movq -0x60(%rbp), %rax
testq %rax, %rax
je 0x59d3
leaq -0x70(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x59e4
callq 0x4350
addq $0x40, %rbx
cmpq -0x40(%rbp), %rbx
jne 0x5905
movq -0x30(%rbp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r14
cmpq %r14, %rbx
je 0x5a3d
movq %r14, %rax
subq %rbx, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9f3a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa018
movq -0x30(%rbp), %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5a72
jmp 0x5a57
movq %rax, %rdi
callq 0x92ba
jmp 0x5a8d
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x8378
jmp 0x5a90
movq %rax, %rbx
jmp 0x5a9c
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x5a9c
callq 0x4350
jmp 0x5a9c
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x83ba
movq -0x30(%rbp), %rdi
callq 0x83fc
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/bots.h
// Function: ipd::bots::tf2t(std::__cxx11::list<ipd::decision, std::allocator<ipd::decision>> const&)
decision tf2t(const history_t& h) {
    if (h.size() < 2)
        return decision::cooperate;
    if (h.front() == decision::defect && *std::next(h.begin()) == decision::defect)
        return decision::defect;
    return decision::cooperate;
}

// Assembly:
xorl %eax, %eax
cmpq $0x2, 0x10(%rdi)
jb 0x5b12
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
cmpl $0x1, 0x10(%rax)
jne 0x5b0f
movq (%rax), %rcx
movl $0x1, %eax
cmpl $0x1, 0x10(%rcx)
je 0x5b11
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/bots.h
// Function: ipd::bots::sus_tf2t(std::__cxx11::list<ipd::decision, std::allocator<ipd::decision>> const&)
decision sus_tf2t(const history_t& h) {
    if (h.size() < 2)
        return decision::defect;
    if (h.front() == decision::defect && *std::next(h.begin()) == decision::defect)
        return decision::defect;
    return decision::cooperate;
}

// Assembly:
movl $0x1, %eax
cmpq $0x2, 0x10(%rdi)
jb 0x5b38
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
cmpl $0x1, 0x10(%rcx)
jne 0x5b35
movq (%rcx), %rcx
cmpl $0x1, 0x10(%rcx)
je 0x5b37
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/config.h
// Function: ipd::config::parse_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::pair<std::string, int> parse_line(std::string line) {
        std::stringstream sstream(line);
        std::string name;
        int val;

        sstream >> name >> val;
        return {name, val};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq -0x1c8(%rbp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x4490
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x4400
leaq -0x1c(%rbp), %rsi
movq %rax, %rdi
callq 0x41f0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x9ba6
movl -0x1c(%rbp), %eax
movl %eax, 0x20(%rbx)
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5c68
callq 0x4350
movq 0xf319(%rip), %rsi      # 0x14f88
leaq -0x1c8(%rbp), %rdi
callq 0x4280
leaq -0x148(%rbp), %rdi
callq 0x4100
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5ca9
callq 0x4350
movq 0xf2d8(%rip), %rsi      # 0x14f88
leaq -0x1c8(%rbp), %rdi
callq 0x4280
leaq -0x148(%rbp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/config.h
// Function: ipd::config::load_config()
void load_config() {
        std::ifstream in("ipd.conf");
        std::string line;
        while (std::getline(in, line)) {
            auto p = parse_line(line);
            assign_arg(p.first, p.second);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
leaq 0x8401(%rip), %rsi      # 0xe12c
leaq -0x2b8(%rbp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x4550
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0xa0(%rbp), %r12
leaq -0x80(%rbp), %r14
leaq -0xb0(%rbp), %r15
leaq -0x90(%rbp), %r13
movq -0x2b8(%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %edx
movq %rbx, %rdi
leaq -0x48(%rbp), %rsi
callq 0x4560
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5e2c
movq %r12, -0xb0(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x9ba6
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0x5be7
movq -0xb0(%rbp), %rdi
cmpq %r12, %rdi
je 0x5ddb
callq 0x4350
movq %r14, -0x90(%rbp)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x9ba6
movl -0x50(%rbp), %esi
movq %r13, %rdi
callq 0x5cd0
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x5e11
callq 0x4350
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x5d6b
callq 0x4350
jmp 0x5d6b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x5e3e
callq 0x4350
leaq -0x2b8(%rbp), %rdi
callq 0x40e0
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x5e75
callq 0x4350
jmp 0x5e75
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
jne 0x5e95
jmp 0x5e9f
jmp 0x5e9c
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
cmpq %r12, %rdi
je 0x5e9f
callq 0x4350
jmp 0x5e9f
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x5eb1
callq 0x4350
leaq -0x2b8(%rbp), %rdi
callq 0x40e0
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::random_decision()
decision random_decision() {
    static std::uniform_int_distribution<int> dist(0, 1);
    static std::knuth_b gen (std::time(nullptr));
    static auto roll = std::bind(dist, gen);

    if (roll())
        return decision::cooperate;
    return decision::defect;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0xf3a6(%rip), %al       # 0x153b8
testb %al, %al
je 0x604b
movb 0xfbb4(%rip), %al       # 0x15bd0
testb %al, %al
je 0x6052
movb 0x103ca(%rip), %al      # 0x163f0
testb %al, %al
je 0x6059
leaq 0xfbaf(%rip), %rsi      # 0x15be0
leaq 0xfba0(%rip), %rdi      # 0x15bd8
movq %rdi, %rdx
callq 0xb2b6
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
popq %rbp
retq
callq 0x45b0
jmp 0x6016
callq 0x45e4
jmp 0x6020
callq 0x4671
jmp 0x602a
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::tft_genome[abi:cxx11](int)
std::string tft_genome(int mem_size) {
    int limit = std::pow(mem_size, 4);
    std::string genome = "c";
    for (int i = 1; i < limit; ++i) {
        if ((i & 2) > 0)
            genome += "c";
        else
            genome += "d";
    }
    return genome;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2sd %esi, %xmm0
movsd 0x7f8b(%rip), %xmm1     # 0xe008
callq 0x4510
cvttsd2si %xmm0, %r12d
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rbx)
leaq 0x809c(%rip), %r14      # 0xe135
leaq 0x8096(%rip), %rdx      # 0xe136
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa0e
cmpl $0x2, %r12d
jl 0x60d9
movl $0x1, %r13d
leaq 0x80f8(%rip), %r15      # 0xe1b6
testb $0x2, %r13b
movq %r14, %rsi
cmoveq %r15, %rsi
movq %rbx, %rdi
callq 0x4570
incl %r13d
cmpl %r13d, %r12d
jne 0x60be
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x60fc
callq 0x4350
movq %r14, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::make_prisoner_t(ipd::genetic::genetic_strategy const&)
prisoner_t make_prisoner_t(const genetic_strategy& gs) {
    // converts a decision to a character
    auto f = [] (std::string s, decision d) {
        if (d == decision::cooperate) s += 'c';
        else s += 'd';
        return s;
    };
    auto name = std::accumulate(gs.strategy.begin(), gs.strategy.end(),
            std::string(), f);
    return {name, gs};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r13
movq %rdi, %r12
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %rbx
leaq -0x38(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
cmpq %rbx, %r14
je 0x623d
movq %r13, -0x50(%rbp)
movq %r12, -0x58(%rbp)
leaq -0x68(%rbp), %r12
leaq -0xa8(%rbp), %r13
leaq -0x78(%rbp), %r15
movq %r12, -0x78(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x9ba6
cmpl $0x1, (%r14)
movl $0x64, %esi
sbbl $0x0, %esi
movq %r15, %rdi
callq 0x42d0
movq %r13, -0xb8(%rbp)
movq -0x78(%rbp), %rax
cmpq %r12, %rax
je 0x61a8
movq %rax, -0xb8(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x61b2
movups (%r12), %xmm0
movups %xmm0, (%r13)
movq -0x70(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq %r12, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movb $0x0, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x43f0
movq -0xb8(%rbp), %rdi
cmpq %r13, %rdi
je 0x61ee
callq 0x4350
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x61fc
callq 0x4350
addq $0x4, %r14
cmpq %rbx, %r14
jne 0x6159
movq -0x48(%rbp), %rsi
leaq -0x88(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq -0x38(%rbp), %rcx
cmpq %rcx, %rsi
je 0x624a
movq %rsi, -0x98(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x58(%rbp), %r12
movq -0x50(%rbp), %r13
jmp 0x625b
leaq -0x88(%rbp), %rbx
movq %rbx, -0x10(%rbx)
jmp 0x6252
movq -0x58(%rbp), %r12
movq -0x50(%rbp), %r13
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rsi
movq -0x40(%rbp), %rdx
movq %rdx, -0x90(%rbp)
movq %rcx, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
leaq 0x10(%r12), %r15
movq %r15, (%r12)
addq %rsi, %rdx
movq %r12, %rdi
callq 0x9ba6
leaq 0x20(%r12), %rdi
movq %r13, %rsi
callq 0x8828
movq -0x98(%rbp), %rdi
cmpq %rbx, %rdi
je 0x62a8
callq 0x4350
movq %r12, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %r15, %rdi
je 0x62d3
callq 0x4350
jmp 0x62d3
movq %rax, %r14
movq -0x98(%rbp), %rdi
cmpq %rbx, %rdi
jne 0x6304
jmp 0x6309
movq %rax, %r14
jmp 0x62f7
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x62f7
callq 0x4350
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x6309
callq 0x4350
movq %r14, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::initial_population(unsigned long, unsigned long, unsigned long)
std::vector<prisoner_t> initial_population(std::size_t n,
        std::size_t first, std::size_t last) {
    std::vector<prisoner_t> ret;
    for (auto i = 0UL; i < n; ++i)
        ret.push_back(make_prisoner_t(genetic_strategy(random_range(first, last))));
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
testq %rsi, %rsi
je 0x6468
movq %rsi, %r12
xorl %r14d, %r14d
leaq -0xb8(%rbp), %r13
leaq -0x80(%rbp), %rbx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x8885
movq %r13, %rdi
movq %rax, %rsi
callq 0x88ca
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6104
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x9282
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x641d
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x642f
callq 0x4350
movq -0xa0(%rbp), %rdi
testq %rdi, %rdi
je 0x6440
callq 0x4350
movq -0xb8(%rbp), %rdi
cmpq %r13, %rdi
je 0x645c
movq (%rdi), %r15
callq 0x4350
movq %r15, %rdi
cmpq %r13, %r15
jne 0x644c
incq %r14
cmpq %r12, %r14
jne 0x63d7
movq -0x30(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x92ba
movq %rax, %rbx
jmp 0x6497
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x83ba
leaq -0xb8(%rbp), %rdi
callq 0x89a8
jmp 0x64a8
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x8472
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::hamming_distance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int hamming_distance(const std::string& s1, const std::string& s2) {
    int ret = 0;
    for (auto i = 0UL; i < s1.size(); ++i) {
        if (s1[i] == s2[i])
            ++ret;
    }
    return ret;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x6718
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq (%rsi), %rsi
xorl %edi, %edi
xorl %eax, %eax
movb (%rdx,%rdi), %r8b
xorl %r9d, %r9d
cmpb (%rsi,%rdi), %r8b
sete %r9b
addl %r9d, %eax
incq %rdi
cmpq %rdi, %rcx
jne 0x66fc
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::evaluate_tft_dist(std::vector<ipd::prisoner_t, std::allocator<ipd::prisoner_t>> const&)
std::vector<score_t> evaluate_tft_dist(const std::vector<prisoner_t>& v) {
    std::vector<score_t> ret;
    for (const auto& i: v) {
        std::size_t msize = std::ceil(
            std::log(i.name.size()) / std::log(4)
        );
        ret.emplace_back(i, i.name.size() - hamming_distance(
                    i.name, tft_genome(msize)
        ));
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r13
cmpq %r13, %r14
je 0x6818
leaq -0x30(%rbp), %r12
movsd 0x8(%r14), %xmm1
unpcklps 0x78e0(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x78e8(%rip), %xmm1     # 0xe050
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x42a0
divsd 0x7897(%rip), %xmm0     # 0xe018
callq 0x40a0
cvttsd2si %xmm0, %rsi
movq %rsi, %rax
subsd 0x787a(%rip), %xmm0     # 0xe010
cvttsd2si %xmm0, %rcx
sarq $0x3f, %rax
andl %eax, %ecx
orl %ecx, %esi
movq 0x8(%r14), %r15
leaq -0x50(%rbp), %rdi
callq 0x6060
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x67e2
movq (%r14), %rcx
xorl %edx, %edx
movq -0x50(%rbp), %rsi
xorl %edi, %edi
movb (%rcx,%rdx), %r8b
xorl %r9d, %r9d
cmpb (%rsi,%rdx), %r8b
sete %r9b
addl %r9d, %edi
incq %rdx
cmpq %rdx, %rax
jne 0x67c4
movl %edi, %eax
jmp 0x67e4
xorl %eax, %eax
subq %rax, %r15
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x8bd8
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x680b
callq 0x4350
addq $0x40, %r14
cmpq %r13, %r14
jne 0x6753
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6844
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x6844
callq 0x4350
movq %rbx, %rdi
callq 0x83fc
movq %r14, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::evaluate_vs_tft(std::vector<ipd::prisoner_t, std::allocator<ipd::prisoner_t>> const&)
std::vector<score_t> evaluate_vs_tft(const std::vector<prisoner_t>& v) {
    std::vector<score_t> ret;
    prisoner_t tft = {"", bots::tft};
    for (const auto& i: v)
        ret.emplace_back(i, play(i, tft, ipd::config::rounds));
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x77fb(%rip), %rdx      # 0xe084
leaq -0x70(%rbp), %rdi
movq %rdx, %rsi
callq 0xaa0e
movq $0x0, -0x48(%rbp)
leaq -0xde4(%rip), %rax      # 0x5ac0
movq %rax, -0x50(%rbp)
leaq 0x41fd(%rip), %rax      # 0xaaac
movq %rax, -0x38(%rbp)
leaq 0x4200(%rip), %rax      # 0xaaba
movq %rax, -0x40(%rbp)
movq (%r15), %r14
movq 0x8(%r15), %r13
cmpq %r13, %r14
je 0x690a
leaq -0x70(%rbp), %r15
leaq -0x2c(%rbp), %r12
movl 0xea80(%rip), %edx      # 0x15358
movq %r14, %rdi
movq %r15, %rsi
callq 0x567a
movl %eax, -0x2c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x8abc
addq $0x40, %r14
cmpq %r13, %r14
jne 0x68d2
movq -0x40(%rbp), %rax
testq %rax, %rax
leaq -0x60(%rbp), %r12
je 0x6918
leaq -0x50(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x6926
callq 0x4350
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x92ba
movq %rax, %r14
jmp 0x6951
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x83ba
movq %rbx, %rdi
callq 0x83fc
movq %r14, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::mutate_strategy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::string mutate_strategy(std::string s, const int rate) {
    auto maybe_change = [&] (const char c) {
        if (random_range(0, 100) <= rate) {
            auto d = random_decision();
            if (d == decision::defect) return 'd';
            return 'c';
        }
        return c;
    };

    std::transform(s.begin(), s.end(), s.begin(), maybe_change);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %r12
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x69c5
movl %edx, %r15d
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
xorl %r14d, %r14d
movb (%r12,%r14), %bl
xorl %edi, %edi
movl $0x64, %esi
callq 0xd2bb
cmpl %r15d, %eax
jg 0x69ae
callq 0x6008
cmpl $0x1, %eax
movb $0x64, %bl
sbbb $0x0, %bl
movb %bl, (%r12,%r14)
incq %r14
cmpq %r14, %r13
jne 0x698c
movq -0x38(%rbp), %rsi
movq (%rsi), %r12
movq -0x30(%rbp), %rdi
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
leaq 0x10(%rsi), %rax
cmpq %rax, %r12
je 0x69e1
movq %r12, (%rdi)
movq (%rax), %rcx
movq %rcx, 0x10(%rdi)
jmp 0x69e7
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
movq %rdi, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::cross(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::pair<std::string, std::string> cross(const std::string& s1,
                                          const std::string& s2) {
    auto point = random_range<std::size_t>(0UL, std::min(s1.size(), s2.size()));
    std::string p1 = s1.substr(0, point),
                p2 = s2.substr(0, point);

    for (auto i = point; i < s1.size(); ++i)
        p2 += s1[i];
    for (auto i = point; i < s2.size(); ++i)
        p1 += s2[i];

    return {p1, p2};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
movq 0x8(%rsi), %rsi
movq 0x8(%rdx), %rax
cmpq %rsi, %rax
cmovbq %rax, %rsi
xorl %edi, %edi
callq 0x8885
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x43a0
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x43a0
cmpq 0x8(%r12), %rbx
jae 0x6a8f
leaq -0x50(%rbp), %r13
movq %rbx, %r15
movq (%r12), %rax
movsbl (%rax,%r15), %esi
movq %r13, %rdi
callq 0x42d0
incq %r15
cmpq 0x8(%r12), %r15
jb 0x6a74
cmpq 0x8(%r14), %rbx
jae 0x6ab1
leaq -0x70(%rbp), %r12
movq (%r14), %rax
movsbl (%rax,%rbx), %esi
movq %r12, %rdi
callq 0x42d0
incq %rbx
cmpq 0x8(%r14), %rbx
jb 0x6a99
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x8c1a
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ad7
callq 0x4350
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ae9
callq 0x4350
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b04
movq %rax, %rbx
jmp 0x6b19
jmp 0x6b04
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b19
callq 0x4350
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b2b
callq 0x4350
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/hill_climb.h
// Function: ipd::hill_climb::mutation_successor(ipd::prisoner_t const&, int)
std::vector<prisoner_t>
mutation_successor(const prisoner_t& p, const int rate) {
    std::vector<prisoner_t> ret;
    auto mutation = std::bind(genetic::mutate_strategy, _1, rate);

    for (int i = 0; i < config::pop_size; ++i) {
        auto n = mutation(p.name);
        ret.push_back(make_prisoner_t(genetic::genetic_strategy(n)));
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
leaq -0x65a(%rip), %rax      # 0x6961
movq %rax, -0x48(%rbp)
movl %edx, -0x40(%rbp)
cmpl $0x0, 0xe39b(%rip)      # 0x15364
jle 0x7098
xorl %ebx, %ebx
leaq -0x68(%rbp), %r13
leaq -0xe0(%rbp), %r15
leaq -0xa8(%rbp), %r12
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0xd787
movq %r15, %rdi
movq %r13, %rsi
callq 0x8fc2
movq %r12, %rdi
movq %r15, %rsi
callq 0x6104
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x9282
movq -0x78(%rbp), %rax
testq %rax, %rax
je 0x7033
leaq -0x88(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0x704b
callq 0x4350
movq -0xc8(%rbp), %rdi
testq %rdi, %rdi
je 0x705c
callq 0x4350
movq -0xe0(%rbp), %rdi
cmpq %r15, %rdi
je 0x7078
movq (%rdi), %r14
callq 0x4350
movq %r14, %rdi
cmpq %r15, %r14
jne 0x7068
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x708a
callq 0x4350
incl %ebx
cmpl 0xe2d2(%rip), %ebx      # 0x15364
jl 0x6fe3
movq -0x30(%rbp), %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x92ba
movq %rax, %r14
jmp 0x70f2
movq %rax, %r14
jmp 0x70e0
movq %rax, %r14
jmp 0x70d4
movq %rax, %r14
leaq -0xa8(%rbp), %rdi
callq 0x83ba
leaq -0xe0(%rbp), %rdi
callq 0x89a8
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x70f2
callq 0x4350
movq -0x30(%rbp), %rdi
callq 0x8472
movq %r14, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/hill_climb.h
// Function: ipd::hill_climb::climb(ipd::prisoner_t, int, std::function<std::vector<std::pair<ipd::prisoner_t, int>, std::allocator<std::pair<ipd::prisoner_t, int>>> (std::vector<ipd::prisoner_t, std::allocator<ipd::prisoner_t>> const&)>)
prisoner_t climb(prisoner_t init, const int rate,
        genetic::fitness_fn fitness_func) {
    while (true) {
        auto succ = mutation_successor(init, rate);
        succ.push_back(init);

        auto evaluation = fitness_func(succ);
        auto m = std::max_element(evaluation.begin(), evaluation.end(),
                std::less<score_t>());

        // best guy was initial guy
        if (m->first.name == init.name)
            break;
        init = m->first;
    }

    return init;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movl %edx, -0x2c(%rbp)
movq %rsi, %r14
movq %rdi, -0x40(%rbp)
leaq 0x20(%rsi), %rax
movq %rax, -0x38(%rbp)
leaq -0x70(%rbp), %rbx
leaq -0x58(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movl -0x2c(%rbp), %edx
callq 0x6f8a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x90f8
cmpq $0x0, 0x10(%r12)
je 0x734e
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq *0x18(%r12)
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rax
cmpq %rax, %rdx
sete %sil
movq %rdx, %rcx
addq $0x48, %rcx
cmpq %rax, %rcx
sete %dil
orb %sil, %dil
je 0x724f
movq %rdx, %r13
jmp 0x7269
movl 0x40(%rdx), %esi
movq %rcx, %r13
cmpl 0x40(%rcx), %esi
jl 0x725d
movq %rdx, %r13
addq $0x48, %rcx
movq %r13, %rdx
cmpq %rax, %rcx
jne 0x724f
movq 0x8(%r13), %rdx
cmpq 0x8(%r14), %rdx
jne 0x7288
testq %rdx, %rdx
je 0x72b8
movq (%r14), %rsi
movq (%r13), %rdi
callq 0x4390
testl %eax, %eax
je 0x72b8
movq %r14, %rdi
movq %r13, %rsi
callq 0x41a0
addq $0x20, %r13
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x9aac
movq %r15, %rdi
callq 0x83fc
movq %rbx, %rdi
callq 0x8472
jmp 0x71f5
leaq -0x58(%rbp), %rdi
callq 0x83fc
leaq -0x70(%rbp), %rdi
callq 0x8472
movq -0x40(%rbp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%r14), %rdx
leaq 0x10(%r14), %rsi
cmpq %rsi, %rdx
je 0x72ed
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x72f3
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rsi, (%r14)
xorl %ecx, %ecx
movq %rcx, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rcx, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq 0x38(%r14), %rcx
movq %rcx, 0x38(%rax)
movq 0x30(%r14), %rdx
testq %rdx, %rdx
je 0x733f
leaq 0x20(%rax), %rcx
addq $0x30, %r14
movq -0x38(%rbp), %rsi
movups (%rsi), %xmm1
movups %xmm1, (%rcx)
movq %rdx, 0x30(%rax)
movups %xmm0, (%r14)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4120
jmp 0x7357
jmp 0x7357
movq %rax, %rbx
jmp 0x7368
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x83fc
leaq -0x70(%rbp), %rdi
callq 0x8472
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/hill_climb.h
// Function: ipd::hill_climb::climb(ipd::prisoner_t, int, int)
prisoner_t climb(prisoner_t init, const int rate, int rounds) {
    for (int i = 0; i < rounds; ++i) {
        auto succ = mutate(init, rate);
        if (single_vs_tft(succ) > single_vs_tft(init))
            init = succ;
    }
    return init;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
testl %ecx, %ecx
jle 0x74c9
movl %ecx, %r15d
movl %edx, %r12d
leaq 0x20(%r14), %rax
movq %rax, -0x38(%rbp)
leaq -0x78(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x7103
movq %r13, %rdi
callq 0x7379
movl %eax, %ebx
movq %r14, %rdi
callq 0x7379
cmpl %eax, %ebx
jle 0x749b
movq %r14, %rdi
movq %r13, %rsi
callq 0x41a0
movq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9aac
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x74b2
leaq -0x58(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x74c4
callq 0x4350
decl %r15d
jne 0x745f
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%r14), %rdx
leaq 0x10(%r14), %rsi
cmpq %rsi, %rdx
je 0x74ec
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x74f2
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rsi, (%r14)
xorl %ecx, %ecx
movq %rcx, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rcx, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq 0x38(%r14), %rcx
movq %rcx, 0x38(%rax)
movq 0x30(%r14), %rdx
testq %rdx, %rdx
je 0x753c
leaq 0x20(%rax), %rcx
movups 0x20(%r14), %xmm1
addq $0x30, %r14
movups %xmm1, (%rcx)
movq %rdx, 0x30(%rax)
movups %xmm0, (%r14)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x92ba
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x83ba
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/main.cpp
// Function: ev_against_classic()
void ev_against_classic() {
    using namespace ipd;
    auto ev_guy   = genetic::evolve(
        config::pop_size,
        config::mutation_rate,
        config::generations,
        genetic::evaluate_vs_tft
    );
    auto cp       = bots::all;
    cp.push_back(ev_guy);

    auto sb = play_tourny(cp, config::rounds);
    for (auto i: sb)
        std::cout << i << std::endl;

    log(sb.front().first, sb.front().second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl 0xda34(%rip), %esi      # 0x15364
movl 0xda32(%rip), %edx      # 0x15368
movl 0xda30(%rip), %ecx      # 0x1536c
leaq -0x78(%rbp), %r8
movq $0x0, 0x8(%r8)
leaq -0x10fb(%rip), %rax     # 0x6854
movq %rax, (%r8)
leaq 0x6161(%rip), %rax      # 0xdaba
movq %rax, 0x18(%r8)
leaq 0x6172(%rip), %rax      # 0xdad6
movq %rax, 0x10(%r8)
leaq -0xb8(%rbp), %rdi
callq 0x6b33
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x798b
leaq -0x78(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0xd97e(%rip), %rsi      # 0x15310
leaq -0x58(%rbp), %rdi
callq 0x9196
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x90f8
movl 0xd9a7(%rip), %edx      # 0x15358
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x58b9
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r13
cmpq %r13, %rbx
je 0x7a60
leaq -0xe0(%rbp), %r14
leaq -0x100(%rbp), %r15
movq 0xd5dc(%rip), %r12      # 0x14fc0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9224
movq %r12, %rdi
movq %r15, %rsi
callq 0x55de
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r12, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4230
movq -0xd0(%rbp), %rax
testq %rax, %rax
je 0x7a3b
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq -0x100(%rbp), %rdi
leaq -0xf0(%rbp), %rax
cmpq %rax, %rdi
je 0x7a53
callq 0x4350
addq $0x48, %rbx
cmpq %r13, %rbx
jne 0x79e4
movq -0x40(%rbp), %rbx
movl 0x40(%rbx), %esi
movq %rbx, %rdi
callq 0x785a
leaq -0x40(%rbp), %rdi
callq 0x83fc
leaq -0x58(%rbp), %rdi
callq 0x8472
movq -0x88(%rbp), %rax
testq %rax, %rax
je 0x7a9a
leaq -0x98(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0xa8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7aaf
callq 0x4350
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7af1
jmp 0x7af1
jmp 0x7af9
jmp 0x7ac9
movq %rax, %rbx
jmp 0x7b16
movq %rax, %rbx
jmp 0x7b1f
movq %rax, %rbx
movq -0x68(%rbp), %rax
testq %rax, %rax
je 0x7b2b
leaq -0x78(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x7b2b
jmp 0x7af1
movq %rax, %rdi
callq 0x92ba
movq %rax, %rbx
jmp 0x7b0d
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x8378
leaq -0x40(%rbp), %rdi
callq 0x83fc
leaq -0x58(%rbp), %rdi
callq 0x8472
leaq -0xb8(%rbp), %rdi
callq 0x83ba
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/main.cpp
// Function: hill_against_classic()
void hill_against_classic() {
    using namespace ipd;
    auto hill_guy = hill_climb::climb(
        make_prisoner_t(genetic::genetic_strategy(3)),
        config::mutation_rate,
        config::hill_pop
    );
    auto cp       = bots::all;
    cp.push_back(hill_guy);

    auto sb = play_tourny(cp, config::rounds);
    for (auto i: sb)
        std::cout << i << std::endl;

    //log(sb.front().first, sb.front().second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
leaq -0xa0(%rbp), %rbx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x88ca
leaq -0xe0(%rbp), %rdi
movq %rbx, %rsi
callq 0x6104
movl 0xd7f8(%rip), %edx      # 0x15368
movl 0xd7fa(%rip), %ecx      # 0x15370
leaq -0x120(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x7431
movq -0xb0(%rbp), %rax
testq %rax, %rax
je 0x7ba6
leaq -0xc0(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0xd0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7bbb
callq 0x4350
movq -0x88(%rbp), %rdi
testq %rdi, %rdi
je 0x7bcc
callq 0x4350
movq -0xa0(%rbp), %rdi
cmpq %rbx, %rdi
je 0x7be8
movq (%rdi), %r14
callq 0x4350
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x7bd8
leaq 0xd721(%rip), %rsi      # 0x15310
leaq -0x58(%rbp), %rdi
callq 0x9196
leaq -0x58(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x90f8
movl 0xd74a(%rip), %edx      # 0x15358
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x58b9
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r13
cmpq %r13, %rbx
je 0x7cb3
leaq -0x80(%rbp), %r14
leaq -0xa0(%rbp), %r15
movq 0xd382(%rip), %r12      # 0x14fc0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9224
movq %r12, %rdi
movq %r15, %rsi
callq 0x55de
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r12, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4230
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x7c92
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0x7caa
callq 0x4350
addq $0x48, %rbx
cmpq %r13, %rbx
jne 0x7c3e
leaq -0x40(%rbp), %rdi
callq 0x83fc
leaq -0x58(%rbp), %rdi
callq 0x8472
movq -0xf0(%rbp), %rax
testq %rax, %rax
je 0x7ce2
leaq -0x100(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0x110(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7cf7
callq 0x4350
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7d3b
jmp 0x7d3b
jmp 0x7d0f
movq %rax, %rbx
jmp 0x7d60
movq %rax, %rbx
jmp 0x7d69
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x83ba
jmp 0x7d2d
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x89a8
jmp 0x7d75
movq %rax, %rdi
callq 0x92ba
movq %rax, %rbx
jmp 0x7d57
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x8378
leaq -0x40(%rbp), %rdi
callq 0x83fc
leaq -0x58(%rbp), %rdi
callq 0x8472
leaq -0x120(%rbp), %rdi
callq 0x83ba
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/main.cpp
// Function: main
int main(int argc, char* argv[]) {
    ipd::config::load_config();
    ipd::config::load_cmd_args(argc, argv);

    //ev_against_classic();
    hill_against_classic();
    //restart_hill_against_classic(1000);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
callq 0x5d10
movl %r14d, %edi
movq %rbx, %rsi
callq 0x5ec5
callq 0x7b33
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::genetic_strategy::genetic_strategy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
genetic_strategy(const std::string& genome) :
        strategy(genome.size()),
        mem_size(
            std::ceil(std::log(genome.size()) / std::log(4))
        )
    {
        // converts a character to a decision
        auto f = [] (char c) {
            if (c == 'c') return decision::cooperate;
            return decision::defect;
        };
        std::transform(genome.begin(), genome.end(), strategy.begin(), f);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %r15
movq 0x8(%rsi), %rsi
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x94aa
movsd 0x8(%r14), %xmm1
unpcklps 0x503e(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x5046(%rip), %xmm1     # 0xe050
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x42a0
divsd 0x4ff5(%rip), %xmm0     # 0xe018
callq 0x40a0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x4fd8(%rip), %xmm0     # 0xe010
sarq $0x3f, %rcx
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x30(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x9071
movq (%r14), %rcx
movq (%r15), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpb $0x63, (%rcx,%rsi)
setne %dil
movl %edi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x905c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x9097
movq (%rdi), %r15
callq 0x4350
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x9087
movq %r14, %rdi
callq 0x4520
nop
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/profile.h
// Function: qp::profiler::stop()
void stop() {
        if (done) return;
        using namespace std::chrono;
        t2 = high_resolution_clock::now();
        sections[tag] += duration_cast<duration<double>>(t2 - t1).count();
        done = true;
        log();
    }

// Assembly:
cmpb $0x0, 0x10(%rdi)
je 0x95d1
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4060
movq %rax, 0x8(%rbx)
subq (%rbx), %rax
cvtsi2sd %rax, %xmm0
divsd 0x4a2d(%rip), %xmm0     # 0xe020
movsd %xmm0, -0x10(%rbp)
leaq 0x18(%rbx), %rsi
leaq 0xbd25(%rip), %rdi      # 0x15328
callq 0x9628
movsd -0x10(%rbp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movb $0x1, 0x10(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x96a8
nop
// File: /workspace/github_cpp_makefile_star2_O3/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::genetic_strategy::encode(std::__cxx11::list<ipd::decision, std::allocator<ipd::decision>> const&) const
std::size_t encode(const history_t& op_history) const {
        std::size_t code = 0;

        auto my_iter = history.begin();
        auto op_iter = op_history.begin();

        for (auto shift = 0UL; shift < 2 * mem_size; shift += 2) {
            if (my_iter == history.end() || op_iter == op_history.end())
                break;

            if (*my_iter == decision::cooperate)
                code |= 1 << shift;

            if (*op_iter == decision::cooperate)
                code |= 1 << (shift + 1);

            ++my_iter; ++op_iter;
        }
        return code;
    }

// Assembly:
movq (%rdi), %rdx
movq 0x30(%rdi), %r8
addq %r8, %r8
movq (%rsi), %r9
sete %al
cmpq %rdi, %rdx
sete %cl
cmpq %rsi, %r9
sete %r11b
orb %cl, %r11b
xorl %r10d, %r10d
orb %al, %r11b
je 0xb7c9
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x2, %r11d
xorl %eax, %eax
leal -0x2(%r11), %ecx
movl $0x1, %ebx
shll %cl, %ebx
cmpl %r10d, 0x10(%rdx)
cmovnel %r10d, %ebx
movl $0x2, %r14d
shll %cl, %r14d
cmpl %r10d, 0x10(%r9)
cmovnel %r10d, %r14d
movslq %r14d, %rcx
orq %rbx, %rax
orq %rcx, %rax
cmpq %r8, %r11
jae 0xb81e
movq (%rdx), %rdx
cmpq %rdi, %rdx
je 0xb81e
movq (%r9), %r9
addq $0x2, %r11
cmpq %rsi, %r9
jne 0xb7d8
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/LiGaCu[P]Distributed_System_to_Compute_the_Shortest_Path/serverB.cpp
// Function: getUDPsockandbind(addrinfo*)
int getUDPsockandbind(struct addrinfo *servinfo)
{
    int sockfd;
    struct addrinfo *p;
    int reuseaddr=1;
    
    // loop through all the results and bind to the first we can
    for(p = servinfo; p != NULL; p = p->ai_next) 
    {
        if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) 
        {
            perror("listener: socket");
            continue;
        }
        if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(int)) == -1) 
        {
            perror("setsockopt");
            exit(1);
        }
        if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) 
        {
            close(sockfd);
            perror("listener: bind");
            continue;
        }
        break;
    }
    if (p == NULL) 
    {
        fprintf(stderr, "listener: failed to bind socket\n");
        exit (2);
    }
    return sockfd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl $0x1, 0xc(%rsp)
testq %rdi, %rdi
je 0x27e1
movq %rdi, %rbx
leaq 0xa10(%rip), %r15       # 0x3183
leaq 0xc(%rsp), %r14
leaq 0xa20(%rip), %r12       # 0x319f
movl 0x4(%rbx), %edi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x2080
movq %r15, %rdi
cmpl $-0x1, %eax
je 0x27d3
movl %eax, %ebp
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x2210
cmpl $-0x1, %eax
je 0x27f5
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
movl %ebp, %edi
callq 0x2050
cmpl $-0x1, %eax
jne 0x27e6
movl %ebp, %edi
callq 0x2250
movq %r12, %rdi
callq 0x2100
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x277f
callq 0x22af
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x229a
// File: /workspace/github_cpp_makefile_star2_O3/ostafen[P]Fast-Insertion-Sort/src/main.cpp
// Function: ChainedBlockInsertionSort<int>* chain<int>(int)
ChainedBlockInsertionSort<T>* chain(int k) {
  ChainedBlockInsertionSort<T>* out = new ChainedBlockInsertionSort<T>;

  for(int i = 1; i<k; i++) {
    float exp = (float)(i+1)/(i+2);
    out = new ChainedBlockInsertionSort<T>(exp, out);
  }
  
  out->setLevel(k);
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movl $0x20, %edi
callq 0x31b0
movq %rax, %r14
leaq 0x7274(%rip), %r15      # 0xace8
movq %r15, (%rax)
movl $0x8, %edi
callq 0x31b0
leaq 0x6f50(%rip), %rcx      # 0xa9d8
movq %rcx, (%rax)
movq %rax, 0x10(%r14)
movl $0x3f000000, 0x8(%r14)  # imm = 0x3F000000
movl $0x1, 0x18(%r14)
cmpl $0x2, %ebx
jl 0x3b01
movl %ebx, %r12d
negl %r12d
movl $0x3, %r13d
leal -0x1(%r13), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %r13d, %xmm0
divss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movl $0x20, %edi
callq 0x31b0
movq %r15, (%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
movq %r14, 0x10(%rax)
leal (%r12,%r13), %ecx
incl %ecx
movl %r13d, %edx
incl %edx
movl %edx, %r13d
movq %rax, %r14
cmpl $0x2, %ecx
jne 0x3ab0
jmp 0x3b04
movq %r14, %rax
movl %ebx, 0x18(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x31c0
movq %rbx, %rdi
callq 0x32a0
nop