LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<NonTrivialStringMovable, std::allocator<NonTrivialStringMovable>, unsigned short>::group_fill(NonTrivialStringMovable const&, unsigned short)
void group_fill(const element_type &element, const skipfield_type number_of_elements)
	{
		const element_pointer_type fill_end = end_iterator.element_pointer + number_of_elements;

		do
		{
			try
			{
				PLF_COLONY_CONSTRUCT(element_allocator_type, (*this), end_iterator.element_pointer++, element);
			}
			catch (...)
			{
				end_iterator.group_pointer->last_endpoint = --end_iterator.element_pointer;
				const skipfield_type temp = static_cast<const skipfield_type>(end_iterator.element_pointer - end_iterator.group_pointer->elements);
				end_iterator.group_pointer->number_of_elements = temp;
				end_iterator.skipfield_pointer = end_iterator.group_pointer->skipfield + temp;
				throw;
			}
		} while (end_iterator.element_pointer != fill_end);

		end_iterator.group_pointer->last_endpoint = end_iterator.element_pointer;
		end_iterator.group_pointer->number_of_elements = number_of_elements;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl %edx, %eax
imulq $0x28, %rax, %r15
movl %edx, %ebp
movq %rsi, %r14
addq %rdi, %r15
leaq 0x28(%rdi), %rax
movq %rax, 0x8(%rbx)
movq %r14, %rsi
callq 0x14020
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
jne 0x71c5a
movq (%rbx), %rax
movq %rdi, (%rax)
movw %bp, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x4090
movq 0x8(%rbx), %rax
movq (%rbx), %rcx
addq $-0x28, %rax
movq %rax, 0x8(%rbx)
movq %rax, (%rcx)
subq 0x10(%rcx), %rax
pushq $0x28
popq %rsi
cqto
idivq %rsi
movw %ax, 0x30(%rcx)
movzwl %ax, %eax
addl %eax, %eax
addq 0x18(%rcx), %rax
movq %rax, 0x10(%rbx)
callq 0x4240
movq %rax, %rbx
callq 0x42b0
movq %rbx, %rdi
callq 0x42c0
movq %rax, %rdi
callq 0x7b4a
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/plf_colony_alpha/plf_colony.h
// Function: plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::group_create(unsigned short)
void group_create(const skipfield_type number_of_elements)
	{
		const group_pointer_type next_group = end_iterator.group_pointer->next_group = PLF_COLONY_ALLOCATE(group_allocator_type, group_allocator_pair, 1, end_iterator.group_pointer);

		try
		{
			#ifdef PLF_COLONY_VARIADICS_SUPPORT
				PLF_COLONY_CONSTRUCT(group_allocator_type, group_allocator_pair, next_group, number_of_elements, end_iterator.group_pointer);
			#else
				PLF_COLONY_CONSTRUCT(group_allocator_type, group_allocator_pair, next_group, group(number_of_elements, end_iterator.group_pointer));
			#endif
		}
		catch (...)
		{
			PLF_COLONY_DESTROY(group_allocator_type, group_allocator_pair, next_group);
			PLF_COLONY_DEALLOCATE(group_allocator_type, group_allocator_pair, next_group, 1);
			end_iterator.group_pointer->next_group = NULL;
			throw;
		}

		end_iterator.group_pointer = next_group;
		end_iterator.element_pointer = next_group->elements;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %ebp
pushq $0x38
popq %rdi
callq 0x41a0
movq (%rbx), %rcx
movq %rax, %r14
movq %r14, 0x8(%rcx)
movq (%rbx), %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x94c8
movq %r14, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x4090
movq %r14, %rdi
callq 0x95a8
movq %r14, %rdi
callq 0x4180
movq (%rbx), %rax
andq $0x0, 0x8(%rax)
callq 0x4240
movq %rax, %rbx
callq 0x42b0
movq %rbx, %rdi
callq 0x42c0
movq %rax, %rdi
callq 0x7b4a
nop
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list_update_1/bench.cpp
// Function: bench_erase_1<Trivial<8>>::run()
static void run(){
        new_graph<T>("erase1", "us");

        auto sizes = {10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000};
        bench<std::vector<T>, microseconds, FilledRandom, RandomErase1>("vector", sizes);
        bench<std::list<T>,   microseconds, FilledRandom, RandomErase1>("list",   sizes);
        bench<std::deque<T>,  microseconds, FilledRandom, RandomErase1>("deque",  sizes);
        bench<plf::colony<T>,  microseconds, FilledRandomInsert, RandomErase1>("colony",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x16236(%rip), %rsi     # 0x89c12
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x4080
leaq 0x16078(%rip), %rsi     # 0x89a6a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7e73
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x40b0
vmovups 0x15b61(%rip), %ymm0    # 0x89590
movabsq $0x186a000015f90, %rax  # imm = 0x186A000015F90
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x16017(%rip), %rsi     # 0x89a6d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x73b61
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x15fec(%rip), %rsi     # 0x89a74
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x73c54
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x15fc2(%rip), %rsi     # 0x89a79
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x73d47
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x15fa8(%rip), %rsi     # 0x89a8e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x73e3a
leaq 0x10(%rsp), %rdi
callq 0x40b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x73b20
jmp 0x73b4a
jmp 0x73b20
jmp 0x73b4a
jmp 0x73b20
jmp 0x73b4a
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x73b43
jmp 0x73b4a
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x40b0
jmp 0x73b3e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x40b0
jmp 0x73b4d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/include/policies.hpp
// Function: RandomErase1<std::deque<Trivial<8>, std::allocator<Trivial<8>>>>::run(std::deque<Trivial<8>, std::allocator<Trivial<8>>>&, unsigned long)
inline static void run(Container &c, std::size_t /*size*/){
        auto it = c.begin();

        while(it != c.end()){
            if(distribution(generator) > 9900){
                it = c.erase(it);
            } else {
                ++it;
            }
        }

        std::cout << c.size() << std::endl;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x18(%rdi), %rax
movq 0x10(%rdi), %rbp
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %r12
leaq 0xb81bd(%rip), %r14     # 0x12c1f8
leaq 0xb81ce(%rip), %r15     # 0x12c210
movq %rdi, %rbx
movq %rax, (%rsp)
cmpq 0x30(%rbx), %rbp
je 0x740c5
movq %r14, %rdi
movq %r15, %rsi
callq 0x267b6
cmpq $0x26ad, %rax           # imm = 0x26AD
jae 0x74081
addq $0x8, %rbp
cmpq %r13, %rbp
jne 0x74049
movq 0x8(%r12), %rbp
addq $0x8, %r12
leaq 0x200(%rbp), %r13
movq %rbp, (%rsp)
jmp 0x74049
movq (%rsp), %rax
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rbp, 0x8(%rsp)
movq %rbx, %rsi
movq %rax, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
callq 0x3d03c
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rbp
movq 0x38(%rsp), %r13
movq 0x40(%rsp), %r12
movq %rax, (%rsp)
jmp 0x74049
movq %rbx, %rdi
callq 0x8eec
movq 0x62f04(%rip), %rdi     # 0xd6fd8
movq %rax, %rsi
callq 0x4110
movq %rax, %rdi
callq 0x40c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list_update_1/bench.cpp
// Function: bench_erase_10<Trivial<8>>::run()
static void run(){
        new_graph<T>("erase10", "us");

        auto sizes = {10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000};
        bench<std::vector<T>, microseconds, FilledRandom, RandomErase10>("vector", sizes);
        bench<std::list<T>,   microseconds, FilledRandom, RandomErase10>("list",   sizes);
        bench<std::deque<T>,  microseconds, FilledRandom, RandomErase10>("deque",  sizes);
        bench<plf::colony<T>,  microseconds, FilledRandomInsert, RandomErase10>("colony",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x12299(%rip), %rsi     # 0x89c19
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x4080
leaq 0x120d4(%rip), %rsi     # 0x89a6a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7e73
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x40b0
vmovups 0x11bbd(%rip), %ymm0    # 0x89590
movabsq $0x186a000015f90, %rax  # imm = 0x186A000015F90
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x12073(%rip), %rsi     # 0x89a6d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x77b05
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x12048(%rip), %rsi     # 0x89a74
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x77bf8
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x1201e(%rip), %rsi     # 0x89a79
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x77ceb
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x12004(%rip), %rsi     # 0x89a8e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x77dde
leaq 0x10(%rsp), %rdi
callq 0x40b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x77ac4
jmp 0x77aee
jmp 0x77ac4
jmp 0x77aee
jmp 0x77ac4
jmp 0x77aee
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x77ae7
jmp 0x77aee
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x40b0
jmp 0x77ae2
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x40b0
jmp 0x77af1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/include/policies.hpp
// Function: RandomErase10<std::deque<Trivial<8>, std::allocator<Trivial<8>>>>::run(std::deque<Trivial<8>, std::allocator<Trivial<8>>>&, unsigned long)
inline static void run(Container &c, std::size_t /*size*/){
        auto it = c.begin();

        while(it != c.end()){
            if(distribution(generator) > 9000){
                it = c.erase(it);
            } else {
                ++it;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x18(%rdi), %rax
movq 0x10(%rdi), %rbp
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %r12
leaq 0xdb74d(%rip), %r14     # 0x1536f8
leaq 0xdb75e(%rip), %r15     # 0x153710
movq %rdi, %rbx
movq %rax, (%rsp)
cmpq 0x30(%rbx), %rbp
je 0x78035
movq %r14, %rdi
movq %r15, %rsi
callq 0x267b6
cmpq $0x2329, %rax           # imm = 0x2329
jae 0x77ff1
addq $0x8, %rbp
cmpq %r13, %rbp
jne 0x77fb9
movq 0x8(%r12), %rbp
addq $0x8, %r12
leaq 0x200(%rbp), %r13
movq %rbp, (%rsp)
jmp 0x77fb9
movq (%rsp), %rax
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rbp, 0x8(%rsp)
movq %rbx, %rsi
movq %rax, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
callq 0x3d03c
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rbp
movq 0x38(%rsp), %r13
movq 0x40(%rsp), %r12
movq %rax, (%rsp)
jmp 0x77fb9
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list_update_1/bench.cpp
// Function: bench_erase_25<Trivial<8>>::run()
static void run(){
        new_graph<T>("erase25", "us");

        auto sizes = {10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000};
        bench<std::vector<T>, microseconds, FilledRandom, RandomErase25>("vector", sizes);
        bench<std::list<T>,   microseconds, FilledRandom, RandomErase25>("list",   sizes);
        bench<std::deque<T>,  microseconds, FilledRandom, RandomErase25>("deque",  sizes);
        bench<plf::colony<T>,  microseconds, FilledRandomInsert, RandomErase25>("colony",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0xe66d(%rip), %rsi      # 0x89c21
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x4080
leaq 0xe4a0(%rip), %rsi      # 0x89a6a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7e73
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x40b0
vmovups 0xdf89(%rip), %ymm0     # 0x89590
movabsq $0x186a000015f90, %rax  # imm = 0x186A000015F90
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0xe43f(%rip), %rsi      # 0x89a6d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7b739
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0xe414(%rip), %rsi      # 0x89a74
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7b82c
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0xe3ea(%rip), %rsi      # 0x89a79
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7b91f
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0xe3d0(%rip), %rsi      # 0x89a8e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7ba12
leaq 0x10(%rsp), %rdi
callq 0x40b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x7b6f8
jmp 0x7b722
jmp 0x7b6f8
jmp 0x7b722
jmp 0x7b6f8
jmp 0x7b722
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x7b71b
jmp 0x7b722
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x40b0
jmp 0x7b716
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x40b0
jmp 0x7b725
movq %rax, %rbx
movq %rbx, %rdi
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/include/policies.hpp
// Function: RandomErase25<std::deque<Trivial<8>, std::allocator<Trivial<8>>>>::run(std::deque<Trivial<8>, std::allocator<Trivial<8>>>&, unsigned long)
inline static void run(Container &c, std::size_t /*size*/){
        auto it = c.begin();

        while(it != c.end()){
            if(distribution(generator) > 7500){
                it = c.erase(it);
            } else {
                ++it;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x18(%rdi), %rax
movq 0x10(%rdi), %rbp
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %r12
leaq 0xff019(%rip), %r14     # 0x17abf8
leaq 0xff02a(%rip), %r15     # 0x17ac10
movq %rdi, %rbx
movq %rax, (%rsp)
cmpq 0x30(%rbx), %rbp
je 0x7bc69
movq %r14, %rdi
movq %r15, %rsi
callq 0x267b6
cmpq $0x1d4d, %rax           # imm = 0x1D4D
jae 0x7bc25
addq $0x8, %rbp
cmpq %r13, %rbp
jne 0x7bbed
movq 0x8(%r12), %rbp
addq $0x8, %r12
leaq 0x200(%rbp), %r13
movq %rbp, (%rsp)
jmp 0x7bbed
movq (%rsp), %rax
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rbp, 0x8(%rsp)
movq %rbx, %rsi
movq %rax, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
callq 0x3d03c
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rbp
movq 0x38(%rsp), %r13
movq 0x40(%rsp), %r12
movq %rax, (%rsp)
jmp 0x7bbed
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list_update_1/bench.cpp
// Function: bench_erase_50<Trivial<8>>::run()
static void run(){
        new_graph<T>("erase50", "us");

        auto sizes = {10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000};
        bench<std::vector<T>, microseconds, FilledRandom, RandomErase50>("vector", sizes);
        bench<std::list<T>,   microseconds, FilledRandom, RandomErase50>("list",   sizes);
        bench<std::deque<T>,  microseconds, FilledRandom, RandomErase50>("deque",  sizes);
        bench<plf::colony<T>,  microseconds, FilledRandomInsert, RandomErase50>("colony",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0xaa41(%rip), %rsi      # 0x89c29
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x4080
leaq 0xa86c(%rip), %rsi      # 0x89a6a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7e73
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x40b0
vmovups 0xa355(%rip), %ymm0     # 0x89590
movabsq $0x186a000015f90, %rax  # imm = 0x186A000015F90
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0xa80b(%rip), %rsi      # 0x89a6d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7f36d
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0xa7e0(%rip), %rsi      # 0x89a74
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7f460
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0xa7b6(%rip), %rsi      # 0x89a79
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7f553
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0xa79c(%rip), %rsi      # 0x89a8e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7f646
leaq 0x10(%rsp), %rdi
callq 0x40b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x7f32c
jmp 0x7f356
jmp 0x7f32c
jmp 0x7f356
jmp 0x7f32c
jmp 0x7f356
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x7f34f
jmp 0x7f356
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x40b0
jmp 0x7f34a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x40b0
jmp 0x7f359
movq %rax, %rbx
movq %rbx, %rdi
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/include/policies.hpp
// Function: RandomErase50<std::deque<Trivial<8>, std::allocator<Trivial<8>>>>::run(std::deque<Trivial<8>, std::allocator<Trivial<8>>>&, unsigned long)
inline static void run(Container &c, std::size_t /*size*/){
        auto it = c.begin();

        while(it != c.end()){
            if(distribution(generator) > 5000){
                it = c.erase(it);
            } else {
                ++it;
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x18(%rdi), %rax
movq 0x10(%rdi), %rbp
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %r12
leaq 0x1228e5(%rip), %r14    # 0x1a20f8
leaq 0x1228f6(%rip), %r15    # 0x1a2110
movq %rdi, %rbx
movq %rax, (%rsp)
cmpq 0x30(%rbx), %rbp
je 0x7f89d
movq %r14, %rdi
movq %r15, %rsi
callq 0x267b6
cmpq $0x1389, %rax           # imm = 0x1389
jae 0x7f859
addq $0x8, %rbp
cmpq %r13, %rbp
jne 0x7f821
movq 0x8(%r12), %rbp
addq $0x8, %r12
leaq 0x200(%rbp), %r13
movq %rbp, (%rsp)
jmp 0x7f821
movq (%rsp), %rax
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rbp, 0x8(%rsp)
movq %rbx, %rsi
movq %rax, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
callq 0x3d03c
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rbp
movq 0x38(%rsp), %r13
movq 0x40(%rsp), %r12
movq %rax, (%rsp)
jmp 0x7f821
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list_update_1/bench.cpp
// Function: bench_find<Trivial<8>>::run()
static void run(){
        new_graph<T>("find", "us");

        auto sizes = {10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000};
        bench<std::vector<T>, microseconds, FilledRandom, Find>("vector", sizes);
        bench<std::list<T>,   microseconds, FilledRandom, Find>("list",   sizes);
        bench<std::deque<T>,  microseconds, FilledRandom, Find>("deque",  sizes);
        bench<plf::colony<T>, microseconds, FilledRandomInsert, Find>("colony",  sizes);
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x6e15(%rip), %rsi      # 0x89c31
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x4080
leaq 0x6c38(%rip), %rsi      # 0x89a6a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7e73
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x40b0
vmovups 0x6721(%rip), %ymm0     # 0x89590
movabsq $0x186a000015f90, %rax  # imm = 0x186A000015F90
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x6bd7(%rip), %rsi      # 0x89a6d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x260c5
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x6bac(%rip), %rsi      # 0x89a74
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x261b8
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x6b82(%rip), %rsi      # 0x89a79
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x262ab
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x6b68(%rip), %rsi      # 0x89a8e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2639e
leaq 0x10(%rsp), %rdi
callq 0x40b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x82f60
jmp 0x82f8a
jmp 0x82f60
jmp 0x82f8a
jmp 0x82f60
jmp 0x82f8a
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x82f83
jmp 0x82f8a
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x40b0
jmp 0x82f7e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x40b0
jmp 0x82f8d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/vector_list_update_1/bench.cpp
// Function: bench_number_crunching<Trivial<8>>::run()
static void run(){
        new_graph<T>("number_crunching", "ms");

        auto sizes = {10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000, 100000};
        bench<std::vector<T>, milliseconds, Empty, RandomSortedInsert>("vector", sizes);
        bench<std::list<T>,   milliseconds, Empty, RandomSortedInsert>("list",   sizes);
        bench<std::deque<T>,  milliseconds, Empty, RandomSortedInsert>("deque",  sizes);
        // colony is unordered
    }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x697c(%rip), %rsi      # 0x89c36
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x4080
leaq 0x68ed(%rip), %rsi      # 0x89bbd
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x7e73
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x40b0
vmovups 0x6283(%rip), %ymm0     # 0x89590
movabsq $0x186a000015f90, %rax  # imm = 0x186A000015F90
movq %rbx, 0x30(%rsp)
movq $0xa, 0x38(%rsp)
movq %rax, 0x20(%rbx)
vmovups %ymm0, (%rbx)
leaq 0x6739(%rip), %rsi      # 0x89a6d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
vzeroupper
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x83400
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x670e(%rip), %rsi      # 0x89a74
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x834f8
leaq 0x10(%rsp), %rdi
callq 0x40b0
leaq 0x66e4(%rip), %rsi      # 0x89a79
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4080
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x835ee
leaq 0x10(%rsp), %rdi
callq 0x40b0
addq $0x70, %rsp
popq %rbx
retq
jmp 0x833cb
jmp 0x833f5
jmp 0x833cb
jmp 0x833f5
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
jmp 0x833ee
jmp 0x833f5
leaq 0x10(%rsp), %rdi
movq %rax, %rbx
callq 0x40b0
jmp 0x833e9
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x40b0
jmp 0x833f8
movq %rax, %rbx
movq %rbx, %rdi
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/include/policies.hpp
// Function: RandomSortedInsert<std::vector<Trivial<8>, std::allocator<Trivial<8>>>>::run(std::vector<Trivial<8>, std::allocator<Trivial<8>>>&, unsigned long)
inline static void run(Container &c, std::size_t size){
        for(std::size_t i=0; i<size; ++i){
            auto val = distribution(generator);
            // hand written comparison to eliminate temporary object creation
            c.insert(std::find_if(begin(c), end(c), [&](decltype(*begin(c)) v){ return v.a >= val; }), {val});
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x143797(%rip), %r15    # 0x1c6ea8
leaq 0x1437a8(%rip), %r12    # 0x1c6ec0
leaq 0x8(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %rsi, %rbx
movq %rdi, %r14
subq $0x1, %rbx
jb 0x83767
movq %r15, %rdi
movq %r12, %rsi
callq 0x267b6
movq %rax, 0x8(%rsp)
movq %r13, %rdx
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x837ce
movq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %rbp, %rdx
movq %rcx, 0x10(%rsp)
callq 0x83776
jmp 0x83728
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/graphs.cpp
// Function: compute_values[abi:cxx11](std::shared_ptr<graphs::graph>)
std::unordered_map<std::string, std::unordered_map<std::string, std::size_t>> compute_values(std::shared_ptr<graphs::graph> graph){
    std::unordered_map<std::string, std::unordered_map<std::string, std::size_t>> results;

    for(auto& result : graph->results){
        results[result.group][result.serie] = result.value;
    }

    return results;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x30(%rdi), %rax
vxorps %xmm0, %xmm0, %xmm0
movq %rdi, %rbx
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
vmovups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
vmovups %xmm0, 0x28(%rdi)
movq (%rsi), %rax
movq 0x60(%rax), %r14
movq 0x68(%rax), %r15
cmpq %r15, %r14
je 0x84d69
movq 0x40(%r14), %r12
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x86388
addq $-0x20, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x867f6
movq %r12, (%rax)
addq $0x48, %r14
jmp 0x84d39
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %rax, %r14
callq 0x858e0
movq %r14, %rdi
callq 0x42c0
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Client.cpp
// Function: Dropbox::Client::askServerUpdates()
void Client::askServerUpdates() {
	
	int fd, wd;
	this->initializeInotify(&fd, &wd);
	
	while(1) {
		this->lockMutex();
		
		this->eventsInotify(&fd);
		
		inotify_rm_watch(fd, wd);
		close(fd);

		this->askUpdate();

		int fd, wd;
		this->initializeInotify(&fd, &wd);

		this->unlockMutex();
		this_thread::sleep_for(chrono::milliseconds(5000));
	}
	/* Clean up*/
	inotify_rm_watch(fd, wd);
	close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x2c(%rbp), %r12
leaq -0x44(%rbp), %r14
movq %r12, %rsi
movq %r14, %rdx
callq 0x4180
leaq 0x70(%rbx), %r15
movl (%r12), %r12d
movl (%r14), %r13d
leaq -0x38(%rbp), %r14
movq %r15, %rdi
callq 0x50d8
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x4212
movl %r12d, %edi
movl %r13d, %esi
callq 0x31a0
movl %r12d, %edi
callq 0x35a0
movq %rbx, %rdi
callq 0x4684
movq %rbx, %rdi
leaq -0x40(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x4180
movq %r15, %rdi
callq 0x3250
movq $0x1388, -0x38(%rbp)    # imm = 0x1388
movq %r14, %rdi
callq 0x50ee
jmp 0x4126
nop
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Client.cpp
// Function: Dropbox::Client::initializeInotify(int*, int*)
void Client::initializeInotify(int *fd, int *wd){
	/* Initialize Inotify*/
	*fd = inotify_init();
	if ( *fd < 0 ) {
		cout << "Couldn't initialize inotify" << endl;
	}
	/* add watch to starting directory */
	*wd = inotify_add_watch(*fd, syncDirPath.c_str(), IN_CLOSE_WRITE | IN_MOVED_FROM | IN_MOVED_TO); 

	if (*wd == -1){
		cout << "Couldn't add watch to " << syncDirPath.c_str() << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3560
movl %eax, (%r15)
testl %eax, %eax
jns 0x41bd
movq 0xce22(%rip), %rdi      # 0x10fc8
leaq 0x7eb2(%rip), %rsi      # 0xc05f
callq 0x3310
movq %rax, %rdi
callq 0x31c0
movl (%r15), %eax
movq 0x50(%rbx), %rsi
movl %eax, %edi
movl $0xc8, %edx
callq 0x3200
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x41e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xcde1(%rip), %rdi      # 0x10fc8
leaq 0x7e8d(%rip), %rsi      # 0xc07b
callq 0x3310
movq 0x50(%rbx), %rsi
movq %rax, %rdi
callq 0x3310
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Client.cpp
// Function: Dropbox::Client::createSyncDir()
void Client::createSyncDir(){
	struct stat st;
	if(stat(syncDirPath.c_str(), &st) == -1){ //Se não existe cria, se existe faz nada
		mkdir(syncDirPath.c_str(), 0777);
		cout << "Created Sync Dir on " + syncDirPath << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x32c0
cmpl $-0x1, %eax
jne 0x4b1d
addq $0x50, %rbx
movq (%rbx), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3190
leaq 0x75a4(%rip), %rsi      # 0xc092
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4fb3
movq 0xc4c4(%rip), %rdi      # 0x10fc8
movq %r14, %rsi
callq 0x32b0
movq %rax, %rdi
callq 0x31c0
leaq -0x30(%rbp), %rdi
callq 0x3170
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3540
nop
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Client.cpp
// Function: Dropbox::Client::removeFileRecord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Client::removeFileRecord(string filename) {
	vector<FileRecord>::iterator it;
	for(it = this->fileRecords.begin(); it != this->fileRecords.end(); it++) {
		if (string(it->filename) == filename) {
			this->fileRecords.erase(it);
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0xc0(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0xc0(%rdi), %r14
leaq -0x58(%rbp), %r13
cmpq 0xc8(%r12), %r14
je 0x4c0c
movq %r13, %rdi
movq %r14, %rsi
leaq -0x29(%rbp), %rdx
callq 0x3130
movq %r13, %rdi
movq %r15, %rsi
callq 0x52a9
movl %eax, %ebx
movq %r13, %rdi
callq 0x3170
testb %bl, %bl
jne 0x4c00
addq $0xe8, %r14
jmp 0x4bc5
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x52cc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Client.cpp
// Function: Dropbox::Client::updateFileRecord(Dropbox::_FileRecord)
void Client::updateFileRecord(FileRecord newFile) {
	vector<FileRecord>::iterator it;
	for(it = this->fileRecords.begin(); it != this->fileRecords.end(); it++) {
		if (string(it->filename) == string(newFile.filename)) {
			*it = newFile;
			return;
		}
	}
	this->fileRecords.push_back(newFile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r12
leaq 0xc0(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0xc0(%rdi), %r14
leaq -0x58(%rbp), %r13
leaq -0x78(%rbp), %rbx
cmpq 0xc8(%r12), %r14
je 0x4c9f
movq %r13, %rdi
movq %r14, %rsi
leaq -0x2a(%rbp), %rdx
callq 0x3130
movq %rbx, %rdi
leaq 0x10(%rbp), %rsi
leaq -0x29(%rbp), %rdx
callq 0x3130
movq %r13, %rdi
movq %rbx, %rsi
callq 0x52a9
movl %eax, %r15d
movq %rbx, %rdi
callq 0x3170
movq %r13, %rdi
callq 0x3170
testb %r15b, %r15b
jne 0x4cae
addq $0xe8, %r14
jmp 0x4c4a
movq -0x38(%rbp), %rdi
leaq 0x10(%rbp), %rsi
callq 0x530c
jmp 0x4cbf
movl $0xe8, %edx
movq %r14, %rdi
leaq 0x10(%rbp), %rsi
callq 0x3280
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3540
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Client.cpp
// Function: Dropbox::Client::download(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Client::download(string filename){
	MessageData request = make_packet(TYPE_REQUEST_DOWNLOAD, 1 , 1, -1, filename.c_str());
	this->socket->send(&request);

	char cCurrentPath[FILENAME_MAX];
	if (!getcwd(cCurrentPath, sizeof(cCurrentPath))) 
		cout << "ERROR GETTING THE CURRENT DIRECTORY!!" << endl;
	cCurrentPath[sizeof(cCurrentPath) - 1] = '\0';
	string currentPath(cCurrentPath);
	currentPath += "/";

	MessageData *data = this->socket->receive(TIMEOUT_OFF);
	if(data->type == TYPE_SEND_FILE) {
		FileRecord * fileRecord = (FileRecord *)(data->payload);
		this->receiveFile(this->socket, string(fileRecord->filename), currentPath);
	}
	else if(data->type == TYPE_NOTHING_TO_SEND)
		cout << "File does not exist." << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x2050, %rsp           # imm = 0x2050
movq %rdi, %rbx
movq (%rsi), %r9
leaq -0x2054(%rbp), %r14
pushq $0x8
popq %rsi
pushq $0x1
popq %rcx
pushq $-0x1
popq %r8
movq %r14, %rdi
movl %ecx, %edx
callq 0x57f0
movq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0xb850
leaq -0x1080(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x31d0
testq %rax, %rax
jne 0x4d4e
movq 0xc28e(%rip), %rdi      # 0x10fc8
leaq 0x7395(%rip), %rsi      # 0xc0d6
callq 0x3310
movq %rax, %rdi
callq 0x31c0
leaq -0x1080(%rbp), %rsi
movb $0x0, 0xfff(%rsi)
leaq -0x78(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x3130
leaq 0x7648(%rip), %rsi      # 0xc3bb
movq %r14, %rdi
callq 0x3570
movq 0x40(%rbx), %rdi
xorl %esi, %esi
callq 0xb9d4
movl (%rax), %ecx
cmpl $0x7, %ecx
je 0x4dde
cmpl $0x3, %ecx
jne 0x4df9
addq $0x14, %rax
movq 0x40(%rbx), %r14
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x3130
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x33d0
leaq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a7a
leaq -0x38(%rbp), %rdi
callq 0x3170
leaq -0x58(%rbp), %rdi
callq 0x3170
jmp 0x4df9
movq 0xc1e3(%rip), %rdi      # 0x10fc8
leaq 0x7310(%rip), %rsi      # 0xc0fc
callq 0x3310
movq %rax, %rdi
callq 0x31c0
leaq -0x78(%rbp), %rdi
callq 0x3170
addq $0x2050, %rsp           # imm = 0x2050
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0x4e1f
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3170
jmp 0x4e31
jmp 0x4e2e
jmp 0x4e2e
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3540
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Client.cpp
// Function: Dropbox::Client::requestServerFileList()
void Client::requestServerFileList() {

	MessageData packet = make_packet(TYPE_LIST_SERVER, 1, 1, -1, "list_server");
	socket->send(&packet);
	vector<FileRecord> files = this->receiveFileList(this->getSocket());
	this->printFileList(files);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq %rdi, %rbx
leaq 0x722c(%rip), %r9       # 0xc124
leaq -0x1014(%rbp), %r14
pushq $0x6
popq %rsi
pushq $0x1
popq %rcx
pushq $-0x1
popq %r8
movq %r14, %rdi
movl %ecx, %edx
callq 0x57f0
movq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0xb850
movq 0x40(%rbx), %rdx
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x66b4
leaq -0x28(%rbp), %rdi
movq %r14, %rsi
callq 0x514a
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x6742
leaq -0x28(%rbp), %rdi
callq 0x5508
leaq -0x40(%rbp), %rdi
callq 0x5508
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x5508
jmp 0x4f79
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x5508
movq %rbx, %rdi
callq 0x3540
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/FileRecord.cpp
// Function: Dropbox::make_record(char const*, long, long, long, int)
FileRecord Dropbox::make_record(const char *filename, time_t creationTime, time_t accessTime, time_t modificationTime, int size) {
    
    FileRecord fileRecord;
    strcpy(fileRecord.filename, filename);
    fileRecord.creationTime = creationTime;
    fileRecord.accessTime = accessTime;
    fileRecord.modificationTime = modificationTime;
    fileRecord.size = size;

    return fileRecord;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
callq 0x32e0
movq %r12, 0xc8(%r13)
movq %r15, 0xd0(%r13)
movq %r14, 0xd8(%r13)
movl %ebx, 0xe0(%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/MessageData.cpp
// Function: Dropbox::make_packet(int, int, int, int, char const*)
MessageData Dropbox::make_packet(int type, int seq, int totalSize, int len, const char *payload){
    MessageData data;
    data.type = type;
    data.seq = seq;
    data.totalSize = totalSize;
    data.len = len;
    data.socketSeq = -1;
    // File or record packets can't have \0 at the end of the payload
    if(type == TYPE_DATA || type == TYPE_SEND_FILE)
        memcpy(data.payload, payload, len);
    else
        strncpy(data.payload, payload, MESSAGE_LEN);

    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
orl $-0x1, 0x10(%rdi)
cmpl $0x3, %esi
je 0x5812
testl %esi, %esi
jne 0x5826
movq %rbx, %rdi
addq $0x14, %rdi
movslq %r8d, %rdx
movq %r9, %rsi
callq 0x3280
jmp 0x583a
movq %rbx, %rdi
addq $0x14, %rdi
movl $0xfa0, %edx            # imm = 0xFA0
movq %r9, %rsi
callq 0x31e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/MessageData.cpp
// Function: Dropbox::make_packet(int, int, int, int, char const*, char const*)
MessageData Dropbox::make_packet(int type, int seq, int totalSize, int len, const char *payload, const char *username){
    MessageData data;
    data.type = type;
    data.seq = seq;
    data.totalSize = totalSize;
    data.len = len;
    data.socketSeq = -1;
    // File or record packets can't have \0 at the end of the payload
    if(type == TYPE_DATA || type == TYPE_SEND_FILE)
        memcpy(data.payload, payload, len);
    else
        strncpy(data.payload, payload, MESSAGE_LEN);
    
    strncpy(data.username, username, 30);

    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rbp), %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
orl $-0x1, 0x10(%rdi)
cmpl $0x3, %esi
je 0x586b
testl %esi, %esi
jne 0x587c
leaq 0x14(%rbx), %rdi
movslq %r8d, %rdx
movq %r9, %rsi
callq 0x3280
jmp 0x588d
leaq 0x14(%rbx), %rdi
movl $0xfa0, %edx            # imm = 0xFA0
movq %r9, %rsi
callq 0x31e0
movq %rbx, %rdi
addq $0xfb4, %rdi            # imm = 0xFB4
pushq $0x1e
popq %rdx
movq %r14, %rsi
callq 0x31e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Operations.cpp
// Function: Dropbox::Operations::getFileList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<FileRecord> Operations::getFileList(string dirPath) {
    vector<FileRecord> files;
    struct stat filestatus;
    DIR *dir;
    struct dirent *ent;

    if ((dir = opendir (dirPath.c_str())) != NULL) {
        while ((ent = readdir (dir)) != NULL) {
            if(ent->d_type == 0x8) {
				stat((dirPath + ent->d_name).c_str(), &filestatus);
                FileRecord fileRecord = make_record(ent->d_name, filestatus.st_ctim.tv_sec, filestatus.st_atim.tv_sec, filestatus.st_mtim.tv_sec, filestatus.st_size);
				files.push_back(fileRecord);
            }
        }
        closedir(dir);
    }
    return files;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rdx), %rdi
callq 0x3450
testq %rax, %rax
je 0x5971
movq %rax, %r15
leaq -0x1a0(%rbp), %r12
movq %r15, %rdi
callq 0x3470
movq %rax, %r13
testq %rax, %rax
je 0x5969
cmpb $0x8, 0x12(%r13)
jne 0x58fa
addq $0x13, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x6c5b
movq -0x1a0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x32c0
movq %r12, %rdi
callq 0x3170
movq -0x50(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x60(%rbp), %r8
movl -0x88(%rbp), %r9d
movq %r12, %rdi
movq %r13, %rsi
callq 0x57a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x530c
jmp 0x58fa
movq %r15, %rdi
callq 0x34c0
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x598a
jmp 0x598a
movq %rax, %r14
movq %rbx, %rdi
callq 0x5508
movq %r14, %rdi
callq 0x3540
nop
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Operations.cpp
// Function: Dropbox::Operations::sendFileList(Dropbox::WrapperSocket*, std::vector<Dropbox::_FileRecord, std::allocator<Dropbox::_FileRecord>>)
void Operations::sendFileList(WrapperSocket *socket, vector<FileRecord> files){
    if(files.empty()){
        MessageData packet = make_packet(TYPE_NOTHING_TO_SEND, 1, 1, -1, "nothing_to_send");
        socket->send(&packet);
        return;
    }
    int seq = 1;
    for(FileRecord record : files) {
        MessageData packet = make_packet(TYPE_DATA, seq, files.size(), sizeof(FileRecord), (char*)&record);
        socket->send(&packet);
        seq++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10d8, %rsp           # imm = 0x10D8
movq %rsi, %r12
movq (%rdx), %r15
movq %rdx, -0x38(%rbp)
movq 0x8(%rdx), %rax
movq %rax, -0x40(%rbp)
cmpq %rax, %r15
je 0x5a3b
movq %r12, -0x30(%rbp)
pushq $0x1
popq %r12
movl $0xe8, %r13d
cmpq -0x40(%rbp), %r15
je 0x5a68
movl $0xe8, %edx
leaq -0x128(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3280
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
cqto
idivq %r13
leaq -0x10fc(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
movl %r12d, %edx
movl %eax, %ecx
movl $0xe8, %r8d
movq %rbx, %r9
callq 0x57f0
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0xb850
incl %r12d
addq %r13, %r15
jmp 0x59d7
leaq 0x6847(%rip), %r9       # 0xc289
leaq -0x10fc(%rbp), %rbx
pushq $0x7
popq %rsi
pushq $0x1
popq %rcx
pushq $-0x1
popq %r8
movq %rbx, %rdi
movl %ecx, %edx
callq 0x57f0
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb850
addq $0x10d8, %rsp           # imm = 0x10D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Operations.cpp
// Function: Dropbox::Operations::receiveFile(Dropbox::WrapperSocket*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Operations::receiveFile(WrapperSocket *socket, string filename, string dirPath) {
    string filePath = dirPath + filename;
		
    ofstream newFile;
		newFile.open(filePath, ofstream::trunc | ofstream::binary);
		if(!newFile.is_open()) {
			return;
    }
    int seqNumber, totalPackets;
    do{
        MessageData *packet = socket->receive(TIMEOUT_OFF);
        seqNumber = packet->seq;
        totalPackets = packet->totalSize;
        newFile.write(packet->payload, packet->len);
    }while(seqNumber != totalPackets);
    
    newFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %rbx
leaq -0x40(%rbp), %rdi
movq %rcx, %rsi
callq 0x5352
leaq -0x240(%rbp), %rdi
callq 0x34f0
leaq -0x240(%rbp), %rdi
leaq -0x40(%rbp), %rsi
pushq $0x24
popq %rdx
callq 0x31b0
leaq -0x1d0(%rbp), %rdi
callq 0x30a0
testb %al, %al
je 0x5b07
leaq -0x240(%rbp), %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb9d4
movl 0x4(%rax), %r15d
movl 0x8(%rax), %r12d
movq %rax, %rsi
addq $0x14, %rsi
movslq 0xc(%rax), %rdx
movq %r14, %rdi
callq 0x33b0
cmpl %r12d, %r15d
jne 0x5ad1
leaq -0x240(%rbp), %rdi
callq 0x33e0
leaq -0x240(%rbp), %rdi
callq 0x3440
leaq -0x40(%rbp), %rdi
callq 0x3170
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b35
jmp 0x5b35
movq %rax, %rbx
jmp 0x5b44
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x3440
leaq -0x40(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3540
nop
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Operations.cpp
// Function: Dropbox::Operations::receiveFileList(Dropbox::WrapperSocket*)
vector<FileRecord> Operations::receiveFileList(WrapperSocket * socket) {
	MessageData *unconvertedFiles;
	FileRecord record;
	vector<FileRecord> files;
	do {
		unconvertedFiles = socket->receive(TIMEOUT_OFF);
		if(unconvertedFiles->type == TYPE_NOTHING_TO_SEND) break;
		record = *((FileRecord*)unconvertedFiles->payload);
		files.push_back(record);
	} while(unconvertedFiles->seq != unconvertedFiles->totalSize);
	return files;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x108(%rbp), %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0xb9d4
movq %rax, %r12
cmpl $0x7, (%rax)
je 0x671b
movq %r12, %rsi
addq $0x14, %rsi
movl $0xe8, %edx
movq %r15, %rdi
callq 0x3280
movq %rbx, %rdi
movq %r15, %rsi
callq 0x530c
movl 0x4(%r12), %eax
cmpl 0x8(%r12), %eax
jne 0x66de
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5508
movq %r14, %rdi
callq 0x3540
nop
// File: /workspace/github_cpp_makefile_star2_O2/vianna274[P]dropbox/src/Operations.cpp
// Function: Dropbox::Operations::receiveUploadAll(Dropbox::WrapperSocket*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Operations::receiveUploadAll(WrapperSocket * socket, string dirPath) {
	while(1) {
		MessageData * packet = socket->receive(TIMEOUT_OFF);
		if (packet->type == TYPE_SEND_UPLOAD_ALL_DONE ||
			packet->type == TYPE_NOTHING_TO_SEND)
			break;
		this->receiveFile(socket, string(packet->payload), dirPath);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x70(%rbp), %r15
leaq -0x29(%rbp), %r12
leaq -0x50(%rbp), %r13
movq %r14, %rdi
xorl %esi, %esi
callq 0xb9d4
movl (%rax), %ecx
cmpl $0x7, %ecx
je 0x68ae
cmpl $0xa, %ecx
je 0x68ae
addq $0x14, %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x3130
movq %r13, %rdi
movq %rbx, %rsi
callq 0x33d0
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x5a7a
movq %r13, %rdi
callq 0x3170
movq %r15, %rdi
callq 0x3170
jmp 0x685b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0x68ce
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3540
nop