LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0x4, %esi
callq 0xa0c0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x45d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x19bf8(%rip), %rsi     # 0x201c6
callq 0x44d0
jmp 0x65d5
leaq -0x12(%rbp), %rdi
callq 0x4430
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x665b
movl -0x28(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jle 0x663a
movq -0x38(%rbp), %rdi
leaq 0x19bc3(%rip), %rsi     # 0x201c6
callq 0x43c0
jmp 0x660a
jmp 0x664e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x4430
jmp 0x6678
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4230
jmp 0x6678
movq -0x38(%rbp), %rdi
leaq 0x19b83(%rip), %rsi     # 0x201c8
callq 0x43c0
jmp 0x664c
jmp 0x664e
jmp 0x6650
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x65e5
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x666e
movq -0x38(%rbp), %rdi
callq 0x4230
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xa0f0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0xa120
movq %rax, -0x48(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x44e0
movq -0x88(%rbp), %rcx
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x67b0
jmp 0x6700
leaq -0x68(%rbp), %rdi
callq 0x4230
movq -0x98(%rbp), %rdi
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x4160
jmp 0x6725
movq -0x98(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0xa150
jmp 0x673b
leaq -0x38(%rbp), %rdi
callq 0x4230
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4230
jmp 0x679a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x6791
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
callq 0x4230
leaq -0x38(%rbp), %rdi
callq 0x4230
movq -0x78(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0xa3f0
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x6a3e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa1f0
movq %rax, -0xd0(%rbp)
jmp 0x6991
movq -0xd0(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0xa290
jmp 0x69a6
leaq -0x70(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x6690
jmp 0x69b8
movq -0xc8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa410
jmp 0x69ca
leaq -0x70(%rbp), %rdi
callq 0x9450
leaq -0xa8(%rbp), %rdi
callq 0xa3c0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x696d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x6a64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x6a30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9450
leaq -0xa8(%rbp), %rdi
callq 0xa3c0
jmp 0x6a64
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x6a54
movq -0xc8(%rbp), %rdi
callq 0x9890
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x9890
movq -0xb0(%rbp), %rdi
callq 0x45c0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x6e72
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4440
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4440
movq %rax, %rcx
movl -0x2c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x6e62
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6e64
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6e0f
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x9340
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9260
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9290
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x92c0
testb $0x1, %al
jne 0x6ee2
jmp 0x7009
leaq -0x28(%rbp), %rdi
callq 0x9300
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x42a0
movq %rax, %rdi
callq 0xa8a0
movsd %xmm0, -0x90(%rbp)
jmp 0x6f0a
movl $0x4, %edi
callq 0xa8e0
movsd %xmm0, -0x98(%rbp)
jmp 0x6f1e
movsd -0x98(%rbp), %xmm1
movsd -0x90(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0x40a0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x190ba(%rip), %xmm1    # 0x20008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x42a0
movq %rax, -0xa8(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0x40(%rbp), %esi
leaq -0x78(%rbp), %rdi
callq 0x6580
jmp 0x6f91
movq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6df0
movq -0x88(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movl %eax, %ecx
movq -0xa8(%rbp), %rax
movslq %ecx, %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdx
callq 0xa900
jmp 0x6fcd
leaq -0x78(%rbp), %rdi
callq 0x4230
leaq -0x28(%rbp), %rdi
callq 0x9320
jmp 0x6ecc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x702c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4230
jmp 0x702c
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x701f
movq -0x88(%rbp), %rdi
callq 0x9520
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x9520
movq -0x48(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x9340
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x45d0
movq -0xa0(%rbp), %rdx
leaq 0x19071(%rip), %rsi     # 0x2010c
leaq -0x58(%rbp), %rdi
callq 0x44d0
jmp 0x70a6
leaq -0x58(%rbp), %rdi
addq $0x20, %rdi
leaq -0x1525(%rip), %rsi     # 0x5b90
callq 0x9740
leaq -0x59(%rbp), %rdi
callq 0x4430
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x9260
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x9290
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x92c0
testb $0x1, %al
jne 0x7101
jmp 0x719c
leaq -0x80(%rbp), %rdi
callq 0x9300
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl 0x2b283(%rip), %edx     # 0x323a8
leaq -0x58(%rbp), %rsi
callq 0x57d0
movl %eax, -0xb4(%rbp)
jmp 0x7136
movq -0xc0(%rbp), %rsi
movq -0xb0(%rbp), %rdi
movl -0xb4(%rbp), %eax
movl %eax, -0x94(%rbp)
leaq -0x94(%rbp), %rdx
callq 0xa6b0
jmp 0x715e
jmp 0x7160
leaq -0x80(%rbp), %rdi
callq 0x9320
jmp 0x70e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x4430
jmp 0x71cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9450
jmp 0x71cb
movb $0x1, -0x11(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x9450
testb $0x1, -0x11(%rbp)
jne 0x71bb
movq -0xb0(%rbp), %rdi
callq 0x9520
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x9520
movq -0x68(%rbp), %rdi
callq 0x45c0
// File: Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: ipd::genetic::mutate_strategy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)::$_0::operator()(char) const
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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %edi, %edi
movl $0x64, %esi
callq 0x1c900
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jg 0x919b
callq 0x6430
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0x9195
movb $0x64, -0x1(%rbp)
jmp 0x91a1
movb $0x63, -0x1(%rbp)
jmp 0x91a1
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42a0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa980
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edi
movq %rdi, -0x98(%rbp)
callq 0xa1f0
movq -0x98(%rbp), %rdx
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0x4400
movq -0x98(%rbp), %rdx
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq -0x70(%rbp), %rdi
callq 0x4400
jmp 0x7388
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42a0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x7418
movq -0x10(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x4440
movsbl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x4240
jmp 0x73d7
jmp 0x73d9
movq -0x88(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x88(%rbp)
jmp 0x7393
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x74b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4230
jmp 0x74b5
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x42a0
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
jae 0x747d
movq -0x18(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x4440
movsbl (%rax), %esi
leaq -0x50(%rbp), %rdi
callq 0x4240
jmp 0x7467
jmp 0x7469
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0x7423
movq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xa9c0
jmp 0x7493
leaq -0x70(%rbp), %rdi
callq 0x4230
leaq -0x50(%rbp), %rdi
callq 0x4230
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x4230
movq -0x78(%rbp), %rdi
callq 0x45c0
nopw (%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xa3f0
leaq -0x807(%rip), %rsi      # 0x71e0
movq 0x2a5b2(%rip), %rdx     # 0x31fa0
leaq -0x28(%rbp), %rdi
leaq -0x14(%rbp), %rcx
callq 0xb360
jmp 0x79fd
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl 0x2a9a7(%rip), %eax     # 0x323b4
jge 0x7aea
movq -0x10(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb3b0
jmp 0x7a26
leaq -0xd0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb150
jmp 0x7a38
leaq -0x98(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x6690
jmp 0x7a4d
movq -0xe0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xa410
jmp 0x7a62
leaq -0x98(%rbp), %rdi
callq 0x9450
leaq -0xd0(%rbp), %rdi
callq 0xa3c0
leaq -0x58(%rbp), %rdi
callq 0x4230
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x7a04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x7b10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x7adf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x7ad3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x9450
leaq -0xd0(%rbp), %rdi
callq 0xa3c0
leaq -0x58(%rbp), %rdi
callq 0x4230
jmp 0x7b10
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x7b00
movq -0xe0(%rbp), %rdi
callq 0x9890
movq -0xd8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0x9890
movq -0x30(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rcx, -0xa0(%rbp)
movq %rsi, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x98(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x79b0
movq -0xa8(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0xb400
jmp 0x7c88
movq -0xa0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0xaa70
jmp 0x7c9e
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x94c0
movq -0xb8(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x94f0
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xb470
movq %rax, -0xb0(%rbp)
jmp 0x7cd8
movq -0xb0(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xb540
movq -0x98(%rbp), %rsi
movq %rax, %rdi
callq 0xb4b0
testb $0x1, %al
jne 0x7d01
jmp 0x7d2f
movl $0x3, -0x80(%rbp)
jmp 0x7d50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7d72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9520
jmp 0x7d72
leaq -0x68(%rbp), %rdi
callq 0xb540
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0xb560
jmp 0x7d49
movl $0x0, -0x80(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9520
leaq -0x38(%rbp), %rdi
callq 0x9890
movl -0x80(%rbp), %eax
testl %eax, %eax
je 0x7d6d
jmp 0x7d6b
jmp 0x7d7d
jmp 0x7c59
leaq -0x38(%rbp), %rdi
callq 0x9890
jmp 0x7da0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0xb5a0
movq -0x88(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x45c0
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x7f32
movq -0x88(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x7b30
movq -0x98(%rbp), %rdi
callq 0x7db0
movl %eax, -0x8c(%rbp)
jmp 0x7ecc
movq -0x88(%rbp), %rdi
callq 0x7db0
movl %eax, -0x9c(%rbp)
jmp 0x7ee0
movl -0x8c(%rbp), %eax
movl -0x9c(%rbp), %ecx
cmpl %ecx, %eax
jle 0x7f1b
movq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xb560
jmp 0x7f02
jmp 0x7f1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9450
jmp 0x7f4f
leaq -0x60(%rbp), %rdi
callq 0x9450
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7e92
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0xb5a0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x45c0
nopl (%rax,%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movl 0x2a103(%rip), %eax     # 0x323b4
movl %eax, -0x114(%rbp)
movl 0x2a0fb(%rip), %eax     # 0x323b8
movl %eax, -0x110(%rbp)
movl 0x2a0f3(%rip), %eax     # 0x323bc
movl %eax, -0x10c(%rbp)
leaq -0x1286(%rip), %rsi     # 0x7050
leaq -0x60(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xb6f0
movl -0x114(%rbp), %esi
movl -0x110(%rbp), %edx
movl -0x10c(%rbp), %ecx
movq -0x108(%rbp), %r8
leaq -0x40(%rbp), %rdi
callq 0x74d0
jmp 0x830a
leaq -0x60(%rbp), %rdi
callq 0xb690
leaq 0x2a046(%rip), %rsi     # 0x32360
leaq -0x88(%rbp), %rdi
callq 0xb780
jmp 0x8328
leaq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb400
jmp 0x833a
movl 0x2a068(%rip), %edx     # 0x323a8
leaq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x59c0
jmp 0x8355
leaq -0xa0(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x94c0
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x94f0
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0xb870
testb $0x1, %al
jne 0x83a5
jmp 0x8474
leaq -0xb0(%rbp), %rdi
callq 0xb8b0
movq %rax, %rsi
leaq -0x100(%rbp), %rdi
callq 0xb8d0
jmp 0x83c2
movq 0x29bef(%rip), %rdi     # 0x31fb8
leaq -0x100(%rbp), %rsi
callq 0x56f0
movq %rax, -0x120(%rbp)
jmp 0x83de
movq -0x120(%rbp), %rdi
movq 0x29b8c(%rip), %rsi     # 0x31f78
callq 0x4420
jmp 0x83f3
leaq -0x100(%rbp), %rdi
callq 0x9430
leaq -0xb0(%rbp), %rdi
callq 0xb910
jmp 0x8389
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb690
jmp 0x84f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x84ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x84e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x84d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x9430
jmp 0x84d5
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0xb330
movq -0x130(%rbp), %rdi
movq %rax, -0x128(%rbp)
callq 0xb330
movq -0x128(%rbp), %rdi
movl 0x40(%rax), %esi
callq 0x81d0
jmp 0x84ab
leaq -0xa0(%rbp), %rdi
callq 0x9520
leaq -0x88(%rbp), %rdi
callq 0x9890
leaq -0x40(%rbp), %rdi
callq 0x9450
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
leaq -0xa0(%rbp), %rdi
callq 0x9520
leaq -0x88(%rbp), %rdi
callq 0x9890
leaq -0x40(%rbp), %rdi
callq 0x9450
movq -0x68(%rbp), %rdi
callq 0x45c0
nop
// File: 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
subq $0x170, %rsp            # imm = 0x170
leaq -0xb8(%rbp), %rdi
movq %rdi, -0x160(%rbp)
movl $0x3, %esi
callq 0xa290
movq -0x160(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x6690
jmp 0x8535
movl 0x29e7d(%rip), %edx     # 0x323b8
movl 0x29e7f(%rip), %ecx     # 0x323c0
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7e60
jmp 0x8550
leaq -0x80(%rbp), %rdi
callq 0x9450
leaq -0xb8(%rbp), %rdi
callq 0xa3c0
leaq 0x29df4(%rip), %rsi     # 0x32360
leaq -0xe0(%rbp), %rdi
callq 0xb780
jmp 0x857a
leaq -0xe0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb400
jmp 0x858c
movl 0x29e16(%rip), %edx     # 0x323a8
leaq -0xf8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x59c0
jmp 0x85a7
leaq -0xf8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x100(%rbp), %rdi
callq 0x94c0
movq %rax, -0x108(%rbp)
movq -0x100(%rbp), %rdi
callq 0x94f0
movq %rax, -0x110(%rbp)
leaq -0x108(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0xb870
testb $0x1, %al
jne 0x85f7
jmp 0x8701
leaq -0x108(%rbp), %rdi
callq 0xb8b0
movq %rax, %rsi
leaq -0x158(%rbp), %rdi
callq 0xb8d0
jmp 0x8614
movq 0x2999d(%rip), %rdi     # 0x31fb8
leaq -0x158(%rbp), %rsi
callq 0x56f0
movq %rax, -0x168(%rbp)
jmp 0x8630
movq -0x168(%rbp), %rdi
movq 0x2993a(%rip), %rsi     # 0x31f78
callq 0x4420
jmp 0x8645
leaq -0x158(%rbp), %rdi
callq 0x9430
leaq -0x108(%rbp), %rdi
callq 0xb910
jmp 0x85db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x8691
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9450
leaq -0xb8(%rbp), %rdi
callq 0xa3c0
jmp 0x874c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x8743
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x8737
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x872b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x9430
jmp 0x872b
leaq -0xf8(%rbp), %rdi
callq 0x9520
leaq -0xe0(%rbp), %rdi
callq 0x9890
leaq -0x40(%rbp), %rdi
callq 0x9450
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
leaq -0xf8(%rbp), %rdi
callq 0x9520
leaq -0xe0(%rbp), %rdi
callq 0x9890
leaq -0x40(%rbp), %rdi
callq 0x9450
movq -0xc0(%rbp), %rdi
callq 0x45c0
nopl (%rax,%rax)
// File: Quinny[P]IteratedPrisoners/main.cpp
// Function: restart_hill_against_classic(int)
void restart_hill_against_classic(int restarts) {
    using namespace ipd;
    auto hill_guy = hill_climb::restart_climb(
        genetic::random_prisoner_t(config::mem_first, config::mem_last),
        config::mutation_rate,
        genetic::evaluate_vs_tft,
        restarts
    );
    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
subq $0x170, %rsp            # imm = 0x170
movl %edi, -0x4(%rbp)
movslq 0x29c37(%rip), %rsi     # 0x323ac
movslq 0x29c34(%rip), %rdx     # 0x323b0
leaq -0x88(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x68a0
movl 0x29c23(%rip), %eax     # 0x323b8
movl %eax, -0x154(%rbp)
leaq -0x1752(%rip), %rsi     # 0x7050
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0xb6f0
movq -0x160(%rbp), %rsi
movl -0x154(%rbp), %edx
movq -0x150(%rbp), %rcx
movl -0x4(%rbp), %r8d
leaq -0x48(%rbp), %rdi
callq 0x7f60
jmp 0x87d8
leaq -0xa8(%rbp), %rdi
callq 0xb690
leaq -0x88(%rbp), %rdi
callq 0x9450
leaq 0x29b69(%rip), %rsi     # 0x32360
leaq -0xd0(%rbp), %rdi
callq 0xb780
jmp 0x8805
leaq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb400
jmp 0x8817
movl 0x29b8b(%rip), %edx     # 0x323a8
leaq -0xe8(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x59c0
jmp 0x8832
leaq -0xe8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rdi
callq 0x94c0
movq %rax, -0xf8(%rbp)
movq -0xf0(%rbp), %rdi
callq 0x94f0
movq %rax, -0x100(%rbp)
leaq -0xf8(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0xb870
testb $0x1, %al
jne 0x8882
jmp 0x897b
leaq -0xf8(%rbp), %rdi
callq 0xb8b0
movq %rax, %rsi
leaq -0x148(%rbp), %rdi
callq 0xb8d0
jmp 0x889f
movq 0x29712(%rip), %rdi     # 0x31fb8
leaq -0x148(%rbp), %rsi
callq 0x56f0
movq %rax, -0x168(%rbp)
jmp 0x88bb
movq -0x168(%rbp), %rdi
movq 0x296af(%rip), %rsi     # 0x31f78
callq 0x4420
jmp 0x88d0
leaq -0x148(%rbp), %rdi
callq 0x9430
leaq -0xf8(%rbp), %rdi
callq 0xb910
jmp 0x8866
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xb690
leaq -0x88(%rbp), %rdi
callq 0x9450
jmp 0x89c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x89bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x89b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x89a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x9430
jmp 0x89a5
leaq -0xe8(%rbp), %rdi
callq 0x9520
leaq -0xd0(%rbp), %rdi
callq 0x9890
leaq -0x48(%rbp), %rdi
callq 0x9450
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
leaq -0xe8(%rbp), %rdi
callq 0x9520
leaq -0xd0(%rbp), %rdi
callq 0x9890
leaq -0x48(%rbp), %rdi
callq 0x9450
movq -0xb0(%rbp), %rdi
callq 0x45c0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x6120
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x62d0
callq 0x8500
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x91b0
movq -0x70(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42a0
movq %rax, -0x60(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xcb70
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0xcb90
jmp 0xb1b0
leaq -0x11(%rbp), %rdi
callq 0xcc00
movq -0x10(%rbp), %rdi
callq 0x42a0
movq %rax, %rdi
callq 0xa8a0
movsd %xmm0, -0x88(%rbp)
movl $0x4, %edi
callq 0xa8e0
movaps %xmm0, %xmm1
movsd -0x88(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0x40a0
movq -0x78(%rbp), %rax
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0x14dfd(%rip), %xmm1    # 0x20008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x43b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4600
movq -0x78(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x18, %rdi
callq 0xcc70
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xeda0
movq %rax, -0x80(%rbp)
jmp 0xb260
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xcc00
jmp 0xb29d
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xccd0
movq -0x70(%rbp), %rdi
callq 0x9240
movq -0x20(%rbp), %rdi
callq 0x45c0
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x10(%rax)
je 0xd97c
jmp 0xd9eb
callq 0x4060
movq -0x28(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rsi)
movq %rsi, %rdi
addq $0x8, %rdi
callq 0xda30
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xda00
movsd %xmm0, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xda80
movq -0x28(%rbp), %rsi
movsd %xmm0, -0x30(%rbp)
addq $0x18, %rsi
leaq 0x249ac(%rip), %rdi     # 0x32378
callq 0xdaa0
movsd -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movb $0x1, 0x10(%rdi)
callq 0xdb80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x9630
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9630
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x30(%rcx), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0x14d75
movq -0x48(%rbp), %rdi
callq 0x9710
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14dd0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x14cf9
movq -0x10(%rbp), %rdi
callq 0x9710
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14dd0
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x14d02
jmp 0x14d04
jmp 0x14d75
leaq -0x20(%rbp), %rdi
callq 0x9660
cmpl $0x0, (%rax)
jne 0x14d29
movq -0x30(%rbp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9660
cmpl $0x0, (%rax)
jne 0x14d52
movq -0x30(%rbp), %rax
addq $0x1, %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x116b0
leaq -0x28(%rbp), %rdi
callq 0x116b0
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
jmp 0x14c9e
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2982
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x2070
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
jne 0x2906
leaq 0x884(%rip), %rdi       # 0x3183
callq 0x20f0
jmp 0x2971
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x1c(%rbp), %rcx
movl $0x4, %r8d
callq 0x2240
cmpl $-0x1, %eax
jne 0x293d
leaq 0x866(%rip), %rdi       # 0x3194
callq 0x20f0
movl $0x1, %edi
callq 0x2160
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2040
cmpl $-0x1, %eax
jne 0x296f
movl -0xc(%rbp), %edi
callq 0x2270
leaq 0x837(%rip), %rdi       # 0x319f
callq 0x20f0
jmp 0x2971
jmp 0x2982
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x28cb
cmpq $0x0, -0x18(%rbp)
jne 0x29ab
movq 0x2648(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
leaq 0x814(%rip), %rsi       # 0x31ae
movb $0x0, %al
callq 0x21d0
movl $0x2, %edi
callq 0x2160
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ostafen[P]Fast-Insertion-Sort/src/main.cpp
// Function: run_string()
void run_string()
{
  cout << "########## Type : string ##########" << endl
       << endl;

  std::vector<SortAlgorithm<string> *> algos;

  algos.push_back(new QuickSort<string>);
  algos.push_back(new MergeSort<string>);
  
  /*algos.push_back(new BlockInsertionSort<string>);
  algos.push_back(new InplaceInsertionBlock<string>);
  algos.push_back(new InPlaceRBIS<string>);
  algos.push_back(new RBIS<string>);
  algos.push_back(new MergeSort<string>);
  algos.push_back(new QuickSort<string>);
  algos.push_back(new HeapSort<string>);
  algos.push_back(new QuickInsertionSort<string>);
  algos.push_back(new BCIS<string>);
  algos.push_back(new CBIS<string>);
*/
  StringArrayGenerator stringGen;
  BenchmarkExecutor<string> stringExecutor(&stringGen, 2, 131072);
  stringExecutor.run(&algos, 1000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0xe6b9(%rip), %rdi      # 0x11fd8
leaq 0x875b(%rip), %rsi      # 0xc081
callq 0x3210
movq %rax, %rdi
movq 0xe693(%rip), %rsi      # 0x11fc8
movq %rsi, -0x68(%rbp)
callq 0x3240
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
leaq -0x18(%rbp), %rdi
callq 0x4490
movl $0x10, %edi
callq 0x3220
movq %rax, -0x60(%rbp)
jmp 0x3963
movq -0x60(%rbp), %rdi
callq 0x44e0
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x44b0
jmp 0x3983
movl $0x8, %edi
callq 0x3220
movq %rax, -0x70(%rbp)
jmp 0x3993
movq -0x70(%rbp), %rdi
callq 0x4520
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x44b0
jmp 0x39b3
leaq -0x48(%rbp), %rdi
callq 0x4560
jmp 0x39be
leaq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x2, %edx
movl $0x20000, %ecx          # imm = 0x20000
callq 0x45a0
jmp 0x39d7
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x45d0
jmp 0x39eb
leaq -0x18(%rbp), %rdi
callq 0x4c00
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4c00
movq -0x28(%rbp), %rdi
callq 0x3390
nopl (%rax,%rax)
// File: ostafen[P]Fast-Insertion-Sort/src/main.cpp
// Function: run_double()
void run_double()
{
  cout << "########## Type : double ##########" << endl
       << endl;

  std::vector<SortAlgorithm<double> *> algos;

  algos.push_back(new QuickSort<double>);
  algos.push_back(new MergeSort<double>);
  
  DoubleArrayGenerator doubleGen;
  BenchmarkExecutor<double> doubleExecutor(&doubleGen, 2, 131072);
  doubleExecutor.run(&algos, 1000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0xe5a9(%rip), %rdi      # 0x11fd8
leaq 0x866f(%rip), %rsi      # 0xc0a5
callq 0x3210
movq %rax, %rdi
movq 0xe583(%rip), %rsi      # 0x11fc8
movq %rsi, -0x68(%rbp)
callq 0x3240
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x3240
leaq -0x18(%rbp), %rdi
callq 0x4c60
movl $0x10, %edi
callq 0x3220
movq %rax, -0x60(%rbp)
jmp 0x3a73
movq -0x60(%rbp), %rdi
callq 0x4cb0
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4c80
jmp 0x3a93
movl $0x8, %edi
callq 0x3220
movq %rax, -0x70(%rbp)
jmp 0x3aa3
movq -0x70(%rbp), %rdi
callq 0x4cf0
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4c80
jmp 0x3ac3
leaq -0x48(%rbp), %rdi
callq 0x4d30
jmp 0x3ace
leaq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x2, %edx
movl $0x20000, %ecx          # imm = 0x20000
callq 0x4d70
jmp 0x3ae7
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x4da0
jmp 0x3afb
leaq -0x18(%rbp), %rdi
callq 0x52e0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x52e0
movq -0x28(%rbp), %rdi
callq 0x3390
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl $0x20, %edi
callq 0x3220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x8550
jmp 0x3bd6
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3c7b
movl -0x20(%rbp), %eax
movl %eax, %ecx
incl %ecx
cvtsi2ss %ecx, %xmm0
addl $0x2, %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movl $0x20, %edi
callq 0x3220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movss -0x24(%rbp), %xmm0
movq -0x10(%rbp), %rsi
callq 0x85c0
jmp 0x3c30
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3be5
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x3230
jmp 0x3c91
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x3230
jmp 0x3c91
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x8610
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3390
nopw (%rax,%rax)
// File: ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: InplaceInsertionBlock<int>::sort(int*, int)
virtual void sort(T *A, int n)
    {
        int k = sqrt(n);
        if (n < k)
        {
            insertion_sort(A, n);
            return;
        }

        int i;
        for (i = k + 1; i < n - k; i += k)
        {
            insertion_sort(A + i, k);
            inplace_insertion_block(A, i + k - 1, k);
        }
        i -= k;
        while (k > 1)
        {
            k = (n - i) / 2;
            i += k;
            insertion_sort(A + i, k);
            inplace_insertion_block(A, i + k - 1, k);
        }

        for (; i < n; i++)
            insertion(A, i);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x55b0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5457
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x55d0
jmp 0x5532
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jge 0x54ac
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl -0x18(%rbp), %edx
callq 0x55d0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
addl -0x18(%rbp), %edx
subl $0x1, %edx
movl -0x18(%rbp), %ecx
callq 0x5620
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5460
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x18(%rbp)
jle 0x550d
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
subl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl -0x18(%rbp), %edx
callq 0x55d0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
addl -0x18(%rbp), %edx
subl $0x1, %edx
movl -0x18(%rbp), %ecx
callq 0x5620
jmp 0x54b7
jmp 0x550f
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5532
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5790
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x550f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)