LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/./utility/cd.h
// Function: virt::util::cd::launch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string launch(std::string param){
			virt::util::shell* sh;
			if ((sh = dynamic_cast<virt::util::shell*>(working_os->app("shell"))) == NULL)
				return "ERROR: No module named \"shell\" found!\n";

			while (param[0] == ' ')
				param.erase(0, 1);
			while (param[param.length()-1] == ' ')
				param.erase(param.length()-1, 1);

			bool s = sh->shell_iterator.move_to(param);
			if (!s)
				return "No such directory. See 'help cd' for more information";
			return "";
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x14fe(%rip), %rsi      # 0x91ef
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3e68
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x595a
testq %rax, %rax
je 0x7d2f
leaq 0x7e77(%rip), %rsi      # 0xfb90
leaq 0x7e80(%rip), %rdx      # 0xfba0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0x7d32
xorl %r15d, %r15d
leaq 0x10(%rsp), %rdi
callq 0x30d0
testq %r15, %r15
je 0x7db7
pushq $0x1
popq %r12
movq (%r14), %rax
cmpb $0x20, (%rax)
jne 0x7d5c
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3070
jmp 0x7d45
pushq $0x1
popq %r12
movq 0x8(%r14), %rsi
cmpb $0x20, -0x1(%rax,%rsi)
jne 0x7d7e
decq %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3070
movq (%r14), %rax
jmp 0x7d60
addq $0x50, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3240
movq %r15, %rdi
movq %r12, %rsi
callq 0x570a
movl %eax, %ebp
leaq 0x30(%rsp), %rdi
callq 0x30d0
testb %bpl, %bpl
je 0x7dc0
leaq 0x2018(%rip), %rsi      # 0x9dcd
jmp 0x7dc7
leaq 0x1816(%rip), %rsi      # 0x95d4
jmp 0x7dc7
leaq 0x1b50(%rip), %rsi      # 0x9917
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e68
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x7df6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30d0
jmp 0x7e00
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/./utility/mkdir.h
// Function: virt::util::mkdir::launch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string launch(std::string param){
			virt::util::shell* sh;
			if ((sh = static_cast<virt::util::shell*>(working_os->app("shell"))) == NULL)
				return "ERROR: No module named \"shell\" found!";

			while (param[0] == ' ')
				param.erase(0, 1);
			while (param[param.length()-1] == ' ')
				param.erase(param.length()-1, 1);

			if (param.find('/') != std::string::npos || param.find(' ') != std::string::npos)
				return ("Invalid character '/' or ' ' in filename");

			if (param == "" || param == "." || param == "..")
				return ("Invalid file name. See 'help mkdir' for more information");

			bool res = sh->shell_iterator.get_working_dir()->add_subdir(param, false);
			if (!res)
				return "Cannot create file: file already exists";
			return "";
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x11ea(%rip), %rsi      # 0x91ef
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3e68
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x595a
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x30d0
testq %r15, %r15
je 0x809f
pushq $0x1
popq %r12
movq (%r14), %rax
cmpb $0x20, (%rax)
jne 0x804e
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3070
jmp 0x8037
pushq $0x1
popq %r12
movq 0x8(%r14), %rsi
cmpb $0x20, -0x1(%rax,%rsi)
jne 0x8070
decq %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3070
movq (%r14), %rax
jmp 0x8052
pushq $0x2f
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3230
cmpq $-0x1, %rax
jne 0x8096
pushq $0x20
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3230
cmpq $-0x1, %rax
je 0x80c3
leaq 0x1d31(%rip), %rsi      # 0x9dce
jmp 0x80a6
leaq 0x1ac8(%rip), %rsi      # 0x9b6e
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e68
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d03(%rip), %rsi      # 0x9dcd
movq %r14, %rdi
callq 0x4088
testb %al, %al
jne 0x80fc
leaq 0xf28(%rip), %rsi       # 0x9005
movq %r14, %rdi
callq 0x4088
testb %al, %al
jne 0x80fc
leaq 0xf14(%rip), %rsi       # 0x9004
movq %r14, %rdi
callq 0x4088
testb %al, %al
je 0x8105
leaq 0x1cf4(%rip), %rsi      # 0x9df7
jmp 0x80a6
addq $0x50, %r15
movq %r15, %rdi
callq 0x586a
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3240
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x398a
movl %eax, %ebp
leaq 0x30(%rsp), %rdi
callq 0x30d0
testb %bpl, %bpl
je 0x814e
leaq 0x1c84(%rip), %rsi      # 0x9dcd
jmp 0x80a6
leaq 0x1cdb(%rip), %rsi      # 0x9e30
jmp 0x80a6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x816c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30d0
jmp 0x8176
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/./utility/pwd.h
// Function: virt::util::pwd::launch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string launch(std::string param){
			virt::util::shell* sh;
			if ((sh = dynamic_cast<virt::util::shell*>(working_os->app("shell"))) == NULL)
				return "ERROR: No module named \"shell\" found!";

			while (param[0] == ' ')
				param.erase(0, 1);
			while (param[param.length()-1] == ' ')
				param.erase(param.length()-1, 1);

			return sh->shell_iterator.get_working_dir()->path() + "\n";
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x1055(%rip), %rsi      # 0x91ef
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3e68
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x595a
testq %rax, %rax
je 0x81d8
leaq 0x79ce(%rip), %rsi      # 0xfb90
leaq 0x79d7(%rip), %rdx      # 0xfba0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0x81db
xorl %r15d, %r15d
leaq 0x28(%rsp), %rdi
callq 0x30d0
testq %r15, %r15
je 0x8261
pushq $0x1
popq %r12
movq (%r14), %rax
cmpb $0x20, (%rax)
jne 0x8205
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3070
jmp 0x81ee
pushq $0x1
popq %r12
movq 0x8(%r14), %rsi
cmpb $0x20, -0x1(%rax,%rsi)
jne 0x8227
decq %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3070
movq (%r14), %rax
jmp 0x8209
addq $0x50, %r15
movq %r15, %rdi
callq 0x586a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x37f2
leaq 0x1b82(%rip), %rdx      # 0x9dcc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f55
leaq 0x8(%rsp), %rdi
callq 0x30d0
jmp 0x8275
leaq 0x1906(%rip), %rsi      # 0x9b6e
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e68
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x8296
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x30d0
jmp 0x82a0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O2/FalconUA[P]vfs/./utility/rm.h
// Function: virt::util::rm::launch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string launch(std::string param){
			virt::util::shell* sh;
			if ((sh = dynamic_cast<virt::util::shell*>(working_os->app("shell"))) == NULL)
				return "ERROR: No module named \"shell\" found!\n";

			while (param[0] == ' ')
				param.erase(0, 1);
			while (param[param.length()-1] == ' ')
				param.erase(param.length()-1, 1);

			sh->shell_iterator.get_working_dir()->remove_file(param);
			sh->shell_iterator.get_working_dir()->remove_subdir(param);
			return "";
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0xaab(%rip), %rsi       # 0x91ef
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3e68
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x595a
testq %rax, %rax
je 0x8782
leaq 0x7424(%rip), %rsi      # 0xfb90
leaq 0x742d(%rip), %rdx      # 0xfba0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x31f0
movq %rax, %r15
jmp 0x8785
xorl %r15d, %r15d
leaq 0x10(%rsp), %rdi
callq 0x30d0
testq %r15, %r15
je 0x8842
pushq $0x1
popq %r12
movq (%r14), %rax
cmpb $0x20, (%rax)
jne 0x87b3
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3070
jmp 0x879c
pushq $0x1
popq %r12
movq 0x8(%r14), %rsi
cmpb $0x20, -0x1(%rax,%rsi)
jne 0x87d5
decq %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3070
movq (%r14), %rax
jmp 0x87b7
addq $0x50, %r15
movq %r15, %rdi
callq 0x586a
movq %rax, %r12
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x3240
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e08
leaq 0x50(%rsp), %rdi
callq 0x30d0
movq %r15, %rdi
callq 0x586a
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3240
movq %r15, %rdi
movq %r12, %rsi
callq 0x3a7c
leaq 0x30(%rsp), %rdi
callq 0x30d0
leaq 0x158d(%rip), %rsi      # 0x9dcd
jmp 0x8849
leaq 0xd8b(%rip), %rsi       # 0x95d4
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3e68
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x8883
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x8883
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30d0
jmp 0x888d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x32c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/newick.cpp
// Function: get_nodes(newick_node*, std::vector<newick_node*, std::allocator<newick_node*>>&)
static void get_nodes(newick_node* node, vn& N)
{
    N[node->taxoni] = node;
    for (newick_child* child = node->child; child; child = child->next)
        if (!N[child->node->taxoni])
            get_nodes(child->node, N);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x28(%rdi), %rax
movq (%rsi), %rcx
movq %rdi, (%rcx,%rax,8)
movq (%r14), %r14
testq %r14, %r14
je 0x36cd
movq (%r14), %rdi
movslq 0x28(%rdi), %rax
movq (%rbx), %rcx
cmpq $0x0, (%rcx,%rax,8)
jne 0x36c7
movq %rbx, %rsi
callq 0x3691
addq $0x8, %r14
jmp 0x36a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/newick.cpp
// Function: load_tree(char const*)
newick_node* load_tree(const char* filename)
{
    ifstream File(filename);
    if (!File)
    {
        cout << "Cannot read " << filename << endl;
        return nullptr;
    }

    int Size;
    File.seekg(0, ios::end);
    Size = File.tellg();
    File.seekg(0, ios::beg);

    string str(Size, 0);
    File.read(&str[0], Size);

    size_t itr = 0;
    return parse_tree(str, itr);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2350
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x50(%rsp,%rax)
je 0x378c
movq 0x6857(%rip), %rdi      # 0x9fc0
leaq 0x2a09(%rip), %rsi      # 0x6179
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
xorl %ebx, %ebx
jmp 0x3803
leaq 0x30(%rsp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x2290
leaq 0x30(%rsp), %rdi
callq 0x2320
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2290
movslq %ebx, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2220
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rbx, %rdx
callq 0x2250
leaq 0x28(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x3847
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x30(%rsp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
retq
jmp 0x381d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x3835
jmp 0x3832
jmp 0x3832
jmp 0x3832
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/newick.cpp
// Function: parse_tree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long&)
static newick_node* parse_tree(string& str, size_t& itr)
{
    newick_child* child = nullptr;
    newick_child** childptr = &child;
    for (itr += 1; itr < str.size() && str[itr - 1] != ')'; ++itr)
    {
        newick_node* new_child = nullptr;
        if (str[itr] == '(')
            new_child = parse_tree(str, itr);
        else
            new_child = parse_node(str, itr, nullptr);

        *childptr = new newick_child(new_child);
        childptr = &(*childptr)->next;
    }
    return parse_node(str, itr, child);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r13
andq $0x0, (%r13)
pushq $0x10
popq %r15
movq (%rbx), %rcx
leaq 0x1(%rcx), %rax
movq %rax, (%rbx)
cmpq 0x8(%r14), %rax
jae 0x38be
movq (%r14), %rdx
cmpb $0x29, (%rdx,%rcx)
je 0x38be
cmpb $0x28, (%rdx,%rax)
jne 0x3894
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3847
jmp 0x38a1
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3e78
movq %rax, %r12
movq %r15, %rdi
callq 0x21e0
movq %r12, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, (%r13)
leaq 0x8(%rax), %r13
jmp 0x3868
movq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3e78
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/newick.cpp
// Function: load_dag_internal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, newick_node*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, newick_node*>>>&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>&)
static newick_node* load_dag_internal(const string& r, msn& M, msvs& C)
{
    if (newick_node* node = M[r])
        return node;

    newick_child* child = nullptr;
    newick_child** childptr = &child;
    for (const string& i : C[r])
    {
        *childptr = new newick_child(load_dag_internal(i, M, C));
        childptr = &(*childptr)->next;
    }
    return M[r] = new newick_node(r, 0, child);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %rdi
movq %r13, %rsi
callq 0x4140
movq (%rax), %r12
testq %r12, %r12
jne 0x3d95
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
movq %r15, %rdi
movq %r13, 0x8(%rsp)
movq %r13, %rsi
callq 0x401c
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x3d64
pushq $0x10
popq %rdi
callq 0x21e0
movq %rax, %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3cdf
movq %rax, (%rbp)
andq $0x0, 0x8(%rbp)
movq %rbp, (%rbx)
movq %rbp, %rbx
addq $0x8, %rbx
addq $0x20, %r12
jmp 0x3d2d
pushq $0x38
popq %rdi
callq 0x21e0
movq %rax, %r12
movq 0x10(%rsp), %rdx
xorps %xmm0, %xmm0
movq %rax, %rdi
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x3568
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4140
movq %r12, (%rax)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r12, %rdi
jmp 0x3dbb
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %rbp, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/newick.cpp
// Function: print_tree(newick_node*, std::ostream&)
void print_tree(newick_node* root, ostream& file)
{
    file << fixed << setprecision(6);
    if (root->child)
    {
        file << "(";
        for (newick_child* child = root->child; child; child = child->next)
        {
            print_tree(child->node, file);
            if (child->next)
                file << ",";
        }
        file << ")" << root->taxon << ":" /*<< root->dist*/;
    }
    else
        file << root->taxon << ":" /*<< root->dist*/;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rsi,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rsi,%rcx)
movq -0x18(%rax), %rax
movq $0x6, 0x8(%rsi,%rax)
cmpq $0x0, (%rdi)
je 0x3e51
leaq 0x23a8(%rip), %rsi      # 0x61b0
leaq 0x23a3(%rip), %r15      # 0x61b2
movq %rbx, %r12
movq %r14, %rdi
callq 0x21d0
movq (%r12), %r13
testq %r13, %r13
je 0x3e3f
movq (%r13), %rdi
movq %r14, %rsi
callq 0x3dc8
leaq 0x8(%r13), %r12
cmpq $0x0, 0x8(%r13)
je 0x3e1a
movq %r15, %rsi
jmp 0x3e12
leaq 0x23a4(%rip), %rsi      # 0x61ea
movq %r14, %rdi
callq 0x21d0
movq %rax, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21a0
leaq 0x234d(%rip), %rsi      # 0x61b4
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/newick.cpp
// Function: parse_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long&, newick_child*)
static newick_node* parse_node(string& str, size_t& itr, newick_child* child)
{
    size_t index = str.find_first_of(",);\r\n\0", itr);
    string data = str.substr(itr, index - itr);
    itr = index;

    size_t index2 = data.find_first_of(':');
    string taxon = data.substr(0, index2);
    float dist = 0;
    if (index2 != string::npos && data.back() != ':')
        dist = stof(data.substr(index2 + 1));

    return new newick_node(taxon, dist, child);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdx
leaq 0x2354(%rip), %rsi      # 0x61ec
callq 0x2100
movq %rax, %r12
movq (%r14), %rdx
movq %rax, %rcx
subq %rdx, %rcx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2200
movq %r12, (%r14)
pushq $0x3a
popq %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x2280
movq %rax, %r14
leaq 0x50(%rsp), %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2200
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
cmpq $-0x1, %r14
je 0x3f32
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpb $0x3a, -0x1(%rax,%rcx)
je 0x3f32
incq %r14
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %r14, %rdx
callq 0x2200
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x41d3
movss %xmm0, 0xc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x20e0
pushq $0x38
popq %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x50(%rsp), %rsi
movq %rax, %rdi
movss 0xc(%rsp), %xmm0
movq %rbx, %rdx
callq 0x3568
leaq 0x50(%rsp), %rdi
callq 0x20e0
leaq 0x10(%rsp), %rdi
callq 0x20e0
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20e0
jmp 0x3f9c
jmp 0x3f99
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x21f0
jmp 0x3f9c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x20e0
jmp 0x3fab
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/usefcnptr.cc
// Function: main
int main() 
{
    vector<int> ivec;
    // give ivec some values
    cout << "Direct call: "   
         << min_element(ivec.begin(), ivec.end()) << endl;

    cout << "Indirect call: " 
         << pf(ivec.begin(), ivec.end()) << endl;

	cout << "equivalent indirect call: "
	     << (*pf)(ivec.begin(), ivec.end()) << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
andq $0x0, -0x10(%rbp)
movq 0x2dc0(%rip), %rdi      # 0x3fd8
leaq 0xde5(%rip), %rsi       # 0x2004
callq 0x1070
movq %rax, %rbx
xorl %edi, %edi
xorl %esi, %esi
callq 0x12d4
movq %rbx, %rdi
movl %eax, %esi
callq 0x10a0
movq %rax, %rdi
callq 0x1050
movq 0x2d8f(%rip), %rdi      # 0x3fd8
leaq 0xdc2(%rip), %rsi       # 0x2012
callq 0x1070
movq %rax, %rbx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *0x2e0a(%rip)           # 0x4070
movq %rbx, %rdi
movl %eax, %esi
callq 0x10a0
movq %rax, %rdi
callq 0x1050
movq 0x2d59(%rip), %rdi      # 0x3fd8
leaq 0xd9c(%rip), %rsi       # 0x2022
callq 0x1070
movq %rax, %rbx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *0x2dd4(%rip)           # 0x4070
movq %rbx, %rdi
movl %eax, %esi
callq 0x10a0
movq %rax, %rdi
callq 0x1050
leaq -0x20(%rbp), %rdi
callq 0x12fc
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x12fc
movq %rbx, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/usefcnptr.cc
// Function: min_element(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>)
int min_element(vector<int>::iterator beg, 
                vector<int>::iterator end) {
    int minVal = 0;
    while (beg != end) {
        if (minVal > *beg)
            minVal = *beg;
        ++beg;
    }
    return minVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpq %rsi, %rdi
je 0x12ec
movl (%rdi), %ecx
cmpl %ecx, %eax
cmovgel %ecx, %eax
addq $0x4, %rdi
jmp 0x12da
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/flip.cc
// Function: main
int main()
{
	int i = 0, j = 0, k = 0, l = 0;
	cout << i << " " << j << " " << k << " " << l << endl;

	f(42, i);        // f changes its argument i
	flip1(f, j, 42); // f called through flip1 leaves j unchanged
	flip2(f, k, 42); // ok: k is changed
	g(1, i);
	flip(g, i, 42);  // ok: rvalue-ness of the third argument is preserved
	cout << i << " " << j << " " << k << " " << l << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x34(%rbp), %r15
andl $0x0, (%r15)
leaq -0x30(%rbp), %rbx
andl $0x0, (%rbx)
movq 0x2d75(%rip), %rdi      # 0x3fd8
xorl %esi, %esi
callq 0x1070
leaq 0xd93(%rip), %r14       # 0x2004
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
pushq $0x2a
popq %r13
movl %r13d, %edi
movq %r15, %rsi
callq 0x11bc
leaq -0x2c(%rbp), %r12
andl $0x0, (%r12)
movl %r13d, %edi
movq %r12, %rsi
callq 0x11bc
movl %r13d, %edi
movq %rbx, %rsi
callq 0x11bc
movl $0x1, (%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x11fe
movl $0x2a, (%r12)
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
callq 0x11fe
movl (%r15), %esi
movq 0x2cc1(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movl (%rbx), %esi
movq %rax, %rdi
callq 0x1070
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rax, %rdi
xorl %esi, %esi
callq 0x1070
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::cummulative_distribution(std::vector<double, std::allocator<double>>&)
void cummulative_distribution(Table &cdf){
            for(size_t i = 0; i < bincount; i++){
                if(i == 0) cdf[i] = pmf[i];
                else{
                    cdf[i] = cdf[i-1] + pmf[i];
                }
            }
        }

// Assembly:
movq (%rdi), %rax
movq 0x78(%rdi), %rcx
movq (%rsi), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x35ef
testq %rsi, %rsi
je 0x35e2
movsd -0x8(%rdx,%rsi,8), %xmm0
addsd (%rax,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
jmp 0x35ea
movsd (%rax), %xmm0
movsd %xmm0, (%rdx)
incq %rsi
jmp 0x35c6
retq
// File: /workspace/github_cpp_makefile_star2_O2/bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::empirical_distribution(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
void empirical_distribution(Table &samples, Values &edf){
            std::sort(samples.begin(), samples.end()); 
            size_t count = 0;
            double last = samples[samples.size() - 1];
            for(size_t i = 0; i < values.size(); i++){
                count = 0;
                if(values[i] < samples[0] && fabs(samples[0] - values[i]) > 1e-6){
                    edf[i] = 0.0;
                    continue;
                }else if(values[i] >= last || fabs(values[i] - last)  < 1e-6){
                
                    edf[i] = 1.0;
                    continue;
                }else{
                    for(size_t j = 0 ; j < samples.size(); j++){
                        if( values[i] >= samples[j] || fabs(values[i] - samples[j]) < 1e-6 ){
                            count++;
                        }else{
                            break;
                        }

                    }
                    edf[i] = double(count) / samples.size();
                }
            }
        
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x420d
movq (%r14), %rax
movq 0x8(%r14), %rcx
movsd -0x8(%rcx), %xmm0
subq %rax, %rcx
sarq $0x3, %rcx
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
movq %rcx, %xmm2
punpckldq 0x2a4f(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x2a57(%rip), %xmm2     # 0x60a0
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1            # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
movq (%rbx), %rdi
xorl %r8d, %r8d
movapd 0x2a4d(%rip), %xmm2     # 0x60b0
movsd 0x29dd(%rip), %xmm3     # 0x6048
movsd 0x299d(%rip), %xmm4     # 0x6010
movq 0x2a15(%rip), %xmm5     # 0x6090
movapd 0x2a1d(%rip), %xmm6     # 0x60a0
cmpq %rsi, %r8
je 0x3740
movsd (%rdx,%r8,8), %xmm7
movsd (%rax), %xmm9
ucomisd %xmm7, %xmm9
jbe 0x36b4
subsd %xmm7, %xmm9
andpd %xmm2, %xmm9
xorpd %xmm8, %xmm8
ucomisd %xmm3, %xmm9
ja 0x3732
ucomisd %xmm0, %xmm7
movapd %xmm4, %xmm8
jae 0x3732
movapd %xmm7, %xmm8
subsd %xmm0, %xmm8
andpd %xmm2, %xmm8
ucomisd %xmm8, %xmm3
movapd %xmm4, %xmm8
ja 0x3732
xorl %r9d, %r9d
cmpq %r9, %rcx
je 0x370a
movsd (%rax,%r9,8), %xmm8
ucomisd %xmm8, %xmm7
jae 0x3705
movapd %xmm7, %xmm9
subsd %xmm8, %xmm9
andpd %xmm2, %xmm9
ucomisd %xmm9, %xmm3
jbe 0x3711
incq %r9
jmp 0x36dd
movapd %xmm1, %xmm8
jmp 0x372d
movq %r9, %xmm7
punpckldq %xmm5, %xmm7    # xmm7 = xmm7[0],xmm5[0],xmm7[1],xmm5[1]
subpd %xmm6, %xmm7
movapd %xmm7, %xmm8
unpckhpd %xmm7, %xmm8            # xmm8 = xmm8[1],xmm7[1]
addsd %xmm7, %xmm8
divsd %xmm1, %xmm8
movsd %xmm8, (%rdi,%r8,8)
incq %r8
jmp 0x3683
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::cramer_von_mises(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double cramer_von_mises(const Table &cdf, const Table &edf){
            double sum = 0.0;
            for(size_t i = 0; i < bincount; i++){
                sum += (edf[i] - cdf[i]) * (edf[i] - cdf[i]);
            }
            return sqrt(sum / bincount);
        }

// Assembly:
movq 0x78(%rdi), %rax
movq (%rdx), %rcx
movq (%rsi), %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
cmpq %rsi, %rax
je 0x3772
movsd (%rcx,%rsi,8), %xmm1
subsd (%rdx,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rsi
jmp 0x3756
movq %rax, %xmm1
punpckldq 0x2911(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x2919(%rip), %xmm1     # 0x60a0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x20d0
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/bolongz[P]Systematic-Alias-Sampling/./sas.h
// Function: SystematicAliasSampling::simple_sas(int, std::vector<double, std::allocator<double>>&, int)
void simple_sas(int samplecount, Table &samples, int from = 0){
                
                double steps = double(bincount) / samplecount;
                //double r = _random(0.0, steps);
                double r = steps * (1.0 - __random(gen));
                double x =  bincount - r;
                int i = from;

                int to = from + samplecount;
                while(i < to){
                  //  int ri = int(x);
                   // int rf  = x  -ri;
                    samples[i] = aliassample(int(x), x- int(x));
                    x -= steps;
                    i++;
                }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r14d
movq %rdi, %rbx
movsd 0x78(%rdi), %xmm0
unpcklps 0x2893(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x289b(%rip), %xmm0     # 0x60a0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
leaq 0x802b(%rip), %rdi      # 0xb850
leaq 0x6c94(%rip), %rsi      # 0xa4c0
callq 0x35f0
movapd (%rsp), %xmm3
movsd 0x27d2(%rip), %xmm1     # 0x6010
subsd %xmm0, %xmm1
mulsd %xmm3, %xmm1
movsd 0x78(%rbx), %xmm2
unpcklps 0x283e(%rip), %xmm2     # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x2846(%rip), %xmm2     # 0x60a0
movapd %xmm2, %xmm0
unpckhpd %xmm2, %xmm0            # xmm0 = xmm0[1],xmm2[1]
addsd %xmm2, %xmm0
subsd %xmm1, %xmm0
addl %ebp, %r14d
movq 0x60(%rbx), %rax
movq (%r15), %rcx
movslq %ebp, %rdx
movslq %r14d, %rsi
leaq 0x30(%rbx), %rdi
addq $0x18, %rbx
cmpq %rsi, %rdx
jge 0x38c7
cvttsd2si %xmm0, %r8d
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movslq %r8d, %r8
movsd (%rax,%r8,8), %xmm1
ucomisd %xmm2, %xmm1
movq %rdi, %r9
cmovbq %rbx, %r9
movq (%r9), %r9
movsd (%r9,%r8,8), %xmm1
movsd %xmm1, (%rcx,%rdx,8)
subsd %xmm3, %xmm0
incq %rdx
jmp 0x3882
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/Simulation.cpp
// Function: main
int main(int argc, char **argv) {
    Simulation simulation;

    std::cout << "Virtual Memory Simulation" << std::endl;

    //Get the input file from the user
    std::string filepath;
    std::cout << "Input file: ";
    std::cin >> filepath;

    //Remove whitespace/newlines
    StringUtilities::Trim(filepath);

    simulation.SetInputFilepath(filepath);
    simulation.Run();

    std::cout << std::endl << "Simulation Complete:" << std::endl;

    simulation.DisplayStatistics();
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
leaq 0x60(%rsp), %rdi
callq 0x2f32
movq 0x9653(%rip), %rdi      # 0xbfc8
leaq 0x46c6(%rip), %rsi      # 0x7042
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x9627(%rip), %rdi      # 0xbfc8
leaq 0x46b4(%rip), %rsi      # 0x705c
callq 0x21d0
movq 0x9624(%rip), %rdi      # 0xbfd8
movq %rsp, %rsi
callq 0x2240
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x2270
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2f90
leaq 0x40(%rsp), %rdi
callq 0x20e0
leaq 0x20(%rsp), %rdi
callq 0x20e0
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x2110
leaq 0x60(%rsp), %rdi
callq 0x2a84
movq 0x95be(%rip), %rdi      # 0xbfc8
callq 0x20f0
leaq 0x4653(%rip), %rsi      # 0x7069
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
leaq 0x60(%rsp), %rdi
callq 0x2ea0
movq %rsp, %rdi
callq 0x20e0
leaq 0x60(%rsp), %rdi
callq 0x3004
xorl %eax, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20e0
jmp 0x2a64
movq %rax, %rbx
jmp 0x2a6c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20e0
leaq 0x60(%rsp), %rdi
callq 0x3004
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/./StringUtilities.h
// Function: StringUtilities::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::vector<std::string> SplitString(std::string s, const std::string &delimiter) {
        size_t pos = 0;
        std::vector<std::string> tokens;

        bool debug = false;

        if(debug) std::cout << "s = " << s << ", delimiter = " << delimiter;

        while((pos = s.find(delimiter)) != std::string::npos) {
            if(debug) std::cout << "Found delimiter at pos = " << pos << std::endl;
            tokens.push_back(s.substr(0, pos));
            if(debug) std::cout << "Added token to vector: " << s.substr(0, pos) << std::endl;
            s.erase(0, pos + delimiter.length());
            if(debug) std::cout << "Erased token and delimiter" << std::endl;
        }

        if(debug) std::cout << "Adding last token to vector: " << s << std::endl;
        tokens.push_back(s);

        return tokens;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2340
cmpq $-0x1, %rax
je 0x3094
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2200
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3c92
movq %r12, %rdi
callq 0x20e0
addq 0x8(%r15), %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x2070
jmp 0x3048
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c66
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x30c1
jmp 0x30c1
movq %rax, %r14
movq %rsp, %rdi
callq 0x20e0
jmp 0x30c4
movq %rax, %r14
movq %rbx, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/./Memory.h
// Function: Memory::Memory()
Memory(void) {
        ram.clear();
        available.clear();
        free.clear();
        lru.clear();

        //Generate 16 available frames
        for(int i = 0; i < (MEM_SIZE / FRAME_SIZE); i++) {
            available.insert(i);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x38(%rdi), %rax
andl $0x0, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
andl $0x0, 0x68(%rdi)
leaq 0x30(%rdi), %r14
andq $0x0, 0x70(%rdi)
leaq 0x60(%rdi), %r15
leaq 0x68(%rdi), %rax
movq %rax, 0x78(%rdi)
movq %rax, 0x80(%rdi)
andq $0x0, 0x88(%rdi)
leaq 0x90(%rdi), %r12
movq %r12, %rdi
callq 0x34ac
movq %rbx, %rdi
callq 0x36b8
movq %r14, %rdi
callq 0x36b8
movq %r15, %rdi
callq 0x36b8
movq %r12, %rdi
callq 0x3484
xorl %ebp, %ebp
leaq 0x6(%rsp), %r13
cmpl $0x10, %ebp
je 0x3445
movw %bp, 0x6(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x3762
incl %ebp
jmp 0x342c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
jmp 0x3464
movq %rax, %r13
movq %r12, %rdi
callq 0x38bc
movq %r15, %rdi
callq 0x38ea
movq %r14, %rdi
callq 0x38ea
movq %rbx, %rdi
callq 0x38ea
movq %r13, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/Memory.cpp
// Function: Memory::AvailableToRAM(unsigned short)
void Memory::AvailableToRAM(const uint16_t frame) {
    //Make sure it does not exist in the available list
    if(available.count(frame)) {
        available.erase(available.find(frame));
    }

    ram.insert(frame);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6(%rsp), %rax
movw %si, (%rax)
leaq 0x30(%rdi), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x58d0
testq %rax, %rax
je 0x5727
leaq 0x6(%rsp), %rsi
movq %r14, %rdi
callq 0x5b8e
movq %r14, %rdi
movq %rax, %rsi
callq 0x5be4
leaq 0x6(%rsp), %rsi
movq %rbx, %rdi
callq 0x5c32
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::Process()
Process::Process(void) {
    name.clear();
    references = 0;
    pageFaults = 0;
    size = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
addq $0x28, %rdi
callq 0x60d8
leaq 0x70(%rbx), %rax
andl $0x0, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
andq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
andl $0x0, 0x20(%rbx)
andw $0x0, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::Process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Process::Process(const std::string & name) {
    this->name = name;
    references = 0;
    pageFaults = 0;
    size = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x60d8
leaq 0x70(%rbx), %rax
andl $0x0, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2110
andl $0x0, 0x20(%rbx)
andw $0x0, 0x24(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x68(%rbx), %rdi
callq 0x38ea
movq %r14, %rdi
callq 0x47ae
jmp 0x5dc3
movq %rax, %r15
movq %rbx, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::PageAccess(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
uint16_t Process::PageAccess(const std::string & string) {
    //Decode the string into the page number
    uint16_t page = DecodePageNumber(string);

    //Add the referenced page number to the set
    pages.insert(page);

    //Determine the range of the page set (this is the size...)
    size = ComputeSize();

    //Increment number of references
    references++;

    return page;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5e12
leaq 0x6(%rsp), %r14
movw %ax, (%r14)
leaq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x5c32
movq %rbx, %rdi
callq 0x5f7a
movw %ax, 0x24(%rbx)
incw 0x20(%rbx)
movzwl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::DecodePageNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
uint16_t Process::DecodePageNumber(const std::string & string) {
    //Create a bitset from the string
    std::bitset<6> bitset(string);

    //Return and cast the integer representation of the bitset
    return (uint16_t)bitset.to_ulong();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5f94
movzwl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/Process.cpp
// Function: Process::DisplayStatistics()
void Process::DisplayStatistics(void) {
    std::cout << std::endl;
    std::cout << "Process: \"" << name << "\"" << std::endl;
    std::cout << "-------------------------" << std::endl;
    std::cout << "Memory References: " << references << std::endl;
    std::cout << "Page Faults: " << pageFaults << std::endl;
    std::cout << "Size in Pages: " << size << std::endl;
    std::cout << "Fault Rate: " << ((float)pageFaults / (float)references) * 100.0 << "%" << std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x617e(%rip), %r14      # 0xbfc8
movq %r14, %rdi
callq 0x20f0
leaq 0x147f(%rip), %rsi      # 0x72d8
movq %r14, %rdi
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
leaq 0x146e(%rip), %rsi      # 0x72e1
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
leaq 0x1459(%rip), %rsi      # 0x72e3
movq %r14, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
leaq 0x145c(%rip), %rsi      # 0x72fd
movq %r14, %rdi
callq 0x21d0
movzwl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x2300
movq %rax, %rdi
callq 0x20f0
leaq 0x144d(%rip), %rsi      # 0x7311
movq %r14, %rdi
callq 0x21d0
movzwl 0x22(%rbx), %esi
movq %rax, %rdi
callq 0x2300
movq %rax, %rdi
callq 0x20f0
leaq 0x1438(%rip), %rsi      # 0x731f
movq %r14, %rdi
callq 0x21d0
movzwl 0x24(%rbx), %esi
movq %rax, %rdi
callq 0x2300
movq %rax, %rdi
callq 0x20f0
leaq 0x1425(%rip), %rsi      # 0x732f
movq %r14, %rdi
callq 0x21d0
movq 0x20(%rbx), %xmm0
pxor %xmm1, %xmm1
punpcklwd %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
divss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm0
mulsd 0x1397(%rip), %xmm0     # 0x72d0
movq %rax, %rdi
callq 0x22c0
leaq 0x13f4(%rip), %rsi      # 0x733c
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/PageTable.cpp
// Function: PageTable::EntryExists(unsigned short)
bool PageTable::EntryExists(const uint16_t page) {
    //Return true if the page entry exists AND is valid
    if(table.count(page)) {
        if(table[page].valid) {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe(%rsp), %rax
movw %si, (%rax)
movq %rax, %rsi
callq 0x61fc
testq %rax, %rax
je 0x6177
leaq 0xe(%rsp), %rsi
movq %rbx, %rdi
callq 0x6290
movq %rax, %rcx
movb $0x1, %al
cmpb $0x0, 0x4(%rcx)
jne 0x6179
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/PageTable.cpp
// Function: PageTable::AddEntry(unsigned short, PageTableEntry&)
void PageTable::AddEntry(const uint16_t page, PageTableEntry & entry) {
    //Set the valid bit
    entry.valid = true;

    //Store the entry in the page table
    table[page] = entry;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
leaq 0xe(%rsp), %rax
movw %si, (%rax)
movb $0x1, 0x4(%rdx)
movq %rax, %rsi
callq 0x6290
movl (%rbx), %ecx
movl %ecx, (%rax)
movb 0x4(%rbx), %cl
movb %cl, 0x4(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/gibsjose[P]VirtualMemorySimulation/PageTable.cpp
// Function: PageTable::GetEntry(unsigned short)
PageTableEntry & PageTable::GetEntry(const uint16_t page) {
    //Returns the entry associated with the page, if it exists
    if(table.count(page)) {
        return table[page];
    } else {
        return invalid;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe(%rsp), %rax
movw %si, (%rax)
movq %rax, %rsi
callq 0x61fc
testq %rax, %rax
je 0x61ef
leaq 0xe(%rsp), %rsi
movq %rbx, %rdi
callq 0x6290
movq %rax, %rbx
jmp 0x61f3
addq $0x38, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/texture-packing.cpp
// Function: showUsage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void showUsage(const std::string name) {
	std::cerr << "Utilisation : " << std::endl
			<< name << " --help" << std::endl
			<< "Affiche plus de détails" << std::endl
			<< name << " [--seed nombre] [--tmin tailleMin] [--tmax tailleMax] [--lt largeurTexture] [--ht hauteurTexture] [--sortie nomDossier] [--tests nombre] [algorithme(s)]" << std::endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8ee2(%rip), %rdi      # 0xcff0
leaq 0x45ec(%rip), %rsi      # 0x8701
callq 0x2210
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21f0
leaq 0x45dc(%rip), %rsi      # 0x8710
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x2110
leaq 0x45cd(%rip), %rsi      # 0x8718
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21f0
leaq 0x45c4(%rip), %rsi      # 0x8731
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
popq %rbx
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/samuel500[P]NEAT/main.cpp
// Function: main
int main(int argc, char *argv[]){
	srand(time(0));

	int population_size = 150;

	Population population = Population(population_size, 3, 1);

	for(int i=0; i<1000; ++i){
		cout << "gen " << i+1 << endl;
		// cout << "m1" << endl;
		// cout << "m2" << endl;

		population.xor_epoch();

		// cout << "m3" << endl;

		cout << "spe size " << population.species.size() << endl;

		// cout << "m4" << endl;

		cout << "fin innov_num " << *(population.innov_num) << endl;

		cout << "elite " << population.elite->fitness << endl;
		// population.test_elite();
		cout << "max f " << population.max_fitness << endl;

		cout << "pop size " << population.individuals.size() << endl;
		if(population.max_fitness>15.9){

			vector<Connection*>::iterator conPtr;
			for(conPtr=population.elite->connections.begin(); conPtr!=population.elite->connections.end(); ++conPtr){
				cout << "w " << (*conPtr)->weight << endl; 
			}
			break;
		}
	}

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
xorl %edi, %edi
callq 0x10c0
movl %eax, %edi
callq 0x10d0
leaq -0xb0(%rbp), %rbx
pushq $0x3
popq %rdx
pushq $0x1
popq %r14
movq %rbx, %rdi
movl $0x96, %esi
movl %r14d, %ecx
callq 0x15c8
movq 0x9bc5(%rip), %r15      # 0xafd8
leaq 0x5c1b(%rip), %r12      # 0x7035
leaq 0x5c1b(%rip), %r13      # 0x703c
cmpl $0x3e9, %r14d           # imm = 0x3E9
je 0x157b
movq %r15, %rdi
leaq 0x5bd8(%rip), %rsi      # 0x7010
callq 0x10e0
movq %rax, %rdi
movl %r14d, %esi
callq 0x1170
movq %rax, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1ba4
movq %r15, %rdi
leaq 0x5bb3(%rip), %rsi      # 0x7015
callq 0x10e0
movq -0x58(%rbp), %rsi
subq -0x60(%rbp), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1070
movq %r15, %rdi
leaq 0x5b92(%rip), %rsi      # 0x701f
callq 0x10e0
movq -0x38(%rbp), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x1170
movq %rax, %rdi
callq 0x1070
movq %r15, %rdi
leaq 0x5b7c(%rip), %rsi      # 0x702e
callq 0x10e0
movq -0x68(%rbp), %rcx
movsd (%rcx), %xmm0
movq %rax, %rdi
callq 0x1130
movq %rax, %rdi
callq 0x1070
movq %r15, %rdi
movq %r12, %rsi
callq 0x10e0
movsd -0x30(%rbp), %xmm0
movq %rax, %rdi
callq 0x1130
movq %rax, %rdi
callq 0x1070
movq %r15, %rdi
movq %r13, %rsi
callq 0x10e0
movq -0xa8(%rbp), %rsi
subq -0xb0(%rbp), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x1090
movq %rax, %rdi
callq 0x1070
movsd -0x30(%rbp), %xmm0
incl %r14d
ucomisd 0x5adc(%rip), %xmm0     # 0x7008
jbe 0x1421
movq -0x68(%rbp), %rax
movq 0x60(%rax), %r15
movq 0x9a97(%rip), %rbx      # 0xafd8
leaq 0x5afe(%rip), %r14      # 0x7046
cmpq 0x68(%rax), %r15
je 0x157b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10e0
movq (%r15), %rcx
movsd 0x10(%rcx), %xmm0
movq %rax, %rdi
callq 0x1130
movq %rax, %rdi
callq 0x1070
addq $0x8, %r15
movq -0x68(%rbp), %rax
jmp 0x1548
leaq -0xb0(%rbp), %rdi
callq 0x2216
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x159d
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2216
movq %rbx, %rdi
callq 0x1180