LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::loadDictionary(char*)
void HashTable::loadDictionary(char *path){
string line;
  
  ifstream myfile(path);
  if (myfile.is_open())
  {
    while ( myfile>>line )
    {
    
    	int n = line.length() + 1;
		char *char_array = new char[n];	
    	strcpy(char_array, line.c_str()); 
    	this->guarda(char_array);
    }
    myfile.close();
  }
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x250(%rbp), %rdi
movl $0x8, %edx
callq 0x2200
leaq -0x1d8(%rbp), %rdi
callq 0x2060
testb %al, %al
je 0x28a0
leaq -0x250(%rbp), %r14
leaq -0x48(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2894
movl -0x40(%rbp), %eax
incl %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %r12
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x2120
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2908
jmp 0x2852
leaq -0x250(%rbp), %rdi
callq 0x2050
leaq -0x250(%rbp), %rdi
callq 0x2070
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x28c1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2150
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28dc
movq %rax, %rbx
jmp 0x28eb
jmp 0x28dc
movq %rax, %rbx
leaq -0x250(%rbp), %rdi
callq 0x2070
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2900
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::print()
void HashTable::print(){
	
	for(int i = 0; i < MAX ; i++){
		LinkedList &l = this->table[i];
		std::cout << "Index "<< i << std::endl; 
		l.print();
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x35c5(%rip), %r15      # 0x5fd8
leaq 0x15ee(%rip), %r12      # 0x4008
movl $0x6, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
movq %r15, %rdi
movl %r14d, %esi
callq 0x21d0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2418
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r14
addq $0x18, %rbx
cmpq $0x14, %r14
jne 0x2a1a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Rekran[P]HahTable-Chaining-/main.cpp
// Function: main
int main(int argc, char** argv) {
vector<string>erros;
HashTable ht = HashTable();

ht.loadDictionary("dictionary.txt");

string word;
  ifstream myfile("text.txt");
  if (myfile.is_open())
  {
    while ( myfile>>word )
    {
    	if(!ht.search(&word[0]))
			erros.push_back(word);
    }
    myfile.close();
  }
for(int i = 0; i< erros.size();i++)
	cout<<erros[i]<<endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x448(%rbp), %rdi
callq 0x26b4
leaq 0x1529(%rip), %rsi      # 0x400f
leaq -0x448(%rbp), %rdi
callq 0x27fa
leaq -0x50(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x1510(%rip), %rsi      # 0x401e
leaq -0x268(%rbp), %rdi
movl $0x8, %edx
callq 0x2200
leaq -0x1f0(%rbp), %rdi
callq 0x2060
testb %al, %al
je 0x2b87
leaq -0x268(%rbp), %rbx
leaq -0x60(%rbp), %r14
leaq -0x448(%rbp), %r15
leaq -0x40(%rbp), %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2170
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2b7b
movq -0x60(%rbp), %rsi
movq %r15, %rdi
callq 0x2708
testb %al, %al
jne 0x2b45
movq %r12, %rdi
movq %r14, %rsi
callq 0x2c96
jmp 0x2b45
leaq -0x268(%rbp), %rdi
callq 0x2050
movq -0x40(%rbp), %rax
cmpq %rax, -0x38(%rbp)
je 0x2bf7
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x3437(%rip), %rbx      # 0x5fd8
movq -0x8(%rax,%r15), %rsi
movq (%rax,%r15), %rdx
movq %rbx, %rdi
callq 0x2160
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20d0
incq %r12
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r15
cmpq %r12, %rcx
ja 0x2ba1
leaq -0x268(%rbp), %rdi
callq 0x2070
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x2c18
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2150
leaq -0x448(%rbp), %rdi
callq 0x2974
leaq -0x40(%rbp), %rdi
callq 0x2ce2
xorl %eax, %eax
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c54
movq %rax, %rbx
jmp 0x2c63
movq %rax, %rbx
jmp 0x2c78
movq %rax, %rbx
jmp 0x2c84
jmp 0x2c54
movq %rax, %rbx
leaq -0x268(%rbp), %rdi
callq 0x2070
movq -0x60(%rbp), %rdi
cmpq %r13, %rdi
je 0x2c78
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2150
leaq -0x448(%rbp), %rdi
callq 0x2974
leaq -0x40(%rbp), %rdi
callq 0x2ce2
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: fill_random(std::vector<unsigned long, std::allocator<unsigned long>>&, unsigned long)
void fill_random(std::vector<std::size_t>& vec, std::size_t size){
    std::mt19937 generator;
    std::uniform_int_distribution<std::size_t> distribution(0, MAX);

    for(std::size_t i = 0; i < size; ++i){
        vec.push_back(distribution(generator));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x13a0, %rsp           # imm = 0x13A0
movl $0x1, %eax
movl $0x1571, %ecx           # imm = 0x1571
movq %rsi, %rbx
movq %rdi, %r14
movq $0x1571, 0x18(%rsp)     # imm = 0x1571
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
movq %rcx, 0x18(%rsp,%rax,8)
incq %rax
cmpq $0x270, %rax            # imm = 0x270
jne 0x12a5
movq $0x0, 0x8(%rsp)
movq $0x270, 0x1398(%rsp) # imm = 0x270
movq $0x2faf080, 0x10(%rsp)  # imm = 0x2FAF080
testq %rbx, %rbx
je 0x132f
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1a70
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x131f
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r14)
jmp 0x132a
movq %r14, %rdi
movq %r13, %rdx
callq 0x1d40
decq %rbx
jne 0x12f6
addq $0x13a0, %rsp           # imm = 0x13A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: in_place_counting_sort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void in_place_counting_sort(std::vector<std::size_t>& A){
    std::vector<std::size_t> C(MAX + 1);

    for (std::size_t i = 0; i < SIZE; ++i){
        ++C[A[i]];
    }

    int current = 0;
    for (std::size_t i = 0; i < MAX; ++i){
        for(std::size_t j =0; j < C[i]; ++j){
            A[current++] = i;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x17d78408, %edi       # imm = 0x17D78408
callq 0x10f0
movl $0x17d78408, %edx       # imm = 0x17D78408
movq %rax, %rbx
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq (%r14), %rax
movq (%rax,%r15,8), %rcx
incq %r15
incq (%rbx,%rcx,8)
cmpq $0x4c4b40, %r15         # imm = 0x4C4B40
jne 0x147d
xorl %ecx, %ecx
xorl %edx, %edx
movq (%rbx,%rcx,8), %rsi
testq %rsi, %rsi
je 0x14b5
movslq %edx, %rdi
leaq (%rax,%rdi,8), %r8
xorl %edi, %edi
movq %rcx, (%r8,%rdi,8)
incq %rdi
cmpq %rsi, %rdi
jb 0x14a7
addl %edi, %edx
incq %rcx
cmpq $0x2faf080, %rcx        # imm = 0x2FAF080
jne 0x1495
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10c0
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: counting_sort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void counting_sort(std::vector<std::size_t>& A){
    std::vector<std::size_t> B(SIZE);
    std::vector<std::size_t> C(MAX);

    for (std::size_t i = 0; i < SIZE; ++i){
        ++C[A[i]];
    }

    for (std::size_t i = 1; i <= MAX; ++i){
        C[i] += C[i - 1];
    }

    for (long i = SIZE - 1; i >= 0; --i) {
        B[C[A[i]] - 1] = A[i];
        --C[A[i]];
    }

    for (std::size_t i = 0; i < SIZE; ++i){
        A[i] = B[i];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl $0x2625a00, %edi        # imm = 0x2625A00
callq 0x10f0
movl $0x2625a00, %edx        # imm = 0x2625A00
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movl $0x17d78400, %edi       # imm = 0x17D78400
callq 0x10f0
movl $0x17d78400, %edx       # imm = 0x17D78400
movq %rax, %r14
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq (%r15), %rax
movq (%rax,%r12,8), %rcx
incq %r12
incq (%r14,%rcx,8)
cmpq $0x4c4b40, %r12         # imm = 0x4C4B40
jne 0x1517
movq (%r14), %rcx
movl $0x1, %edx
addq (%r14,%rdx,8), %rcx
movq %rcx, (%r14,%rdx,8)
incq %rdx
cmpq $0x2faf081, %rdx        # imm = 0x2FAF081
jne 0x1533
movl $0x4c4b3f, %ecx         # imm = 0x4C4B3F
movq (%rax,%rcx,8), %rdx
movq (%r14,%rdx,8), %rsi
movq %rdx, -0x8(%rbx,%rsi,8)
decq %rsi
addq $-0x1, %rcx
movq %rsi, (%r14,%rdx,8)
jb 0x154c
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
cmpq $0x4c4b40, %rcx         # imm = 0x4C4B40
jne 0x1568
movq %r14, %rdi
callq 0x10c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10c0
movq %rbx, %rdi
movq %rax, %r14
callq 0x10c0
movq %r14, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: binsort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void binsort(std::vector<std::size_t>& A){
    std::vector<std::vector<std::size_t>> B(MAX + 1);

    for(std::size_t i = 0; i < SIZE; ++i){
        B[A[i]].push_back(A[i]);
    }

    std::size_t current = 0;
    for(std::size_t i = 0; i < MAX; ++i){
        for(auto item : B[i]){
            A[current++] = item;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x47868c18, %edi       # imm = 0x47868C18
callq 0x10f0
leaq 0x47868c18(%rax), %r15
movl $0x47868c18, %edx       # imm = 0x47868C18
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
movq %r15, 0x18(%rsp)
callq 0x1070
movq %r15, 0x10(%rsp)
movq (%rbx), %rdx
movq 0x8(%rsp), %rcx
movq (%rdx,%r14), %rax
leaq (%rax,%rax,2), %rsi
leaq (%rcx,%rsi,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1613
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x161b
addq %r14, %rdx
callq 0x21bc
addq $0x8, %r14
cmpq $0x2625a00, %r14        # imm = 0x2625A00
jne 0x15e8
movq 0x8(%rsp), %rax
movq (%rbx), %rcx
xorl %edx, %edx
xorl %esi, %esi
leaq (%rdx,%rdx,2), %r8
movq (%rax,%r8,8), %rdi
movq 0x8(%rax,%r8,8), %r8
cmpq %r8, %rdi
je 0x1656
movq (%rdi), %r9
addq $0x8, %rdi
movq %r9, (%rcx,%rsi,8)
incq %rsi
jmp 0x1641
incq %rdx
cmpq $0x2faf080, %rdx        # imm = 0x2FAF080
jne 0x1634
leaq 0x8(%rsp), %rdi
callq 0x1906
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x1906
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: radix_sort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void radix_sort(std::vector<std::size_t>& A){
    std::vector<std::size_t> B(SIZE);
    std::vector<std::size_t> cnt(radix);

    for(std::size_t i = 0, shift = 0; i < digits; i++, shift += r){
        for(std::size_t j = 0; j < radix; ++j){
            cnt[j] = 0;
        }

        for(std::size_t j = 0; j < SIZE; ++j){
            ++cnt[(A[j] >> shift) & mask];
        }

        for(std::size_t j = 1; j < radix; ++j){
            cnt[j] += cnt[j - 1];
        }

        for(long j = SIZE - 1; j >= 0; --j){
            B[--cnt[(A[j] >> shift) & mask]] = A[j];
        }

        for(std::size_t j = 0; j < SIZE; ++j){
           A[j] = B[j];
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movl $0x2625a00, %edi        # imm = 0x2625A00
callq 0x10f0
movl $0x2625a00, %edx        # imm = 0x2625A00
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movl $0x80000, %edi          # imm = 0x80000
callq 0x10f0
movl $0x80000, %edx          # imm = 0x80000
movq %rax, %r14
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq (%r15), %r15
movb $0x1, %bpl
movl $0x80000, %edx          # imm = 0x80000
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
xorl %eax, %eax
shrxq %r12, (%r15,%rax,8), %rcx
incq %rax
movzwl %cx, %ecx
incq (%r14,%rcx,8)
cmpq $0x4c4b40, %rax         # imm = 0x4C4B40
jne 0x16e8
movq (%r14), %rax
movl $0x1, %ecx
addq (%r14,%rcx,8), %rax
movq %rax, (%r14,%rcx,8)
incq %rcx
cmpq $0x10000, %rcx          # imm = 0x10000
jne 0x1708
movl $0x4c4b3f, %eax         # imm = 0x4C4B3F
movq (%r15,%rax,8), %rcx
addq $-0x1, %rax
shrxq %r12, %rcx, %rdx
movzwl %dx, %edx
movq (%r14,%rdx,8), %rsi
leaq -0x1(%rsi), %rdi
movq %rcx, -0x8(%rbx,%rsi,8)
movq %rdi, (%r14,%rdx,8)
jb 0x1721
xorl %eax, %eax
movq (%rbx,%rax,8), %rcx
movq %rcx, (%r15,%rax,8)
incq %rax
cmpq $0x4c4b40, %rax         # imm = 0x4C4B40
jne 0x1746
addq $0x10, %r12
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x16d7
movq %r14, %rdi
callq 0x10c0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10c0
movq %rbx, %rdi
movq %rax, %r14
callq 0x10c0
movq %r14, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: main
int main(){
    std::cout << "std::sort" << std::endl;
    bench(&std_sort);

    std::cout << "counting_sort" << std::endl;
    bench(&counting_sort);

    std::cout << "in_place_counting_sort" << std::endl;
    bench(&in_place_counting_sort);

    std::cout << "binsort" << std::endl;
    bench(&::binsort);

    std::cout << "radix_sort" << std::endl;
    bench(&radix_sort);

    return 0;
}

// Assembly:
pushq %rbx
movq 0x3839(%rip), %rbx      # 0x4fd8
leaq 0x1913(%rip), %rsi      # 0x30b9
movl $0x9, %edx
movq %rbx, %rdi
callq 0x1100
movq (%rbx), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
leaq -0x3d8(%rip), %rdi      # 0x1409
callq 0x194b
leaq 0x18df(%rip), %rsi      # 0x30cc
movl $0xd, %edx
movq %rbx, %rdi
callq 0x1100
movq (%rbx), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
leaq -0x35a(%rip), %rdi      # 0x14ce
callq 0x194b
leaq 0x188f(%rip), %rsi      # 0x30c3
movl $0x16, %edx
movq %rbx, %rdi
callq 0x1100
movq (%rbx), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
leaq -0x41c(%rip), %rdi      # 0x1453
callq 0x194b
leaq 0x185f(%rip), %rsi      # 0x30da
movl $0x7, %edx
movq %rbx, %rdi
callq 0x1100
movq (%rbx), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
leaq -0x30c(%rip), %rdi      # 0x15aa
callq 0x194b
leaq 0x1820(%rip), %rsi      # 0x30e2
movl $0xa, %edx
movq %rbx, %rdi
callq 0x1100
movq (%rbx), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
leaq -0x272(%rip), %rdi      # 0x168b
callq 0x194b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: void bench<void (*)(std::vector<unsigned long, std::allocator<unsigned long>>&)>(void (*)(std::vector<unsigned long, std::allocator<unsigned long>>&))
void bench(Function sort_function){
    std::array<std::vector<std::size_t>, REPEAT> vec;

    for(std::size_t i = 0; i < REPEAT; ++i){
        fill_random(vec[i], SIZE);
    }

    Clock::time_point t0 = Clock::now();

    for(std::size_t i = 0; i < REPEAT; ++i){
        sort_function(vec[i]);
    }

    Clock::time_point t1 = Clock::now();
    milliseconds ms = std::chrono::duration_cast<milliseconds>(t1 - t0);

    std::cout << ms.count() << "ms" << std::endl;

    if(DISPLAY){
        display_vec(vec[0]);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x260, %rsp            # imm = 0x260
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x258, %edx            # imm = 0x258
xorl %esi, %esi
xorl %r14d, %r14d
callq 0x1070
leaq 0x8(%rsp,%r14), %rdi
movl $0x4c4b40, %esi         # imm = 0x4C4B40
callq 0x127c
addq $0x18, %r14
cmpq $0x258, %r14            # imm = 0x258
jne 0x196e
xorl %r15d, %r15d
callq 0x1040
movq %rax, %r14
leaq 0x8(%rsp,%r15), %rdi
callq *%rbx
addq $0x18, %r15
cmpq $0x258, %r15            # imm = 0x258
jne 0x1995
callq 0x1040
subq %r14, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
sarq $0x12, %rdx
shrq $0x3f, %rsi
addq %rdx, %rsi
movq 0x3605(%rip), %rdi      # 0x4fd8
callq 0x10d0
leaq 0x1728(%rip), %rsi      # 0x3107
movl $0x2, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x1100
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movl $0x240, %ebx            # imm = 0x240
movq 0x8(%rsp,%rbx), %rdi
testq %rdi, %rdi
je 0x1a2a
callq 0x10c0
addq $-0x18, %rbx
cmpq $-0x18, %rbx
jne 0x1a1b
addq $0x260, %rsp            # imm = 0x260
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1a45
jmp 0x1a45
movl $0x240, %r14d           # imm = 0x240
movq %rax, %rbx
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x1a5d
callq 0x10c0
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x1a4e
movq %rbx, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_srv.c
// Function: cmd_handler
scdcint_t cmd_handler(void *data, const char *cmd, const char *params, scdcint_t params_size)
{
  printf(PREFIX "cmd_handler: cmd: '%s', data: %p\n", cmd, data);

  if (strcmp(cmd, "quit") == 0)
  {
    printf(PREFIX "quiting server\n");
    sighandler(0);

  } else
  {
    printf(PREFIX "unkown server command: '%s'\n", cmd);
  }

  return SCDC_SUCCESS;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rdx
leaq 0x4eb81(%rip), %rdi     # 0x5b023
xorl %eax, %eax
callq 0xb080
leaq 0x4eb9f(%rip), %rsi     # 0x5b04f
movq %rbx, %rdi
callq 0xb770
testl %eax, %eax
je 0xc4cf
leaq 0x4eb91(%rip), %rdi     # 0x5b054
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb080
jmp 0xc4f9
leaq 0x4ebde(%rip), %rdi     # 0x5b0b4
callq 0xb860
leaq 0x4eb22(%rip), %rdi     # 0x5b004
xorl %esi, %esi
xorl %eax, %eax
callq 0xb080
movq 0x6c0a6(%rip), %rdi     # 0x78598
xorl %esi, %esi
callq 0xd46e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc4.cc
// Function: Interpreter::expression()
long Interpreter::expression() {
    long result = factor();

    while (_current_token.type == TOKENTYPE::MUL ||
    _current_token.type == TOKENTYPE::DIV ||
    _current_token.type == TOKENTYPE::PLUS ||
    _current_token.type == TOKENTYPE::MINUS) {
        Token token = _current_token;
        if (token.type == TOKENTYPE::MUL) {
            eat(TOKENTYPE::MUL);
            result *= factor();
        } else if (token.type == TOKENTYPE::DIV) {
            eat(TOKENTYPE::DIV);
            long rhs = factor();
            if (rhs == 0) {
                throw("Division by zero");
            }
            result /= rhs;
        } else if (token.type == TOKENTYPE::PLUS) {
            eat(TOKENTYPE::PLUS);
            result += factor();
        } else if (token.type == TOKENTYPE::MINUS) {
            eat(TOKENTYPE::MINUS);
            result -= factor();
        }
    }

    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10(%rdi), %rbx
movl $0x1, %esi
callq 0x29c6
movl 0x8(%r14), %eax
leal -0x2(%rax), %ecx
cmpl $0x3, %ecx
ja 0x297d
leaq 0x734(%rip), %r15       # 0x3020
addl $-0x2, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq %r14, %rdi
movl $0x2, %esi
callq 0x29c6
addq 0x10(%r14), %rbx
jmp 0x2960
movq %r14, %rdi
movl $0x4, %esi
callq 0x29c6
imulq 0x10(%r14), %rbx
jmp 0x2960
movq %r14, %rdi
movl $0x5, %esi
callq 0x29c6
movq 0x10(%r14), %r12
movq %r14, %rdi
movl $0x1, %esi
callq 0x29c6
testq %r12, %r12
je 0x298c
movq %rbx, %rax
cqto
idivq %r12
movq %rax, %rbx
jmp 0x296d
movq %r14, %rdi
movl $0x3, %esi
callq 0x29c6
subq 0x10(%r14), %rbx
movq %r14, %rdi
movl $0x1, %esi
callq 0x29c6
movl 0x8(%r14), %eax
leal -0x2(%rax), %ecx
cmpl $0x4, %ecx
jb 0x28ec
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x2090
leaq 0x726(%rip), %rcx       # 0x30c3
movq %rcx, (%rax)
movq 0x2609(%rip), %rsi      # 0x4fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/m1c0l[P]TCP/server.cpp
// Function: printSend(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short, int, int, bool)
void printSend(string pktType, uint16_t seq, int cwnd, int ssThresh, bool isRetransmit) {
	cout << "Sending packet " << seq << " " << cwnd << " " << ssThresh;
	if (isRetransmit) {
		cout << " Retransmission";
	}
	if (pktType != "data") {
		// SYN or FIN
		cout << " " << pktType;
	}
	cout << '\n';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x537b(%rip), %r13      # 0x7fd0
leaq 0x241e(%rip), %rsi      # 0x507a
movl $0xf, %edx
movq %r13, %rdi
callq 0x21f0
movl %r12d, %esi
movq %r13, %rdi
callq 0x2120
movq %rax, %r12
leaq 0x2427(%rip), %r13      # 0x50a5
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21f0
movq %r12, %rdi
movl %r15d, %esi
callq 0x22c0
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21f0
movq %r15, %rdi
movl %r14d, %esi
callq 0x22c0
testl %ebp, %ebp
je 0x2cd3
movq 0x530e(%rip), %rdi      # 0x7fd0
leaq 0x23c1(%rip), %rsi      # 0x508a
movl $0xf, %edx
callq 0x21f0
leaq 0x23c0(%rip), %rsi      # 0x509a
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x2d10
movq 0x52e3(%rip), %r14      # 0x7fd0
leaq 0x23b1(%rip), %rsi      # 0x50a5
movl $0x1, %edx
movq %r14, %rdi
callq 0x21f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x21f0
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x52b1(%rip), %rdi      # 0x7fd0
movl $0x1, %edx
callq 0x21f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day03/ex04/SuperTrap.cpp
// Function: SuperTrap::SuperTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
SuperTrap::SuperTrap(std::string name) : ClapTrap(name), NinjaTrap(name), FragTrap(name)
{
	this->hitPoints = FragTrap::hitPoints;
	this->maxHit = FragTrap::maxHit;
	this->energyPoints = NinjaTrap::energyPoints;
	this->maxEnergyPoints = NinjaTrap::maxEnergyPoints;
	this->level = 1.0;
	this->meleeAttackDamage = NinjaTrap::meleeAttackDamage;
	this->rangedAttackDamage = FragTrap::rangedAttackDamage;
	this->armorDamageReduction = FragTrap::armorDamageReduction;
	std::cout << this->name << ": I'm a SuperTrap!" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x2940
movq %rbx, %rdi
movq %r12, %rsi
callq 0x239c
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x42fb
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x2940
leaq 0x3933(%rip), %rsi      # 0x7c50
leaq -0x68(%rbp), %rdx
movq %r14, %rdi
callq 0x31c0
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x433e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2940
leaq 0x8(%r14), %r15
leaq 0x38fc(%rip), %rsi      # 0x7c60
leaq -0x48(%rbp), %rdx
movq %r15, %rdi
callq 0x29e0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4385
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2100
leaq 0x381c(%rip), %rax      # 0x7ba8
movq %rax, (%r14)
leaq 0x3892(%rip), %rax      # 0x7c28
movq %rax, 0x10(%r14)
leaq 0x383f(%rip), %rax      # 0x7be0
movq %rax, 0x8(%r14)
movl $0x3f800000, 0x28(%r14) # imm = 0x3F800000
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq 0x3c1c(%rip), %rdi      # 0x7fd8
callq 0x2110
movq %rax, %r12
leaq 0x110d(%rip), %rsi      # 0x54d8
movl $0x12, %edx
movq %rax, %rdi
callq 0x2110
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x447c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x447c
movq %rax, %r12
jmp 0x447c
movq %rax, %r12
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x448b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x448b
movq %rax, %r12
jmp 0x448b
movq %rax, %r12
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x4493
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x4493
movq %rax, %r12
leaq 0x37ec(%rip), %rsi      # 0x7c60
movq %r15, %rdi
callq 0x2d48
leaq 0x37cd(%rip), %rsi      # 0x7c50
movq %r14, %rdi
callq 0x3538
movq %rbx, %rdi
callq 0x25b8
movq %r12, %rdi
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day03/ex04/main.cpp
// Function: main
int main(void)
{
	SuperTrap	alpha("Alpha");
	ScavTrap	lucie("Lucie");

	srand(time(0));
	alpha.meleeAttack("John");
	alpha.rangedAttack("Rose");
	alpha.vaulthunter_dot_exe("Micheal");
	alpha.ninjaShoebox(lucie);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xa59(%rip), %rsi       # 0x550e
leaq 0xa57(%rip), %rdx       # 0x5513
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x4cba
leaq -0xd0(%rbp), %rdi
movq %rbx, %rsi
callq 0x429c
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x4aec
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xa19(%rip), %rsi       # 0x5514
leaq 0xa17(%rip), %rdx       # 0x5519
leaq -0x50(%rbp), %rdi
callq 0x4cba
leaq -0x120(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3bb8
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x4b30
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2100
xorl %edi, %edi
callq 0x20d0
movl %eax, %edi
callq 0x20e0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x9cd(%rip), %rsi       # 0x551a
leaq 0x9ca(%rip), %rdx       # 0x551e
leaq -0x30(%rbp), %rdi
callq 0x4cba
leaq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4a6c
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4b82
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x98f(%rip), %rsi       # 0x551f
leaq 0x98c(%rip), %rdx       # 0x5523
callq 0x4cba
leaq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4a3c
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4bc1
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x955(%rip), %rsi       # 0x5524
leaq 0x955(%rip), %rdx       # 0x552b
callq 0x4cba
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e68
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c00
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2100
leaq -0xd0(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x3740
leaq -0x120(%rbp), %rdi
callq 0x3db0
leaq -0xd0(%rbp), %rdi
callq 0x4964
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4c5d
jmp 0x4c43
jmp 0x4c5d
jmp 0x4c43
jmp 0x4c5d
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c60
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x4c60
movq %rax, %rbx
leaq -0x120(%rbp), %rdi
callq 0x3db0
leaq -0xd0(%rbp), %rdi
callq 0x4964
movq %rbx, %rdi
callq 0x2150
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c6c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x4c6c
movq %rax, %rbx
jmp 0x4c6c
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c78
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x4c78
nop
// File: /workspace/github_cpp_makefile_star2_O3/nightmeng[P]net/examples/http/httptest.cpp
// Function: handle_read(int, int, socket&)
void handle_read(int ec, int transfered, socket &sock){
	std::cout << buff << std::endl;
	bzero(buff, 2048);
	sock.async_read(buff, 2048, std::bind(handle_read, std::placeholders::_1,
				std::placeholders::_2, std::ref(sock)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
leaq 0x9c8d(%rip), %r14      # 0xd1f0
movq %r14, %rdi
callq 0x30e0
movq 0x9a5e(%rip), %r15      # 0xcfd0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x3220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3150
movl $0x800, %esi            # imm = 0x800
movq %r14, %rdi
callq 0x3300
leaq -0x38(%rbp), %r15
movq $0x0, 0x8(%r15)
movl $0x10, %edi
callq 0x3200
leaq -0x85(%rip), %rcx       # 0x354c
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, (%r15)
leaq 0x38a(%rip), %rax       # 0x396c
movq %rax, 0x18(%r15)
leaq 0x397(%rip), %rax       # 0x3984
movq %rax, 0x10(%r15)
movl $0x800, %edx            # imm = 0x800
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x5110
movq -0x28(%rbp), %rax
testq %rax, %rax
je 0x361b
leaq -0x38(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x364a
movq %rax, %rbx
movq -0x28(%rbp), %rax
testq %rax, %rax
je 0x3642
leaq -0x38(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x3310
movq %rax, %rdi
callq 0x395d
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]cxx-invert-file-tree/generator.cpp
// Function: main
int main(int argc, char **argv)
{
    if (argc < 2) {
        usage(std::cerr);
        std::cerr << "ERROR: folder path is not provided" << std::endl;
        return 1;
    }

    srand(time(nullptr));

    fs::path folder_path(argv[1]);
    fs::create_directory(folder_path);
    std::cout << "Created Folder: " << folder_path << std::endl;
    generate_tree(folder_path);

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %edi
jg 0x3844
movq 0x37f9(%rip), %rbx      # 0x6ff0
movq %rbx, %rdi
callq 0x325c
leaq 0x1841(%rip), %rsi      # 0x5047
movl $0x22, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movl $0x1, %ebx
jmp 0x38d9
movq %rsi, %rbx
xorl %edi, %edi
callq 0x2180
movl %eax, %edi
callq 0x2190
addq $0x8, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq 0x3a92
movq %r14, %rdi
callq 0x20d0
movq 0x3755(%rip), %rdi      # 0x6fd0
leaq 0x17a5(%rip), %rsi      # 0x5027
movl $0x10, %edx
callq 0x21f0
movq 0x373d(%rip), %rdi      # 0x6fd0
movq %rsp, %rsi
callq 0x3a0a
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %ebx, %ebx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x32b7
movq %rsp, %rdi
callq 0x39d2
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x39d2
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/engine.cpp
// Function: Engine::set_times(int, int)
void Engine::set_times(int time_left, int stones)
{
  max_playouts = INFINITE;
  if (stones) max_time = (0.9*time_left/stones)*CLOCKS_PER_SEC;
  else max_time = (0.9*time_left + byo_time)*CLOCKS_PER_SEC;
  std::cerr << max_time << "\n";
}

// Assembly:
movl $0x7fffffff, 0x14(%rdi) # imm = 0x7FFFFFFF
cvtsi2sd %esi, %xmm0
testl %edx, %edx
je 0x37a3
mulsd 0x786f(%rip), %xmm0     # 0xb008
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
jmp 0x37b8
cvtsi2sdq 0x610(%rdi), %xmm1
mulsd 0x7854(%rip), %xmm0     # 0xb008
addsd %xmm1, %xmm0
pushq %rax
mulsd 0x784f(%rip), %xmm0     # 0xb010
cvttsd2si %xmm0, %rsi
movq %rsi, 0x608(%rdi)
movq 0xc81c(%rip), %rdi      # 0xfff0
callq 0x31a0
leaq 0x7ea4(%rip), %rsi      # 0xb684
movl $0x1, %edx
movq %rax, %rdi
popq %rax
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/engine.cpp
// Function: Engine::play_random_game(bool)
int Engine::play_random_game(bool heavy)
{
  int pass = 0;
  main_goban->shuffle_empty();
  while (pass < 2) {
    int move = heavy ? main_goban->play_heavy() : main_goban->play_random();
    amaf.play(move, ++simul_len);
    rand_movs++;
    if (move == Goban::PASS) pass++;
    else pass = 0;
#ifdef DEBUG_INFO
      main_goban->print_goban();
#endif
    int mercy = main_goban->mercy();    
    if (mercy != -1) {
      return 1-mercy;
    }
//#ifdef DEBUG_INFO
    if (simul_len > 2*main_goban->get_size2()) {
      std::cerr << "WARNING: Simulation exceeded max length.\n";
      discarded++;
      return -1;
    }
//#endif
  }
    return (main_goban->chinese_count() > 0) ? 1:0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0xfc120, %edi          # imm = 0xFC120
addq 0x8(%rbx), %rdi
callq 0x3ed4
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
cmpl $0x1, %r12d
jg 0x38a9
testb %bpl, %bpl
je 0x3829
callq 0x83d6
jmp 0x382e
callq 0x83b2
movl %eax, %r14d
movl 0x1c(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1c(%rbx)
movslq %r14d, %rsi
cmpl $0x0, 0x50(%rbx,%rsi,4)
movb 0x5fc(%rbx), %dl
jne 0x3855
notl %eax
testb %dl, %dl
cmovnel %eax, %ecx
movl %ecx, 0x50(%rbx,%rsi,4)
xorb $0x1, %dl
movb %dl, 0x5fc(%rbx)
incl 0x18(%rbx)
movq 0x8(%rbx), %rdi
callq 0x5992
cmpl $-0x1, %eax
jne 0x38bb
incl %r12d
testl %r14d, %r14d
cmovnel %r15d, %r12d
movq 0x8(%rbx), %rax
movl 0xc(%rax), %eax
addl %eax, %eax
cmpl %eax, 0x1c(%rbx)
jle 0x380f
movq 0xc762(%rip), %rdi      # 0xfff0
leaq 0x779f(%rip), %rsi      # 0xb034
movl $0x29, %edx
callq 0x31f0
incl 0x20(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x38c4
callq 0x5860
xorps %xmm1, %xmm1
xorl %eax, %eax
ucomiss %xmm1, %xmm0
seta %al
jmp 0x38c4
movl %eax, %ecx
movl $0x1, %eax
subl %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/engine.cpp
// Function: Engine::back_up_results(int, Node**, int, bool)
void Engine::back_up_results(int result, Node *node_history[], int nnodes, bool side)
{
  for (int i = 0; i < nnodes; i++) {
    node_history[i]->set_results(1-result); //Because root node belongs to opponent.
    node_history[i]->set_amaf(result, amaf, side, i+1);
    side = !side;
    result = 1-result;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testl %ecx, %ecx
jle 0x3bbf
movl %r8d, %ebx
movq %rdx, %r14
movl %esi, %ebp
addq $0x50, (%rsp)
movl %ecx, %r15d
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
movl $0x1, %r13d
subl %ebp, %r13d
movl %r13d, %esi
callq 0x9b24
movq (%r14,%r12,8), %rdi
incq %r12
movzbl %bl, %ebx
movl %ebx, %ecx
andl $0x1, %ecx
movl %ebp, %esi
movq (%rsp), %rdx
movl %r12d, %r8d
callq 0x9b44
xorb $0x1, %bl
movl %r13d, %ebp
cmpq %r12, %r15
jne 0x3b82
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/engine.cpp
// Function: Engine::print_PV() const
void Engine::print_PV() const
{
  fin_clock = clock() - fin_clock;
  tree.print();
  int nplayouts = tree.get_root()->get_visits();
  std::cerr << "#Playouts: " << nplayouts
            << ", average length: " << rand_movs/nplayouts
            << ", discarded: " << discarded << ", playouts/sec: "
            << (float)nplayouts/fin_clock*CLOCKS_PER_SEC << "\n";
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3100
subq 0x600(%rbx), %rax
movq %rax, 0x600(%rbx)
leaq 0x28(%rbx), %rdi
callq 0xa622
movslq 0x44(%rbx), %rax
movq 0x28(%rbx,%rax,8), %rax
movsd 0x8(%rax), %xmm0
movapd %xmm0, (%rsp)
cvttsd2si %xmm0, %ebp
movq 0xc3dd(%rip), %r14      # 0xfff0
leaq 0x7444(%rip), %rsi      # 0xb05e
movl $0xb, %edx
movq %r14, %rdi
callq 0x31f0
movq %r14, %rdi
movl %ebp, %esi
callq 0x32f0
movq %rax, %r14
leaq 0x742f(%rip), %rsi      # 0xb06a
movl $0x12, %edx
movq %rax, %rdi
callq 0x31f0
movl 0x18(%rbx), %eax
cltd
idivl %ebp
movq %r14, %rdi
movl %eax, %esi
callq 0x32f0
movq %rax, %r14
leaq 0x741b(%rip), %rsi      # 0xb07d
movl $0xd, %edx
movq %rax, %rdi
callq 0x31f0
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x32f0
movq %rax, %r14
leaq 0x7407(%rip), %rsi      # 0xb08b
movl $0x10, %edx
movq %rax, %rdi
callq 0x31f0
cvttpd2dq (%rsp), %xmm0
cvtdq2ps %xmm0, %xmm0
cvtsi2ssq 0x600(%rbx), %xmm1
divss %xmm1, %xmm0
mulss 0x7382(%rip), %xmm0     # 0xb030
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
callq 0x32a0
leaq 0x79c3(%rip), %rsi      # 0xb684
movl $0x1, %edx
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x31f0
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/engine.cpp
// Function: Engine::score(std::vector<int, std::allocator<int>>*)
float Engine::score(std::vector<int> *dead)
{
  const int PLAYOUTS = 5000;
  int score = 0;
  int score_table[MAXSIZE2+1] = {0};
  for (int i = 0; i < PLAYOUTS; i++) {
    simul_len = 0;
    play_random_game(LIGHT);
    main_goban->score_area(score_table);
    main_goban->restore();
  }
  for (int i = 1; i <= main_goban->get_size2(); i++) {
    if (score_table[i] > PLAYOUTS/2) score_table[i] = 1;
    else if (score_table[i] < -PLAYOUTS/2) score_table[i] = -1;
    else score_table[i] = 0;
    
    if (dead && main_goban->get_value(i)
        && score_table[i] !=  main_goban->get_value(i)) {
      dead->insert(dead->end(), i);
    }
  }

  for (int i = 1; i <= main_goban->get_size2(); i++) {
    score += score_table[i];
  }
  return score - main_goban->get_komi();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x5c0, %rsp            # imm = 0x5C0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movl $0x5a8, %edx            # imm = 0x5A8
movq %r15, %rdi
xorl %esi, %esi
callq 0x30e0
movl $0x1388, %ebp           # imm = 0x1388
movl $0x0, 0x1c(%r14)
movzbl 0x1(%r14), %esi
movq %r14, %rdi
callq 0x37ee
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x5902
movq 0x8(%r14), %rdi
callq 0x490e
decl %ebp
jne 0x3d04
movl $0x1, 0xc(%rsp)
movq 0x8(%r14), %rdi
cmpl $0x0, 0xc(%rdi)
jle 0x3de3
movl $0x1, %ebp
leaq 0xc(%rsp), %r15
movl $0x1, %esi
movslq %esi, %rax
movl 0x10(%rsp,%rax,4), %ecx
xorl %edx, %edx
cmpl $0xfffff63c, %ecx       # imm = 0xFFFFF63C
setl %dl
negl %edx
cmpl $0x9c5, %ecx            # imm = 0x9C5
cmovgel %ebp, %edx
movl %edx, 0x10(%rsp,%rax,4)
testq %rbx, %rbx
je 0x3dad
callq 0x5846
testl %eax, %eax
je 0x3dad
movslq 0xc(%rsp), %rsi
movl 0x10(%rsp,%rsi,4), %r12d
movq 0x8(%r14), %rdi
callq 0x5846
cmpl %eax, %r12d
je 0x3dad
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3e5a
movl 0xc(%rsp), %ecx
leal 0x1(%rcx), %esi
movl %esi, 0xc(%rsp)
movq 0x8(%r14), %rdi
movl 0xc(%rdi), %eax
cmpl %eax, %ecx
jl 0x3d57
testl %eax, %eax
jle 0x3de3
incq %rax
xorl %ecx, %ecx
movl $0x1, %edx
addl 0x10(%rsp,%rdx,4), %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x3dd1
cvtsi2ss %ecx, %xmm0
jmp 0x3de6
xorps %xmm0, %xmm0
subss 0x10(%rdi), %xmm0
addq $0x5c0, %rsp            # imm = 0x5C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/engine.cpp
// Function: Engine::perft(int)
void Engine::perft(int max)
{
  for (int i = 0; i < max; i++) {
    simul_len = 0;
    play_random_game(LIGHT);
    std::cerr << "restoring\n";
    main_goban->restore();
  }
}

// Assembly:
testl %esi, %esi
jle 0x3e58
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0xc1dc(%rip), %r15      # 0xfff0
leaq 0x7281(%rip), %r12      # 0xb09c
movl $0x0, 0x1c(%r14)
movzbl 0x1(%r14), %esi
movq %r14, %rdi
callq 0x37ee
movl $0xa, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x31f0
movq 0x8(%r14), %rdi
callq 0x490e
decl %ebx
jne 0x3e1b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/goban.cpp
// Function: Goban::Goban(int)
Goban::Goban(int newsize)
{
  size = (newsize <= MAXSIZE) ? newsize : size;
  size2 = size*size;
  komi = 0.5;
  clear();
  init_adjacent();
  init_diagonals();
  init_vicinity();
  init_distance();
  init_manhattan();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0xb68, %r14d           # imm = 0xB68
leaq (%rbx,%r14), %rdi
callq 0x5d9c
addq $0x970, %r14            # imm = 0x970
cmpq $0xd63c8, %r14          # imm = 0xD63C8
jne 0x4097
leaq 0xbba9(%rip), %rax      # 0xfc60
movq %rax, 0xfc120(%rbx)
xorl %r14d, %r14d
movl %r14d, 0xfc6d0(%rbx)
movl %r14d, 0xfc128(%rbx)
leaq 0xbbd2(%rip), %rax      # 0xfca8
movq %rax, 0xfc6d8(%rbx)
movl %r14d, 0xfd7cc(%rbx)
movl %r14d, 0xfc6e0(%rbx)
leaq 0xfd7d0(%rbx), %rdi
callq 0xa8cc
cmpl $0x14, %ebp
jl 0x40ff
movl 0x8(%rbx), %ebp
movl %ebp, 0x8(%rbx)
imull %ebp, %ebp
movl %ebp, 0xc(%rbx)
movl $0x3f000000, 0x10(%rbx) # imm = 0x3F000000
movq %rbx, %rdi
callq 0x483c
movl %r14d, 0x14(%rbx)
movl %r14d, 0xfd7cc(%rbx)
movl %r14d, 0xfc6e0(%rbx)
movq %rbx, %rdi
callq 0x4172
movq %rbx, %rdi
callq 0x4210
movq %rbx, %rdi
callq 0x42c0
movq %rbx, %rdi
callq 0x43fe
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4680
nop
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_adjacent()
void Goban::init_adjacent()
{
  for (int k = 1; k <= size2; k++) {
    int nadj = 0;
    if (k <= size*(size-1)) {  //N
      adjacent[k][nadj++] =  k + size;
    }
    if (k % size) {  //E
      adjacent[k][nadj++] =  k + 1;
    }
    if (k > size) {  //S
      adjacent[k][nadj++] = k - size;
    }
    if (k % size != 1) {  //W
      adjacent[k][nadj++] = k -1;
    }
    adjacent[k][nadj] = 0;
  }
}

// Assembly:
movl 0xc(%rdi), %ecx
testl %ecx, %ecx
jle 0x420e
pushq %rbp
pushq %r14
pushq %rbx
movslq 0x8(%rdi), %rsi
movl %esi, %r8d
leal -0x1(%rsi), %eax
imull %esi, %eax
movslq %eax, %r9
movl $0x1, %r10d
subl %esi, %r10d
addq $0xd63fc, %rdi          # imm = 0xD63FC
xorl %r11d, %r11d
leaq 0x1(%r11), %rbx
movl $0x0, %ebp
cmpq %r9, %rbx
jg 0x41bf
leal (%r8,%r11), %eax
incl %eax
movl %eax, (%rdi)
movl $0x1, %ebp
leal 0x1(%r11), %eax
cltd
idivl %r8d
testl %edx, %edx
je 0x41d7
movl %ebp, %eax
incl %ebp
leal 0x2(%r11), %r14d
movl %r14d, (%rdi,%rax,4)
cmpq %rsi, %rbx
jle 0x41e8
movl %ebp, %eax
incl %ebp
leal (%r10,%r11), %r14d
movl %r14d, (%rdi,%rax,4)
cmpl $0x1, %edx
je 0x41f5
movl %ebp, %eax
incl %ebp
movl %r11d, (%rdi,%rax,4)
movl %ebp, %eax
movl $0x0, (%rdi,%rax,4)
addq $0x14, %rdi
movq %rbx, %r11
cmpq %rbx, %rcx
jne 0x41a4
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_diagonals()
void Goban::init_diagonals()
{

  for (int k = 1; k <= size2; k++) {
    int ndiag = 0;
    if (k <= size*(size-1) && k % size != 1) {  //NW
      diagonals[k][ndiag++] =  k + size - 1;
    }  
    if (k <= size*(size-1) && k % size) {  //NE
      diagonals[k][ndiag++] =  k + size + 1;
    }
    if (k > size && k % size) {  //SE
      diagonals[k][ndiag++] = k - size +1;
    }
    if (k > size && k % size != 1) {  //SW
      diagonals[k][ndiag++] = k - size -1;
    }
    diagonals[k][ndiag] = 0;
  }
}

// Assembly:
movl 0xc(%rdi), %esi
testl %esi, %esi
jle 0x42bf
pushq %r14
pushq %rbx
movslq 0x8(%rdi), %r8
movl %r8d, %r9d
leal -0x1(%r8), %eax
imull %r8d, %eax
movslq %eax, %r10
incq %rsi
movl %r8d, %r11d
negl %r11d
addq $0xd8044, %rdi          # imm = 0xD8044
movl $0x1, %ecx
xorl %ebx, %ebx
cmpq %r10, %rcx
jg 0x4277
movl %ecx, %eax
cltd
idivl %r9d
xorl %ebx, %ebx
cmpl $0x1, %edx
je 0x426a
leal (%r9,%rcx), %eax
decl %eax
movl %eax, (%rdi)
movl $0x1, %ebx
testl %edx, %edx
je 0x4277
leal (%r9,%rcx), %eax
incl %eax
movl %ebx, %edx
incl %ebx
movl %eax, (%rdi,%rdx,4)
cmpq %r8, %rcx
jle 0x42a7
movl %ecx, %eax
cltd
idivl %r9d
testl %edx, %edx
je 0x429a
leal (%r11,%rcx), %eax
incl %eax
movl %ebx, %r14d
incl %ebx
movl %eax, (%rdi,%r14,4)
cmpl $0x1, %edx
je 0x42a7
leal (%r11,%rcx), %eax
decl %eax
movl %ebx, %edx
incl %ebx
movl %eax, (%rdi,%rdx,4)
movl %ebx, %eax
movl $0x0, (%rdi,%rax,4)
incq %rcx
addq $0x14, %rdi
cmpq %rcx, %rsi
jne 0x4245
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/antoniogarro[P]Hara/goban.cpp
// Function: Goban::init_vicinity()
void Goban::init_vicinity()
{  
  for (int i = 0; i <= size2; i++) {
    for (int j = 0; j < 16; j++) {
      vicinity[i][j] = 0;
    }
  }
  //Duplicate to calculate rotations,avoiding run-time modulo division:
  for (int i = 0; i < 2; i++) {
    for (int k = 1; k <= size2; k++) {
      if (k <= size*(size-1)) {
        if (k % size != 1) {  //NW
          vicinity[k][0+8*i] =  k + size - 1;
        }
        vicinity[k][1+8*i] =  k + size;  //N
      }
      if (k % size ) {
        if (k <= size*(size-1)) {  //NE
          vicinity[k][2+8*i] =  k + size + 1;
        }
        vicinity[k][3+8*i] =  k + 1;  //E
      }
      if (k > size) {
        if (k % size) {  //SE
          vicinity[k][4+8*i] = k - size +1;
        }
        vicinity[k][5+8*i] = k - size;  //S
      }
      if (k % size != 1) {
        if (k > size) {  //SW
          vicinity[k][6+8*i] = k - size -1;
        }
        vicinity[k][7+8*i] = k - 1;  //W
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r14d
testl %r14d, %r14d
js 0x42f2
leaq 0xd9c78(%rbx), %rdi
leaq 0x1(%r14), %r15
movq %r15, %rdx
shlq $0x6, %rdx
xorl %esi, %esi
callq 0x30e0
jmp 0x42f6
leal 0x1(%r14), %r15d
movslq 0x8(%rbx), %rsi
movl %esi, %edi
leal -0x1(%rsi), %eax
imull %esi, %eax
movslq %eax, %r8
movl %r15d, %r9d
movl %esi, %r10d
negl %r10d
addq $0xd9cd4, %rbx          # imm = 0xD9CD4
decq %r9
movb $0x1, %r11b
xorl %eax, %eax
testl %r14d, %r14d
jle 0x43d9
leaq (%rbx,%rax,4), %r15
movl $0x1, %r12d
xorl %ecx, %ecx
movq %rcx, %r13
incq %rcx
movl %ecx, %eax
cltd
idivl %edi
cmpq %r8, %rcx
jle 0x434c
testl %edx, %edx
je 0x43af
leal 0x2(%r13), %eax
jmp 0x4383
cmpl $0x1, %edx
jne 0x435d
leal (%rdi,%r13), %eax
incl %eax
movl %eax, -0x18(%r15)
jmp 0x4373
leal (%rdi,%r13), %eax
movl %eax, -0x1c(%r15)
leal (%rdi,%r13), %eax
incl %eax
movl %eax, -0x18(%r15)
testl %edx, %edx
je 0x43af
leal 0x1(%r12), %eax
leal (%rdi,%r13), %ebp
addl $0x2, %ebp
movl %ebp, -0x14(%r15)
movl %eax, -0x10(%r15)
cmpq %rsi, %rcx
jle 0x43a8
leal (%r10,%r13), %eax
addl $0x2, %eax
movl %eax, -0xc(%r15)
leal (%r10,%r13), %eax
incl %eax
movl %eax, -0x8(%r15)
cmpl $0x1, %edx
jne 0x43be
jmp 0x43c9
cmpl $0x1, %edx
jne 0x43c6
jmp 0x43c9
cmpq %rsi, %rcx
jle 0x43c6
leal (%r10,%r13), %eax
incl %eax
movl %eax, -0x8(%r15)
leal (%r10,%r13), %eax
movl %eax, -0x4(%r15)
movl %r13d, (%r15)
incq %r12
addq $0x40, %r15
cmpq %rcx, %r9
jne 0x4332
movl $0x8, %eax
testb $0x1, %r11b
movl $0x0, %r11d
jne 0x431d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop