LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Quinny[P]IteratedPrisoners/main.cpp
// Function: winner_battle()
void winner_battle() {
    using namespace ipd;

    std::string genome;
    int n;
    std::ifstream f("winners.txt");
    std::vector<prisoner_t> winners;

    while (f >> genome >> n)
        winners.emplace_back(
            make_prisoner_t(genetic::genetic_strategy(genome))
        );

    auto sb = play_tourny(winners, ipd::config::rounds);
    for (auto i: sb)
        std::cout << i.first << ", " << i.second << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
leaq -0x98(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x64f9(%rip), %rsi      # 0xd155
leaq -0x2f8(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x4540
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq -0x2f8(%rbp), %r14
leaq -0xa8(%rbp), %r15
leaq -0x2c(%rbp), %r12
leaq -0x88(%rbp), %r13
leaq -0xf0(%rbp), %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x43f0
movq %rax, %rdi
movq %r12, %rsi
callq 0x4210
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6cf2
movq %r13, %rdi
movq %r15, %rsi
callq 0x7836
movq %rbx, %rdi
movq %r13, %rsi
callq 0x57a1
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x7ac8
movq %rbx, %rdi
callq 0x6ed6
movq %r13, %rdi
callq 0x7342
jmp 0x6c9a
movl 0xe650(%rip), %edx      # 0x15348
leaq -0x88(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x511f
movq -0x88(%rbp), %rbx
movq -0x80(%rbp), %r13
leaq -0xf0(%rbp), %r14
movq 0xe297(%rip), %r15      # 0x14fb8
leaq 0x635a(%rip), %r12      # 0xd082
cmpq %r13, %rbx
je 0x6d72
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7aaa
movq %r15, %rdi
movq %r14, %rsi
callq 0x4300
movq %r15, %rdi
movq %r12, %rsi
callq 0x4380
movl -0xb0(%rbp), %esi
movq %rax, %rdi
callq 0x4500
movq %rax, %rdi
callq 0x4180
movq %r14, %rdi
callq 0x6ed6
addq $0x48, %rbx
jmp 0x6d28
leaq -0x88(%rbp), %rdi
callq 0x6ef6
leaq -0x50(%rbp), %rdi
callq 0x6f7a
leaq -0x2f8(%rbp), %rdi
callq 0x40f0
leaq -0xa8(%rbp), %rdi
callq 0x4160
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6de1
movq %rax, %rbx
jmp 0x6e16
movq %rax, %rbx
jmp 0x6df5
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x6ed6
jmp 0x6dd1
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x7342
jmp 0x6e01
jmp 0x6de1
movq %rax, %rbx
jmp 0x6e01
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x6ed6
leaq -0x88(%rbp), %rdi
callq 0x6ef6
leaq -0x50(%rbp), %rdi
callq 0x6f7a
leaq -0x2f8(%rbp), %rdi
callq 0x40f0
leaq -0xa8(%rbp), %rdi
callq 0x4160
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O2/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 0x543e
movl %r14d, %edi
movq %rbx, %rsi
callq 0x5564
callq 0x692a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Quinny[P]IteratedPrisoners/./ipd/genetic.h
// Function: std::vector<ipd::prisoner_t, std::allocator<ipd::prisoner_t>> ipd::genetic::weighted_random_sample<ipd::prisoner_t>(std::vector<std::pair<ipd::prisoner_t, int>, std::allocator<std::pair<ipd::prisoner_t, int>>> const&, int)
std::vector<T>
weighted_random_sample(const std::vector<std::pair<T, int>>& v, int n) {
    qp::profiler selection_prof("weighted sample");
    std::vector<int> cummulative;
    int total = 0;
    for (auto& i: v) {
        total += i.second;
        cummulative.push_back(total);
    }

    std::vector<T> sample(n);
    for (int i = 0; i < n; ++i) {
        int prob = random_range(0, total - 1);
        auto it = std::upper_bound(cummulative.begin(), cummulative.end(), prob);
        assert(it != cummulative.end());
        auto index = std::distance(cummulative.begin(), it);
        sample[i] = v[index].first;
    }

    return sample;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5bcd(%rip), %rsi      # 0xd1c7
leaq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x4130
movq %rbx, -0x60(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7362
leaq -0x80(%rbp), %rdi
callq 0x4160
leaq -0x50(%rbp), %r12
andq $0x0, 0x10(%r12)
leaq -0x30(%rbp), %r13
andl $0x0, (%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq (%r15), %rbx
movq %r15, -0x58(%rbp)
movq 0x8(%r15), %r15
cmpq %r15, %rbx
je 0x7666
movl 0x40(%rbx), %eax
addl %eax, -0x30(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xb858
addq $0x48, %rbx
jmp 0x764a
movslq %r14d, %rsi
leaq -0x2c(%rbp), %rdx
movq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0xb87e
xorl %r13d, %r13d
testl %r14d, %r14d
cmovlel %r13d, %r14d
shlq $0x6, %r14
leaq -0x2c(%rbp), %r12
movq -0x58(%rbp), %r15
cmpq %r13, %r14
je 0x76d9
movl -0x30(%rbp), %esi
decl %esi
xorl %edi, %edi
callq 0xb7d3
movl %eax, -0x2c(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %r12, %rdx
callq 0xba9c
cmpq -0x48(%rbp), %rax
je 0x7703
subq -0x50(%rbp), %rax
shrq $0x2, %rax
imulq $0x48, %rax, %rsi
addq (%r15), %rsi
movq (%rbx), %rdi
addq %r13, %rdi
callq 0x798a
addq $0x40, %r13
jmp 0x768f
leaq -0x50(%rbp), %rdi
callq 0xbada
leaq -0xb8(%rbp), %rdi
callq 0x74e8
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5acd(%rip), %rdi      # 0xd1d7
leaq 0x5ade(%rip), %rsi      # 0xd1ef
leaq 0x5ae7(%rip), %rcx      # 0xd1ff
movl $0xa5, %edx
callq 0x4240
jmp 0x7748
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x4160
jmp 0x7760
movq %rax, %r14
jmp 0x7760
jmp 0x773b
jmp 0x773b
movq %rax, %r14
movq %rbx, %rdi
callq 0x6f7a
jmp 0x774b
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0xbada
leaq -0xb8(%rbp), %rdi
callq 0x74e8
movq %r14, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r15
leaq 0x18(%rdi), %r14
movq 0x8(%rsi), %rsi
leaq -0x19(%rbp), %rdx
movq %r14, %rdi
callq 0x7de2
movq 0x8(%r15), %rdi
callq 0x7510
divsd 0x57a1(%rip), %xmm0     # 0xd018
callq 0x4090
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x5784(%rip), %xmm0     # 0xd010
cvttsd2si %xmm0, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x30(%rbx)
movq (%r15), %rdi
movq 0x8(%r15), %rsi
addq %rdi, %rsi
movq 0x18(%rbx), %rdx
callq 0x8510
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x7e6e
jmp 0x78cd
movq %rax, %r15
movq %rbx, %rdi
callq 0x7b1a
movq %r15, %rdi
callq 0x4520
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7fd7
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4050
movq %rax, 0x8(%rbx)
subq (%rbx), %rax
cvtsi2sd %rax, %xmm0
divsd 0x5027(%rip), %xmm0     # 0xd020
movsd %xmm0, -0x10(%rbp)
leaq 0x18(%rbx), %rsi
leaq 0xd30f(%rip), %rdi      # 0x15318
callq 0x802e
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 0x8098
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
movq 0x30(%rdi), %rdx
addq %rdx, %rdx
xorl %r8d, %r8d
movl $0x1, %r9d
movl $0x2, %r10d
movq %rsi, %r11
movq %rdi, %rbx
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rdx, %rcx
jae 0x9c9a
movq (%rbx), %rbx
cmpq %rdi, %rbx
je 0x9c9a
movq (%r11), %r11
cmpq %rsi, %r11
je 0x9c9a
movl %r9d, %r14d
shll %cl, %r14d
cmpl %r8d, 0x10(%rbx)
cmovnel %r8d, %r14d
movl %r10d, %r15d
shll %cl, %r15d
cmpl %r8d, 0x10(%r11)
cmovnel %r8d, %r15d
movslq %r15d, %r15
orq %rax, %r14
orq %r15, %r14
addq $0x2, %rcx
movq %r14, %rax
jmp 0x9c57
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl $0x1, (%r14)
leaq 0xb91(%rip), %rbp       # 0x3183
pushq $0x2
popq %r15
pushq $0x4
popq %r12
testq %rbx, %rbx
je 0x2670
movl 0x4(%rbx), %edi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x2080
movq %rbp, %rdi
cmpl $-0x1, %eax
je 0x2653
movl %eax, %r13d
movl %eax, %edi
pushq $0x1
popq %rsi
movl %r15d, %edx
movq %r14, %rcx
movl %r12d, %r8d
callq 0x21e0
cmpl $-0x1, %eax
je 0x2690
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
movl %r13d, %edi
callq 0x2040
cmpl $-0x1, %eax
jne 0x265e
movl %r13d, %edi
callq 0x2220
leaq 0xb4c(%rip), %rdi       # 0x319f
callq 0x20f0
movq 0x28(%rbx), %rbx
jmp 0x25fa
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2961(%rip), %rax      # 0x4fd8
movq (%rax), %rcx
leaq 0xb2d(%rip), %rdi       # 0x31ae
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x2200
pushq $0x2
jmp 0x269e
leaq 0xafd(%rip), %rdi       # 0x3194
callq 0x20f0
pushq $0x1
popq %rdi
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq 0x7926(%rip), %rdi      # 0xafd8
leaq 0x39b8(%rip), %rsi      # 0x7071
callq 0x31c0
movq %rax, %rdi
callq 0x30c0
movq %rax, %rdi
callq 0x30c0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x10
popq %rdi
callq 0x31d0
leaq 0x73de(%rip), %rcx      # 0xaac8
movq %rcx, (%rax)
leaq 0x741c(%rip), %rcx      # 0xab10
movq %rcx, 0x8(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x61da
pushq $0x8
popq %rdi
callq 0x31d0
leaq 0x7431(%rip), %rcx      # 0xab48
movq %rcx, (%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x61da
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x3bea
leaq 0x30(%rsp), %rdi
movq %rbx, (%rdi)
movabsq $0x2000000000002, %rax  # imm = 0x2000000000002
movq %rax, 0x8(%rdi)
movq %rsp, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x3c06
movq %rsp, %rdi
callq 0x61a6
addq $0x40, %rsp
popq %rbx
retq
jmp 0x376e
jmp 0x376e
jmp 0x376e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x61a6
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq 0x784b(%rip), %rdi      # 0xafd8
leaq 0x3901(%rip), %rsi      # 0x7095
callq 0x31c0
movq %rax, %rdi
callq 0x30c0
movq %rax, %rdi
callq 0x30c0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x10
popq %rdi
callq 0x31d0
leaq 0x7413(%rip), %rcx      # 0xabd8
movq %rcx, (%rax)
leaq 0x7451(%rip), %rcx      # 0xac20
movq %rcx, 0x8(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x6410
pushq $0x8
popq %rdi
callq 0x31d0
leaq 0x7466(%rip), %rcx      # 0xac58
movq %rcx, (%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x6410
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x3f6c
leaq 0x30(%rsp), %rdi
movq %rbx, (%rdi)
movabsq $0x2000000000002, %rax  # imm = 0x2000000000002
movq %rax, 0x8(%rdi)
movq %rsp, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x3f90
movq %rsp, %rdi
callq 0x63dc
addq $0x40, %rsp
popq %rbx
retq
jmp 0x3849
jmp 0x3849
jmp 0x3849
movq %rax, %rbx
movq %rsp, %rdi
callq 0x63dc
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
pushq $0x20
popq %rdi
callq 0x31d0
movq %rax, %r14
movq %rax, %rdi
callq 0x5784
pushq $0x1
popq %rcx
pushq $0x20
popq %r15
leaq 0x7453(%rip), %r12      # 0xace8
cmpl %ebx, %ecx
jge 0x38d2
leal 0x1(%rcx), %ebp
cvtsi2ss %ebp, %xmm1
addl $0x2, %ecx
cvtsi2ss %ecx, %xmm0
divss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movq %r15, %rdi
callq 0x31d0
movq %r12, (%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
movq %r14, 0x10(%rax)
movl %ebp, %ecx
movq %rax, %r14
jmp 0x3895
movl %ebx, 0x18(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
cvtsi2sd %edx, %xmm0
movq %rdi, %r15
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x428c
sqrtsd %xmm0, %xmm0
jmp 0x4291
callq 0x3140
cvttsd2si %xmm0, %r13d
movl %ebx, %eax
subl %r13d, %eax
jge 0x42b8
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43ba
movl %ebx, 0x4(%rsp)
leal 0x1(%r13), %ecx
movslq %ecx, %rbx
movslq %r13d, %rcx
cltq
movq %rax, 0x20(%rsp)
leaq (%r14,%rbx,4), %rbp
movq %rcx, 0x18(%rsp)
leaq (,%rcx,4), %rax
movq %rax, 0x10(%rsp)
leal (%r13,%r13), %eax
movq %rax, 0x8(%rsp)
pushq $0x1
popq %r12
cmpq 0x20(%rsp), %rbx
jge 0x432e
movq %r15, %rdi
movq %rbp, %rsi
movl %r13d, %edx
callq 0x43ba
addq 0x18(%rsp), %rbx
movq 0x8(%rsp), %rax
leal (%rax,%r12), %edx
decl %edx
movq %r15, %rdi
movq %r14, %rsi
movl %r13d, %ecx
callq 0x43ec
addl %r13d, %r12d
addq 0x10(%rsp), %rbp
jmp 0x42f1
pushq $0x2
popq %rbx
cmpl $0x1, %r13d
jle 0x436d
movl 0x4(%rsp), %eax
subl %r12d, %eax
cltd
idivl %ebx
movl %eax, %r13d
addl %eax, %r12d
movslq %r12d, %rbp
leaq (%r14,%rbp,4), %rsi
movq %r15, %rdi
movl %eax, %edx
callq 0x43ba
leal -0x1(%r13,%rbp), %edx
movq %r15, %rdi
movq %r14, %rsi
movl %r13d, %ecx
callq 0x43ec
jmp 0x4331
movl 0x4(%rsp), %ebx
cmpl %ebx, %r12d
jge 0x4389
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x448c
incl %r12d
jmp 0x4371
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: InplaceInsertionBlock<int>::inplace_insertion_block(int*, int, int)
void inplace_insertion_block(T *A, int e, int k)
    {
        int l, r;
        r = e;
        l = e - 2 * k;

        int i = e - k;
        while (i >= 0 && l >= 0 && r > (e - k))
        {
            if (A[l] > A[r])
            {
                swap(&A[i], &A[l]);
                l--;
            }
            else
            {
                swap(&A[i], &A[r]);
                r--;
            }
            i--;
        }

        while (l >= 0)
        {
            swap(&A[i], &A[l]);
            i--;
            l--;
        }

        while (r > e - k)
        {
            swap(&A[i], &A[r]);
            i--;
            r--;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %edi
subl %ecx, %edi
subl %ecx, %edi
movl %edx, %r8d
subl %ecx, %r8d
movslq %r8d, %rax
leaq (%rsi,%rax,4), %rcx
movl %r8d, %r10d
movslq %edx, %r9
testl %r10d, %r10d
js 0x4467
testl %edi, %edi
js 0x4467
cmpl %r8d, %edx
jle 0x4467
movl %edi, %r9d
movl (%rsi,%r9,4), %r11d
movslq %edx, %rbx
movl (%rsi,%rbx,4), %ebp
movl %r10d, %r14d
movl (%rsi,%r14,4), %r15d
cmpl %ebp, %r11d
jle 0x443e
movl %r11d, (%rsi,%r14,4)
movl %r15d, (%rsi,%r9,4)
decl %edi
jmp 0x4448
movl %ebp, (%rsi,%r14,4)
movl %r15d, (%rsi,%rbx,4)
decl %edx
decl %r10d
addq $-0x4, %rcx
jmp 0x4408
movl %edi, %edx
movl (%rcx), %r8d
movl (%rsi,%rdx,4), %r10d
movl %r10d, (%rcx)
movl %r8d, (%rsi,%rdx,4)
decl %edi
addq $-0x4, %rcx
testl %edi, %edi
jns 0x4451
jmp 0x4480
movl (%rcx), %edx
movl (%rsi,%r9,4), %edi
movl %edi, (%rcx)
movl %edx, (%rsi,%r9,4)
decq %r9
addq $-0x4, %rcx
cmpq %rax, %r9
jg 0x446d
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: InplaceInsertionBlock<int>::insertion(int*, int)
void insertion(T *A, int i)
    {
        int j = i - 1;
        int value = A[i];
        while (j >= 0 && A[j] > value)
        {
            A[j + 1] = A[j];
            j--;
        }
        A[j + 1] = value;
    }

// Assembly:
movslq %edx, %rdi
movl (%rsi,%rdi,4), %eax
movl %edi, %edx
movl %edi, %ecx
sarl $0x1f, %ecx
andl %edi, %ecx
testl %edx, %edx
jle 0x44b1
movl -0x4(%rsi,%rdx,4), %edi
cmpl %eax, %edi
jle 0x44af
movl %edi, (%rsi,%rdx,4)
decq %rdx
jmp 0x449b
movl %edx, %ecx
movslq %ecx, %rcx
movl %eax, (%rsi,%rcx,4)
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: InsertionSort<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::sort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int)
void sort(T *A, int n)
    {
        for (int i = 1; i < n; i++)
        {
            int j = i - 1;
            T value = A[i];
            while (j >= 0 && A[j] > value)
            {
                A[j + 1] = A[j];
                j--;
            }
            A[j + 1] = value;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movslq %edx, %rax
movq %rax, 0x10(%rsp)
pushq $0x1
popq %r12
leaq 0x18(%rsp), %r14
movq %rsi, %rbp
movq %rsi, 0x8(%rsp)
cmpq 0x10(%rsp), %r12
jge 0x4b2a
movq %r12, %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x3240
movq %rbp, %r15
movq %r12, %r13
testq %r13, %r13
jle 0x4aff
movq %r15, %rdi
movq %r14, %rsi
callq 0x4b72
testb %al, %al
je 0x4b02
leaq -0x20(%r15), %rbx
leaq 0x20(%r15), %rdi
decq %r13
movq %r15, %rsi
callq 0x30f0
movq %rbx, %r15
jmp 0x4ad3
xorl %r13d, %r13d
movslq %r13d, %rdi
shlq $0x5, %rdi
movq 0x8(%rsp), %rbx
addq %rbx, %rdi
movq %r14, %rsi
callq 0x30f0
movq %r14, %rdi
callq 0x30b0
incq %r12
addq $0x20, %rbp
jmp 0x4ab4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4b3b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: QuickSort<int>::_sort(int*, int, int)
void _sort(T arr[], int low, int high)
    {
        if(low < high) {
            int pi = partition(arr, low, high);
            _sort(arr, low, pi - 1);
            _sort(arr, pi + 1, high);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
cmpl %ebx, %ebp
jge 0x465c
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x4666
movl %eax, %r12d
leal -0x1(%r12), %ecx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x461a
incl %r12d
movl %r12d, %ebp
jmp 0x462c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: QuickSort<int>::partition(int*, int, int)
int partition(T arr[], int low, int high)
    {
        T pivot = arr[high];
        int i = (low - 1);

        for (int j = low; j <= high - 1; j++)
        {
            if (arr[j] <= pivot)
            {
                i++;
                swap(&arr[i], &arr[j]);
            }
        }
        swap(&arr[i + 1], &arr[high]);
        return i + 1;
    }

// Assembly:
movslq %ecx, %rcx
movl (%rsi,%rcx,4), %eax
movslq %edx, %rdi
decl %edx
movslq %edx, %r8
cmpq %rcx, %rdi
jge 0x4699
movl (%rsi,%rdi,4), %r9d
cmpl %eax, %r9d
jg 0x4694
leal 0x1(%r8), %edx
movl 0x4(%rsi,%r8,4), %r10d
movl %r9d, 0x4(%rsi,%r8,4)
movl %r10d, (%rsi,%rdi,4)
incq %rdi
jmp 0x4671
leal 0x1(%r8), %eax
movl 0x4(%rsi,%r8,4), %edx
movl (%rsi,%rcx,4), %edi
movl %edi, 0x4(%rsi,%r8,4)
movl %edx, (%rsi,%rcx,4)
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: QuickInsertionSort<int>::_sort(int*, int, int)
void _sort(T arr[], int low, int high)
    {
        int size = (high - low) + 1;
        if (size <= 10)
        {
            is.sort(arr + low, size);
            return;
        }
        int pi = partition(arr, low, high);
        _sort(arr, low, pi - 1);
        _sort(arr, pi + 1, high);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl %ebp, %edx
subl %r15d, %edx
cmpl $0x9, %edx
jle 0x4725
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x4742
movl %eax, %r12d
leal -0x1(%r12), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x46da
incl %r12d
movl %r12d, %r15d
jmp 0x46ed
incl %edx
addq $0x8, %r14
movslq %r15d, %rax
leaq (%rbx,%rax,4), %rsi
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: MergeSort<int>::_sort(int*, int, int, int*)
void _sort(T *A, int l, int r, T *X)
    {
        if (l < r)
        {
            int m = l + (r - l) / 2;
            _sort(A, l, m, X);
            _sort(A, m + 1, r, X);
            merge(A, l, m, r, X);
        }
    }

// Assembly:
movl %ecx, %eax
subl %edx, %eax
jle 0x484a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %r13d
leal (%r14,%r13), %ecx
movl %ecx, 0x4(%rsp)
movl %r14d, %edx
callq 0x47d6
leal (%r14,%r13), %edx
incl %edx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
movq %rbx, %r8
callq 0x47d6
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl 0x4(%rsp), %ecx
movl %ebp, %r8d
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x484c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: MergeSort<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::merge(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void merge(T arr[], int l, int m, int r, T *L)
    {
        int i, j, k;
        int n1 = m - l + 1;
        int n2 = r - m;

        //T L[n1];
        T *R = arr + m + 1; //T R[n2];

        for (i = 0; i < n1; i++)
            L[i] = arr[l + i];

        /*for (j = 0; j < n2; j++)
            R[j] = arr[m + 1 + j];*/

        i = 0;
        j = 0;
        k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        while (i < n1)
            arr[k++] = L[i++];

        while (j < n2)
            arr[k++] = R[j++];
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movl %r8d, 0x4(%rsp)
movq %rsi, %rbx
movl %ecx, %esi
subl %edx, %esi
movl %ecx, 0x8(%rsp)
movslq %ecx, %rax
shlq $0x5, %rax
addq %rbx, %rax
movq %rax, 0x18(%rsp)
movslq %edx, %rbp
movl %esi, 0x14(%rsp)
movslq %esi, %rax
movq %rax, 0x20(%rsp)
shlq $0x5, %rbp
leaq (%rbx,%rbp), %r12
xorl %r15d, %r15d
movq %r9, %r13
cmpq 0x20(%rsp), %r15
jg 0x4ea2
movq %r13, %rdi
movq %r12, %rsi
callq 0x30f0
incq %r15
addq $0x20, %r12
addq $0x20, %r13
jmp 0x4e83
movl 0x8(%rsp), %eax
subl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
addq %rbp, %rbx
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq %ebp, %r15
cmpl 0x14(%rsp), %ebp
jg 0x4f12
cmpl 0x4(%rsp), %r13d
jge 0x4f12
shlq $0x5, %r15
addq %r14, %r15
movslq %r13d, %r12
shlq $0x5, %r12
addq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4c92
movq %rbx, %rdi
testb %al, %al
je 0x4f01
movq %r15, %rsi
callq 0x30f0
incl %ebp
jmp 0x4f0c
movq %r12, %rsi
callq 0x30f0
incl %r13d
addq $0x20, %rbx
jmp 0x4ec0
movslq %r13d, %r12
movslq %ebp, %rax
shlq $0x5, %rax
addq %rax, %r14
cmpq 0x20(%rsp), %r15
jg 0x4f3e
incq %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30f0
addq $0x20, %rbx
addq $0x20, %r14
jmp 0x4f1f
movslq 0x4(%rsp), %r15
movq %r12, %rax
shlq $0x5, %rax
movq 0x18(%rsp), %rcx
leaq (%rax,%rcx), %r14
addq $0x20, %r14
cmpq %r15, %r12
jge 0x4f74
incq %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30f0
addq $0x20, %r14
addq $0x20, %rbx
jmp 0x4f57
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: HeapSort<int>::sort(int*, int)
virtual void sort(T *A, int n)
    {
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(A, n, i);

        for (int i = n - 1; i >= 0; i--)
        {
            swap(&A[0], &A[i]);
            heapify(A, i, 0);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x2
popq %rcx
movl %edx, %eax
cltd
idivl %ecx
movl %eax, %r15d
testl %r15d, %r15d
jle 0x491e
decl %r15d
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %r15d, %ecx
callq 0x4976
jmp 0x4904
movl %ebp, %r15d
testl %r15d, %r15d
jle 0x4948
decq %r15
movl %r15d, %eax
movl (%rbx), %ecx
movl (%rbx,%rax,4), %edx
movl %edx, (%rbx)
movl %ecx, (%rbx,%rax,4)
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x4976
jmp 0x4921
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: HeapSort<int>::heapify(int*, int, int)
void heapify(T arr[], int n, int i)
    {
        int largest = i;
        int l = 2 * i + 1;
        int r = 2 * i + 2;

        if (l < n && arr[l] > arr[largest])
            largest = l;

        if (r < n && arr[r] > arr[largest])
            largest = r;

        if (largest != i)
        {
            swap(&arr[i], &arr[largest]);

            heapify(arr, n, largest);
        }
    }

// Assembly:
leal 0x1(,%rcx,2), %r8d
movslq %ecx, %rax
movl %ecx, %edi
cmpl %edx, %r8d
jge 0x4999
movslq %r8d, %rdi
movl (%rsi,%rdi,4), %edi
cmpl (%rsi,%rax,4), %edi
jg 0x4996
movl %ecx, %r8d
movl %r8d, %edi
leal 0x2(,%rcx,2), %r8d
cmpl %edx, %r8d
jge 0x49bc
movslq %r8d, %r9
movl (%rsi,%r9,4), %r9d
movslq %edi, %r10
cmpl (%rsi,%r10,4), %r9d
jg 0x49b9
movl %edi, %r8d
movl %r8d, %edi
cmpl %ecx, %edi
je 0x49d7
movslq %edi, %rcx
movl (%rsi,%rax,4), %r8d
movl (%rsi,%rcx,4), %r9d
movl %r9d, (%rsi,%rax,4)
movl %r8d, (%rsi,%rcx,4)
movl %edi, %ecx
jmp 0x4976
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/gen.cpp
// Function: IntArrayGenerator::random(int)
virtual int *random(int size)
    {
        int *v = new int[size];
        for (int i = 0; i < size; i++)
        {
            v[i] = randomInt();
        }
        return v;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shlq $0x2, %rax
xorl %r12d, %r12d
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
cmovlel %r12d, %ebx
callq 0x3030
movq %rax, %r15
cmpq %r12, %rbx
je 0x4a33
movq %r14, %rdi
callq 0x4a42
movl %eax, (%r15,%r12,4)
incq %r12
jmp 0x4a1d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/gen.cpp
// Function: StringArrayGenerator::random[abi:cxx11](int)
virtual string *random(int size)
    {
        string *A = new string[size];

        for (int i = 0; i < size; i++)
        {
            int len = rand() % maxLength;
            A[i] = getRandomString(len);
        }
        return A;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r12
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rax
testl %r12d, %r12d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r14
movq %r12, (%rax)
testl %r12d, %r12d
je 0x4ff3
leaq 0x18(%r14), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x4fdd
addq $0x8, %r14
xorl %r13d, %r13d
testl %ebp, %ebp
cmovgl %ebp, %r13d
leaq 0x8(%rsp), %r15
movq %r14, %r12
subq $0x1, %r13
jb 0x503b
callq 0x3060
cltd
idivl 0x8(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x504e
movq %r12, %rdi
movq %r15, %rsi
callq 0x3200
movq %r15, %rdi
callq 0x30b0
addq $0x20, %r12
jmp 0x5008
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/gen.cpp
// Function: StringArrayGenerator::getRandomString[abi:cxx11](int)
string getRandomString(int len)
    {
        string s = "";
        for (int j = 0; j < len; j++)
            s += (char)(rand() % 256);
        return s;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x212a(%rip), %rsi      # 0x718c
leaq 0xf(%rsp), %rdx
callq 0x44b8
xorl %r14d, %r14d
testl %ebp, %ebp
cmovgl %ebp, %r14d
subl $0x1, %r14d
jb 0x508d
callq 0x3060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3160
jmp 0x5075
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x30b0
movq %r14, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/gen.cpp
// Function: DoubleArrayGenerator::random(int)
virtual double *random(int size)
    {

        double *v = new double[size];
        for (int i = 0; i < size; i++)
        {
            v[i] = randomDouble();
        }
        return v;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shlq $0x3, %rax
xorl %r12d, %r12d
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
cmovlel %r12d, %ebx
callq 0x3030
movq %rax, %r15
cmpq %r12, %rbx
je 0x539b
movq %r14, %rdi
callq 0x53aa
movsd %xmm0, (%r15,%r12,8)
incq %r12
jmp 0x5383
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/gen.cpp
// Function: DoubleArrayGenerator::randomDouble()
double randomDouble()
    {
        std::random_device rd;
        std::mt19937 gen(rd());
        double d = std::generate_canonical<double, 10>(gen);
        return d * (rand() % max);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x2718, %rsp           # imm = 0x2718
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x543a
movq %r14, %rdi
callq 0x3250
movl %eax, %esi
leaq 0x1390(%rsp), %rdi
callq 0x55c8
leaq 0x1390(%rsp), %rdi
callq 0x548f
movsd %xmm0, (%rsp)
callq 0x3060
cltd
idivl 0xc(%rbx)
cvtsi2sd %edx, %xmm0
movsd (%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x55b8
movsd (%rsp), %xmm0
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r14
retq
jmp 0x5424
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x55b8
movq %rbx, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: ChainedBlockInsertionSort<int>::sort(int*, int)
virtual void sort(T *A, int n)
    {
        int k = pow(n, exp);
        if (n < k)
        {
            algo->sort(A, n);
            return;
        }

        algo->sort(A, k);
        for (int i = k; i < n; i += k)
        {
            if (n - i < k)
                k = n - i;

            T b[k];
            for (int h = 0; h < k; h++)
                b[h] = A[i + h];

            algo->sort(b, k);
            int j = i - 1;
            int s = k - 1;
            while (s >= 0)
            {
                while (j >= 0 && A[j] > b[s])
                {
                    A[j + s + 1] = A[j];
                    j--;
                }
                A[j + s + 1] = b[s];
                s--;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cvtsi2sd %edx, %xmm0
cvtss2sd 0x8(%rdi), %xmm1
callq 0x32b0
cvttsd2si %xmm0, %edx
movq %rbx, -0x38(%rbp)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movq (%rax), %rax
cmpl %r15d, %edx
jle 0x580d
movq %r14, %rsi
movl %r15d, %edx
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %r14, %rsi
movq %rdx, %rbx
callq *%rax
movq %rbx, %r11
pushq $-0x1
popq %rbx
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
movl %r11d, %eax
movl %r15d, -0x2c(%rbp)
movl %r15d, %r13d
subl %r11d, %r13d
jle 0x5913
movq %rsp, -0x40(%rbp)
cmpl %eax, %r13d
movl %eax, -0x30(%rbp)
movl %eax, %edx
cmovll %r13d, %edx
leaq 0xf(,%rdx,4), %rax
andq $-0x10, %rax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
movslq %r11d, %rcx
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
leaq (%r14,%rcx,4), %rcx
xorl %edi, %edi
cmpq %rdi, %rax
je 0x5881
movl (%rcx,%rdi,4), %esi
movl %esi, (%r15,%rdi,4)
incq %rdi
jmp 0x5870
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rdx, -0x48(%rbp)
movq %r11, -0x50(%rbp)
callq *(%rax)
movq -0x50(%rbp), %r11
leal -0x1(%r11), %eax
movl -0x30(%rbp), %ecx
cmpl %r13d, %ecx
cmovll %ecx, %r13d
movslq %r13d, %rcx
testq %rcx, %rcx
jle 0x58ff
movslq %eax, %rdi
cmpl $-0x1, %edi
movl %ebx, %eax
cmovll %edi, %eax
leaq -0x1(%rcx), %rdx
movl (%r15,%rdx,4), %esi
leal (%rcx,%rdi), %r8d
shlq $0x20, %r8
testq %rdi, %rdi
js 0x58f1
movl (%r14,%rdi,4), %r9d
cmpl %esi, %r9d
jle 0x58ef
movq %r8, %r10
sarq $0x1e, %r10
movl %r9d, (%r14,%r10)
decq %rdi
addq %r12, %r8
jmp 0x58ce
movl %edi, %eax
addl %eax, %ecx
movslq %ecx, %rcx
movl %esi, (%r14,%rcx,4)
movq %rdx, %rcx
jmp 0x58ae
movq -0x40(%rbp), %rsp
movq -0x48(%rbp), %rax
addl %eax, %r11d
movl -0x2c(%rbp), %r15d
jmp 0x582c
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: FastInsertionSort<int>::sort(int*, int)
virtual void sort(T *A, int n)
    {
        int i = log(log_base, n);
        float exp = (float)(i - 1) / i;
        int k_0 = pow(n, exp);
        if (k_0 <= 0)
            return;

        T b[k_0];
        _sort(A, n, i, b);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movss 0x18(%rdi), %xmm0
cvtsi2ss %edx, %xmm1
callq 0x5d20
cvttss2si %xmm0, %r12d
leal -0x1(%r12), %eax
cvtsi2ss %eax, %xmm1
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
divss %xmm0, %xmm1
cvtsi2sd %ebx, %xmm0
cvtss2sd %xmm1, %xmm1
callq 0x32b0
cvttsd2si %xmm0, %eax
testl %eax, %eax
jle 0x5c89
movq %rsp, %r13
movl %eax, %eax
movq %rsp, %r8
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %r8
movq %r8, %rsp
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl %r12d, %ecx
callq 0x5d4e
movq %r13, %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: FastInsertionSort<int>::_sort(int*, int, int, int*)
void _sort(T *A, int n, int l, T *b)
    {
        float exp = (float)(l - 1) / l;
        int k = pow(n, exp);
        if (n <= k || k <= 5 || l <= 1)
        {
            is.sort(A, n);
            return;
        }

        _sort(A, k, l - 1, b);
        for (int i = k; i < n; i += k)
        {
            if (n - i < k)
                k = n - i;

            _sort(A + i, k, l - 1, b);

            for (int h = 0; h < k; h++)
                b[h] = A[i + h];

            int j = i - 1;
            int s = k - 1;
            while (s >= 0)
            {
                while (j >= 0 && A[j] > b[s])
                {
                    A[j + s + 1] = A[j];
                    j--;
                }
                A[j + s + 1] = b[s];
                s--;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movl %ecx, %ebx
movq %rsi, %r14
leal -0x1(%rbx), %eax
movl %eax, 0xc(%rsp)
cvtsi2ss %eax, %xmm1
movq %rdi, 0x10(%rsp)
cvtsi2ss %ecx, %xmm0
divss %xmm0, %xmm1
movl %edx, 0x8(%rsp)
cvtsi2sd %edx, %xmm0
cvtss2sd %xmm1, %xmm1
callq 0x32b0
cmpl $0x2, %ebx
jl 0x5eb3
cvttsd2si %xmm0, %r12d
cmpl 0x8(%rsp), %r12d
jge 0x5eb3
cmpl $0x5, %r12d
jle 0x5eb3
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
movl 0xc(%rsp), %ecx
movq %r15, %r8
callq 0x5d4e
movabsq $-0x100000000, %rbp     # imm = 0xFFFFFFFF00000000
movl %r12d, %r10d
movl 0x8(%rsp), %r13d
subl %r10d, %r13d
jle 0x5ea4
cmpl %r12d, %r13d
movl %r12d, 0x1c(%rsp)
cmovll %r13d, %r12d
movq %r10, 0x20(%rsp)
movslq %r10d, %rax
leaq (%r14,%rax,4), %rbx
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %r12d, %edx
movl 0xc(%rsp), %ecx
movq %r15, %r8
callq 0x5d4e
testl %r12d, %r12d
movl $0x0, %eax
cmovgl %r12d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x5e30
movl (%rbx,%rcx,4), %edx
movl %edx, (%r15,%rcx,4)
incq %rcx
jmp 0x5e1f
movq 0x20(%rsp), %r10
leal -0x1(%r10), %eax
movl 0x1c(%rsp), %ecx
cmpl %r13d, %ecx
cmovll %ecx, %r13d
movslq %r13d, %rcx
pushq $-0x1
popq %r11
testq %rcx, %rcx
jle 0x5e9c
leaq -0x1(%rcx), %rdx
movslq %eax, %rsi
cmpl $-0x1, %esi
movl %r11d, %eax
cmovll %esi, %eax
leal (%rcx,%rsi), %edi
shlq $0x20, %rdi
movl (%r15,%rdx,4), %r8d
testq %rsi, %rsi
js 0x5e8e
movl (%r14,%rsi,4), %r9d
cmpl %r8d, %r9d
jle 0x5e8c
movq %rdi, %r8
sarq $0x1e, %r8
movl %r9d, (%r14,%r8)
decq %rsi
addq %rbp, %rdi
jmp 0x5e67
movl %esi, %eax
addl %eax, %ecx
movslq %ecx, %rcx
movl %r8d, (%r14,%rcx,4)
movq %rdx, %rcx
jmp 0x5e4b
addl %r12d, %r10d
jmp 0x5dd4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq %r14, %rsi
movl 0x8(%rsp), %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45c0
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: BlockInsertionSort<int>::sort(int*, int)
virtual void sort(T *A, int n)
    {
        int k = sqrt(n);
        if (n < k)
        {
            is.sort(A, n);
            return;
        }

        is.sort(A, k);
        for (int i = k; i < n; i += k)
        {
            if (n - i < k)
                k = n - i;

            T b[k];
            for (int h = 0; h < k; h++)
                b[h] = A[i + h];

            is.sort(b, k);
            int j = i - 1;
            int s = k - 1;
            while (s >= 0)
            {
                while (j >= 0 && A[j] > b[s])
                {
                    A[j + s + 1] = A[j];
                    j--;
                }
                A[j + s + 1] = b[s];
                s--;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
cvtsi2sd %edx, %xmm0
movq %rdi, %r15
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x5f4f
sqrtsd %xmm0, %xmm0
jmp 0x5f54
callq 0x3140
cvttsd2si %xmm0, %edx
addq $0x10, %r15
cmpl %ebx, %edx
jle 0x5f7b
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45c0
movq %r15, -0x38(%rbp)
movq %r15, %rdi
movq %r14, %rsi
movq %rdx, %r15
callq 0x45c0
movq %r15, %r11
pushq $-0x1
popq %r15
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
movl %r11d, %eax
movl %ebx, -0x2c(%rbp)
movl %ebx, %r13d
subl %r11d, %r13d
jle 0x6085
movq %rsp, -0x40(%rbp)
cmpl %eax, %r13d
movl %eax, -0x30(%rbp)
movl %eax, %edx
cmovll %r13d, %edx
leaq 0xf(,%rdx,4), %rax
andq $-0x10, %rax
movq %rsp, %rbx
subq %rax, %rbx
movq %rbx, %rsp
movslq %r11d, %rcx
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
leaq (%r14,%rcx,4), %rcx
xorl %edi, %edi
cmpq %rdi, %rax
je 0x5ff8
movl (%rcx,%rdi,4), %esi
movl %esi, (%rbx,%rdi,4)
incq %rdi
jmp 0x5fe8
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %rdx, -0x48(%rbp)
movq %r11, -0x50(%rbp)
callq 0x45c0
movq -0x50(%rbp), %r11
leal -0x1(%r11), %eax
movl -0x30(%rbp), %ecx
cmpl %r13d, %ecx
cmovll %ecx, %r13d
movslq %r13d, %rcx
testq %rcx, %rcx
jle 0x6072
movslq %eax, %rdi
cmpl $-0x1, %edi
movl %r15d, %eax
cmovll %edi, %eax
leaq -0x1(%rcx), %rdx
movl (%rbx,%rdx,4), %esi
leal (%rcx,%rdi), %r8d
shlq $0x20, %r8
testq %rdi, %rdi
js 0x6064
movl (%r14,%rdi,4), %r9d
cmpl %esi, %r9d
jle 0x6062
movq %r8, %r10
sarq $0x1e, %r10
movl %r9d, (%r14,%r10)
decq %rdi
addq %r12, %r8
jmp 0x6041
movl %edi, %eax
addl %eax, %ecx
movslq %ecx, %rcx
movl %esi, (%r14,%rcx,4)
movq %rdx, %rcx
jmp 0x6021
movq -0x40(%rbp), %rsp
movq -0x48(%rbp), %rax
addl %eax, %r11d
movl -0x2c(%rbp), %ebx
jmp 0x5fa4
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/algo.cpp
// Function: QuickBlockInsertionSort<int>::_sort(int*, int, int)
void _sort(T arr[], int low, int high)
    {
        int size = (high - low) + 1;
        if (size <= minSize)
        {
            is.sort(arr + low, size);
            return;
        }
        int pi = partition(arr, low, high);
        _sort(arr, low, pi - 1);
        _sort(arr, pi + 1, high);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl %ebp, %edx
subl %r15d, %edx
cmpl 0x8(%r14), %edx
jl 0x6102
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x6120
movl %eax, %r12d
leal -0x1(%r12), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x60b6
incl %r12d
movl %r12d, %r15d
jmp 0x60c9
incl %edx
addq $0x10, %r14
movslq %r15d, %rax
leaq (%rbx,%rax,4), %rsi
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5f22
nop
// File: /workspace/github_cpp_makefile_star2_O2/ostafen[P]Fast-Insertion-Sort/src/util.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>* arrayCopy<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int)
T *arrayCopy(T *A, int n)
{
    T *B = new T[n];
    for (int i = 0; i < n; i++)
        B[i] = A[i];
    return B;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r12
movq %r12, %r15
shlq $0x5, %r15
leaq 0x8(%r15), %rax
testl %r12d, %r12d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x3030
movq %rax, %r14
movq %r12, (%rax)
testl %r12d, %r12d
je 0x63a4
leaq 0x18(%r14), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r15
jne 0x638e
addq $0x8, %r14
xorl %r12d, %r12d
testl %ebp, %ebp
cmovgl %ebp, %r12d
movq %r14, %r15
subq $0x1, %r12
jb 0x63cf
movq %r15, %rdi
movq %rbx, %rsi
callq 0x30f0
addq $0x20, %r15
addq $0x20, %rbx
jmp 0x63b4
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop