LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wichtounet[P]articles/plf_colony_alpha/plf_timsort.h
// Function: plf::TimSort<Trivial<8>**, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::sort_dereferencer<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::less>>::minRunLength(long)
static diff_t minRunLength(diff_t n)
	{
		assert(n >= 0);
		diff_t r = 0;
		
		while (n >= MIN_MERGE)
		{
			r |= (n & 1);
			n >>= 1;
		}
		
		return n + r;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
cmpq $0x20, -0x8(%rsp)
jl 0xe5af8
movq -0x8(%rsp), %rax
andq $0x1, %rax
orq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
sarq %rax
movq %rax, -0x8(%rsp)
jmp 0xe5ace
movq -0x8(%rsp), %rax
addq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_timsort.h
// Function: plf::TimSort<Trivial<8>**, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::sort_dereferencer<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::less>>::mergeCollapse()
void mergeCollapse()
	{
		while (pending_.size() > 1)
		{
			diff_t n = pending_.size() - 2;

			if ((n > 0 && pending_[n - 1].len <= pending_[n].len + pending_[n + 1].len) || (n > 1 && pending_[n - 2].len <= pending_[n - 1].len + pending_[n].len))
			{
				if (pending_[n - 1].len < pending_[n + 1].len)
				{
					--n;
				}
				
				mergeAt(n);
			}
			else if (pending_[n].len <= pending_[n + 1].len)
			{
				mergeAt(n);
			}
			else
			{
				break;
			}
		}
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
callq 0xe68a0
cmpq $0x1, %rax
jbe 0xe5d45
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
callq 0xe68a0
subq $0x2, %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jle 0xe5c13
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
subq $0x1, %rsi
callq 0xe6c00
movq 0x30(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
callq 0xe6c00
movq 0x30(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
addq $0x1, %rsi
callq 0xe6c00
movq 0x20(%rsp), %rcx
movq %rax, %rdx
movq 0x28(%rsp), %rax
addq 0x8(%rdx), %rcx
cmpq %rcx, %rax
jle 0xe5c88
cmpq $0x1, 0x38(%rsp)
jle 0xe5cec
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
subq $0x2, %rsi
callq 0xe6c00
movq 0x30(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
subq $0x1, %rsi
callq 0xe6c00
movq 0x30(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
callq 0xe6c00
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x18(%rsp), %rax
addq 0x8(%rdx), %rcx
cmpq %rcx, %rax
jg 0xe5cec
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
subq $0x1, %rsi
callq 0xe6c00
movq 0x30(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
addq $0x1, %rsi
callq 0xe6c00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq 0x8(%rcx), %rax
jge 0xe5cdb
movq 0x38(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xe6c20
jmp 0xe5d40
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
callq 0xe6c00
movq 0x30(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, (%rsp)
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
addq $0x1, %rsi
callq 0xe6c00
movq %rax, %rcx
movq (%rsp), %rax
cmpq 0x8(%rcx), %rax
jg 0xe5d3c
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xe6c20
jmp 0xe5d3e
jmp 0xe5d45
jmp 0xe5d40
jmp 0xe5b73
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: wichtounet[P]articles/plf_colony_alpha/plf_timsort.h
// Function: plf::TimSort<Trivial<8>**, plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::sort_dereferencer<plf::colony<Trivial<8>, std::allocator<Trivial<8>>, unsigned short>::less>>::mergeForceCollapse()
void mergeForceCollapse()
	{
		while (pending_.size() > 1)
		{
			diff_t n = pending_.size() - 2;

			if (n > 0 && pending_[n - 1].len < pending_[n + 1].len)
			{
				--n;
			}
			
			mergeAt(n);
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xe68a0
cmpq $0x1, %rax
jbe 0xe5e01
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xe68a0
subq $0x2, %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jle 0xe5ded
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
subq $0x1, %rsi
callq 0xe6c00
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
addq $0x1, %rsi
callq 0xe6c00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq 0x8(%rcx), %rax
jge 0xe5ded
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe6c20
jmp 0xe5d63
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movw %dx, %ax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movw %ax, 0x26(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rax
movzwl 0x26(%rsp), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
movq 0x8(%rdi), %rsi
movq %rsi, %rax
addq $0x28, %rax
movq %rax, 0x8(%rdi)
movq 0x28(%rsp), %rdx
callq 0x39250
jmp 0x149276
jmp 0x149300
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x50b0
movq (%rsp), %rax
movq 0x8(%rax), %rdx
addq $-0x28, %rdx
movq %rdx, 0x8(%rax)
movq (%rax), %rcx
movq %rdx, (%rcx)
movl 0x8(%rax), %ecx
movq (%rax), %rdx
movl 0x10(%rdx), %edx
subl %edx, %ecx
shrl $0x3, %ecx
imull $0xffffcccd, %ecx, %ecx # imm = 0xFFFFCCCD
movw %cx, 0xa(%rsp)
movw 0xa(%rsp), %dx
movq (%rax), %rcx
movw %dx, 0x30(%rcx)
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movzwl 0xa(%rsp), %edx
leaq (%rcx,%rdx,2), %rcx
movq %rcx, 0x10(%rax)
callq 0x52d0
jmp 0x149346
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0x5350
jmp 0x1492fe
jmp 0x149334
jmp 0x149302
movq (%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x149257
movq (%rsp), %rax
movq 0x8(%rax), %rdx
movq (%rax), %rcx
movq %rdx, (%rcx)
movw 0x26(%rsp), %cx
movq (%rax), %rax
movw %cx, 0x30(%rax)
addq $0x38, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x5360
movq %rax, %rdi
callq 0x14670
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movw %si, %ax
movq %rdi, 0x40(%rsp)
movw %ax, 0x3e(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rax, %rdi
addq $0x42, %rdi
movq %rdi, 0x10(%rsp)
movq (%rax), %rdx
movl $0x1, %esi
callq 0x16f80
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
movq %rax, 0x8(%rdx)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x3e(%rsp), %rdx
callq 0x139e50
jmp 0x139d9b
jmp 0x139e11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
callq 0x50b0
movq 0x18(%rsp), %rdi
addq $0x42, %rdi
movq %rdi, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x177b0
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl $0x1, %edx
callq 0x16ff0
jmp 0x139de3
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
callq 0x52d0
jmp 0x139e42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x5350
jmp 0x139e0f
jmp 0x139e30
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5360
movq %rax, %rdi
callq 0x14670
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: RandomErase1<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*/){
        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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14410
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14290
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6b7b0
testb $0x1, %al
jne 0x1505e1
jmp 0x150642
leaq 0xf2520(%rip), %rdi     # 0x242b08
leaq 0xf2531(%rip), %rsi     # 0x242b20
callq 0x6b780
cmpq $0x26ac, %rax           # imm = 0x26AC
jbe 0x150633
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5ed30
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xab1f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x15063d
leaq 0x20(%rsp), %rdi
callq 0x6bab0
jmp 0x1505bd
movq 0x30(%rsp), %rdi
callq 0x14550
movq %rax, %rsi
movq 0x9f982(%rip), %rdi     # 0x1effd8
callq 0x5080
movq %rax, %rdi
movq 0x9f95b(%rip), %rsi     # 0x1effc0
callq 0x5230
addq $0x38, %rsp
retq
nop
// File: wichtounet[P]articles/include/policies.hpp
// Function: RandomErase10<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*/){
        auto it = c.begin();

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14410
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14290
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6b7b0
testb $0x1, %al
jne 0x158be1
jmp 0x158c42
leaq 0x111420(%rip), %rdi    # 0x26a008
leaq 0x111431(%rip), %rsi    # 0x26a020
callq 0x6b780
cmpq $0x2328, %rax           # imm = 0x2328
jbe 0x158c33
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5ed30
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xab1f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x158c3d
leaq 0x20(%rsp), %rdi
callq 0x6bab0
jmp 0x158bbd
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: RandomErase25<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*/){
        auto it = c.begin();

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14410
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14290
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6b7b0
testb $0x1, %al
jne 0x160a61
jmp 0x160ac2
leaq 0x130aa0(%rip), %rdi    # 0x291508
leaq 0x130ab1(%rip), %rsi    # 0x291520
callq 0x6b780
cmpq $0x1d4c, %rax           # imm = 0x1D4C
jbe 0x160ab3
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5ed30
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xab1f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x160abd
leaq 0x20(%rsp), %rdi
callq 0x6bab0
jmp 0x160a3d
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: wichtounet[P]articles/include/policies.hpp
// Function: RandomErase50<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*/){
        auto it = c.begin();

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14410
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x14290
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6b7b0
testb $0x1, %al
jne 0x1688e1
jmp 0x168942
leaq 0x150120(%rip), %rdi    # 0x2b8a08
leaq 0x150131(%rip), %rsi    # 0x2b8a20
callq 0x6b780
cmpq $0x1388, %rax           # imm = 0x1388
jbe 0x168933
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5ed30
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xab1f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x16893d
leaq 0x20(%rsp), %rdi
callq 0x6bab0
jmp 0x1688bd
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
jae 0x1710ff
leaq 0x16eeaa(%rip), %rdi    # 0x2dff08
leaq 0x16eebb(%rip), %rsi    # 0x2dff20
callq 0x6b780
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x5ed00
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
callq 0x6b320
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x171150
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5ed30
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x171110
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x171047
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x78, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x1766b0
movq 0x28(%rsp), %rdi
callq 0x176640
addq $0x60, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x1766c0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x1766f0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x176720
testb $0x1, %al
jne 0x174b50
jmp 0x174bc9
leaq 0x50(%rsp), %rdi
callq 0x176760
movq 0x18(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq 0x40(%rsi), %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rsi
callq 0x176770
movq %rax, 0x10(%rsp)
jmp 0x174b82
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1767a0
movq %rax, (%rsp)
jmp 0x174b97
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x50(%rsp), %rdi
callq 0x1767d0
jmp 0x174b3b
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x1767f0
jmp 0x174be9
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x174bdf
movq 0x18(%rsp), %rdi
callq 0x1767f0
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x5360
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0x4a80
movq -0x30(%rbp), %rdi
callq 0x6ab0
movq -0x30(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x4b50
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x31e0
movl -0xc(%rbp), %edi
callq 0x3670
movq -0x30(%rbp), %rdi
callq 0x5420
movq -0x30(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x4a80
movq -0x30(%rbp), %rdi
callq 0x6ad0
movl $0x1388, -0x24(%rbp)    # imm = 0x1388
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x6ba0
leaq -0x20(%rbp), %rdi
callq 0x6af0
jmp 0x4a11
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x3640
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x4ad4
movq 0x1e50f(%rip), %rdi     # 0x22fc8
leaq 0x1459f(%rip), %rsi     # 0x1905f
callq 0x33a0
movq %rax, %rdi
movq 0x1e4e1(%rip), %rsi     # 0x22fb0
callq 0x33d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
addq $0x50, %rdi
callq 0x3180
movl -0x24(%rbp), %edi
movq %rax, %rsi
movl $0xc8, %edx
callq 0x3230
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x4b4a
movq 0x1e4b6(%rip), %rdi     # 0x22fc8
leaq 0x14562(%rip), %rsi     # 0x1907b
callq 0x33a0
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x50, %rdi
callq 0x3180
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x33a0
movq %rax, %rdi
movq 0x1e46b(%rip), %rsi     # 0x22fb0
callq 0x33d0
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
addq $0x50, %rdi
callq 0x3180
movq %rax, %rdi
leaq -0x98(%rbp), %rsi
callq 0x3340
cmpl $-0x1, %eax
jne 0x5def
movq -0xd0(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3180
movq %rax, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x31d0
movq -0xe8(%rbp), %rdx
leaq 0x13315(%rip), %rsi     # 0x19092
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x6780
movq -0xe0(%rbp), %rsi
movq 0x1d22a(%rip), %rdi     # 0x22fc8
callq 0x3330
movq %rax, -0xd8(%rbp)
jmp 0x5dac
movq -0xd8(%rbp), %rdi
movq 0x1d1f6(%rip), %rsi     # 0x22fb0
callq 0x33d0
jmp 0x5dc1
leaq -0xb8(%rbp), %rdi
callq 0x3280
jmp 0x5def
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x3280
jmp 0x5df8
addq $0xf0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x3610
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6f20
movq -0x80(%rbp), %rdi
addq $0xc0, %rdi
callq 0x6f40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x80(%rbp), %rdi
addq $0xc0, %rdi
callq 0x6fb0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6f70
testb $0x1, %al
jne 0x5f01
jmp 0x5fcf
leaq -0x18(%rbp), %rdi
callq 0x7070
movq %rax, -0x98(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3620
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3480
jmp 0x5f3a
movq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x6fe0
movb %al, -0x99(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3280
leaq -0x49(%rbp), %rdi
callq 0x33e0
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x5f6e
jmp 0x5fb9
movq -0x80(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0xa8(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7100
movq -0xa8(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x7090
movq %rax, -0x70(%rbp)
jmp 0x5fcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x33e0
jmp 0x5fd8
jmp 0x5fbb
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x7140
movq %rax, -0x78(%rbp)
jmp 0x5ed7
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3610
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6f20
movq -0x90(%rbp), %rdi
addq $0xc0, %rdi
callq 0x6f40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x90(%rbp), %rdi
addq $0xc0, %rdi
callq 0x6fb0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6f70
testb $0x1, %al
jne 0x606a
jmp 0x617e
leaq -0x10(%rbp), %rdi
callq 0x7070
movq %rax, -0xa8(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3620
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x3480
jmp 0x60a3
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3620
movq -0x98(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x3480
jmp 0x60cc
leaq -0x40(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6fe0
movb %al, -0xb1(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3280
leaq -0x79(%rbp), %rdi
callq 0x33e0
leaq -0x40(%rbp), %rdi
callq 0x3280
leaq -0x41(%rbp), %rdi
callq 0x33e0
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x610f
jmp 0x6165
leaq -0x10(%rbp), %rdi
callq 0x7180
movq -0x98(%rbp), %rsi
movq %rax, %rdi
movl $0xe8, %edx
callq 0x3300
jmp 0x6198
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x615a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x79(%rbp), %rdi
callq 0x33e0
leaq -0x40(%rbp), %rdi
callq 0x3280
leaq -0x41(%rbp), %rdi
callq 0x33e0
jmp 0x61a1
jmp 0x6167
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x7140
movq %rax, -0x88(%rbp)
jmp 0x603d
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
addq $0xc0, %rdi
callq 0x71a0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3610
nopw (%rax,%rax)
// File: 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
subq $0x1040, %rsp           # imm = 0x1040
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1030(%rbp)
leaq 0x12b83(%rip), %r9      # 0x19124
leaq -0xfdc(%rbp), %rdi
movq %rdi, -0x1038(%rbp)
movl $0x6, %esi
movl $0x1, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl %ecx, %edx
callq 0x97a0
movq -0x1038(%rbp), %rsi
movq -0x1030(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x17d90
movq -0x1030(%rbp), %rdi
callq 0x7290
movq -0x1030(%rbp), %rsi
movq %rax, %rdx
leaq -0xff8(%rbp), %rdi
movq %rdi, -0x1028(%rbp)
callq 0xb200
movq -0x1028(%rbp), %rsi
leaq -0x1010(%rbp), %rdi
callq 0x6bc0
jmp 0x661b
movq -0x1030(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
callq 0xb310
jmp 0x6630
leaq -0x1010(%rbp), %rdi
callq 0x6a00
leaq -0xff8(%rbp), %rdi
callq 0x6a00
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1018(%rbp)
movl %eax, -0x101c(%rbp)
jmp 0x6683
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1018(%rbp)
movl %eax, -0x101c(%rbp)
leaq -0x1010(%rbp), %rdi
callq 0x6a00
leaq -0xff8(%rbp), %rdi
callq 0x6a00
movq -0x1018(%rbp), %rdi
callq 0x3610
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rsi
callq 0x3360
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0xc8(%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0xd0(%rdi)
movq -0x20(%rbp), %rcx
movq %rcx, 0xd8(%rdi)
movl -0x24(%rbp), %ecx
movl %ecx, 0xe0(%rdi)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movq %r9, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, (%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x4(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0xc(%rdi)
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
cmpl $0x0, -0x4(%rbp)
je 0x97ee
cmpl $0x3, -0x4(%rbp)
jne 0x9805
movq -0x28(%rbp), %rdi
addq $0x14, %rdi
movq -0x18(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x3300
jmp 0x981b
movq -0x28(%rbp), %rdi
addq $0x14, %rdi
movq -0x18(%rbp), %rsi
movl $0xfa0, %edx            # imm = 0xFA0
callq 0x3210
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rbp), %rax
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %r8d, -0x10(%rbp)
movq %r9, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, (%rdi)
movl -0x8(%rbp), %eax
movl %eax, 0x4(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x8(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0xc(%rdi)
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
cmpl $0x0, -0x4(%rbp)
je 0x9882
cmpl $0x3, -0x4(%rbp)
jne 0x9899
movq -0x28(%rbp), %rdi
addq $0x14, %rdi
movq -0x18(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x3300
jmp 0x98af
movq -0x28(%rbp), %rdi
addq $0x14, %rdi
movq -0x18(%rbp), %rsi
movl $0xfa0, %edx            # imm = 0xFA0
callq 0x3210
movq -0x28(%rbp), %rdi
addq $0xfb4, %rdi            # imm = 0xFB4
movq 0x10(%rbp), %rsi
movl $0x1e, %edx
callq 0x3210
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x210, %rsp            # imm = 0x210
movq %rdx, -0x1e8(%rbp)
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x68b0
movq -0x1e8(%rbp), %rdi
callq 0x3180
movq %rax, %rdi
callq 0x3520
movq %rax, -0x1e0(%rbp)
jmp 0x9965
movq -0x1e0(%rbp), %rax
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
je 0x9a83
jmp 0x997f
movq -0xb8(%rbp), %rdi
callq 0x3540
movq %rax, -0x200(%rbp)
jmp 0x9994
movq -0x200(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, %rax
je 0x9a73
movq -0xc0(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x8, %eax
jne 0x9a6e
movq -0x1e8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
addq $0x13, %rdx
leaq -0xf0(%rbp), %rdi
callq 0xbb80
jmp 0x99e0
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0x3180
movq %rax, %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3340
movq -0x208(%rbp), %rdi
callq 0x3280
movq -0xc0(%rbp), %rsi
addq $0x13, %rsi
movq -0x48(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq -0x58(%rbp), %r8
movl -0x80(%rbp), %r9d
leaq -0x1d8(%rbp), %rdi
callq 0x9730
jmp 0x9a37
movq -0x1f8(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x71a0
jmp 0x9a4c
jmp 0x9a6e
movq -0x1f8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
callq 0x6a00
jmp 0x9aa9
jmp 0x997f
movq -0xb8(%rbp), %rdi
callq 0x3580
jmp 0x9a81
jmp 0x9a83
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x9a99
movq -0x1f8(%rbp), %rdi
callq 0x6a00
movq -0x1f0(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x3610
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20e0, %rsp           # imm = 0x20E0
movq %rdx, -0x20d8(%rbp)
movq %rdi, %rax
movq -0x20d8(%rbp), %rdi
movq %rdi, -0x20d0(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0xbc00
testb $0x1, %al
jne 0x9afa
jmp 0x9b34
leaq -0xfec(%rbp), %rdi
movl $0x7, %esi
movl $0x1, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
leaq 0xf771(%rip), %r9       # 0x19289
movl %ecx, %edx
callq 0x97a0
movq -0x10(%rbp), %rdi
leaq -0xfec(%rbp), %rsi
callq 0x17d90
jmp 0x9c19
movq -0x20d0(%rbp), %rax
movl $0x1, -0xff0(%rbp)
movq %rax, -0xff8(%rbp)
movq -0xff8(%rbp), %rdi
callq 0x6f40
movq %rax, -0x1000(%rbp)
movq -0xff8(%rbp), %rdi
callq 0x6fb0
movq %rax, -0x1008(%rbp)
leaq -0x1000(%rbp), %rdi
leaq -0x1008(%rbp), %rsi
callq 0x6f70
testb $0x1, %al
jne 0x9b8e
jmp 0x9c19
leaq -0x1000(%rbp), %rdi
callq 0x7180
movq %rax, %rsi
leaq -0x10f0(%rbp), %rdi
movl $0xe8, %edx
callq 0x3300
movq -0x20d0(%rbp), %rdi
movl -0xff0(%rbp), %eax
movl %eax, -0x20dc(%rbp)
callq 0x8470
movl -0x20dc(%rbp), %edx
movl %eax, %ecx
leaq -0x20c4(%rbp), %rdi
xorl %esi, %esi
movl $0xe8, %r8d
leaq -0x10f0(%rbp), %r9
callq 0x97a0
movq -0x10(%rbp), %rdi
leaq -0x20c4(%rbp), %rsi
callq 0x17d90
movl -0xff0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xff0(%rbp)
leaq -0x1000(%rbp), %rdi
callq 0x72e0
jmp 0x9b72
addq $0x20e0, %rsp           # imm = 0x20E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x280, %rsp            # imm = 0x280
movq %rcx, -0x268(%rbp)
movq %rsi, %rax
movq -0x268(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7210
leaq -0x240(%rbp), %rdi
callq 0x35b0
jmp 0x9c73
movl $0x20, %edi
movl $0x4, %esi
callq 0xbc40
movl %eax, -0x26c(%rbp)
jmp 0x9c8a
movl -0x26c(%rbp), %edx
leaq -0x240(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x31f0
jmp 0x9ca2
leaq -0x240(%rbp), %rdi
callq 0x32e0
movb %al, -0x26d(%rbp)
jmp 0x9cb6
movb -0x26d(%rbp), %al
testb $0x1, %al
jne 0x9d0b
jmp 0x9cc2
movl $0x1, -0x250(%rbp)
jmp 0x9d97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x9db5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x3500
jmp 0x9db5
jmp 0x9d0d
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x18090
movq %rax, -0x278(%rbp)
jmp 0x9d21
movq -0x278(%rbp), %rax
movq %rax, -0x260(%rbp)
movq -0x260(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x254(%rbp)
movq -0x260(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x258(%rbp)
movq -0x260(%rbp), %rax
movq %rax, %rsi
addq $0x14, %rsi
movslq 0xc(%rax), %rdx
leaq -0x240(%rbp), %rdi
callq 0x3460
jmp 0x9d6f
jmp 0x9d71
movl -0x254(%rbp), %eax
cmpl -0x258(%rbp), %eax
jne 0x9d0d
leaq -0x240(%rbp), %rdi
callq 0x34a0
jmp 0x9d8d
movl $0x0, -0x250(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x3500
leaq -0x40(%rbp), %rdi
callq 0x3280
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x3280
movq -0x248(%rbp), %rdi
callq 0x3610
nopw (%rax,%rax)
// File: 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
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x109(%rbp)
callq 0x68b0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x18090
movq %rax, -0x138(%rbp)
jmp 0xb248
movq -0x138(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x7, (%rax)
jne 0xb27e
jmp 0xb2c9
movq -0x130(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
callq 0x6a00
jmp 0xb2f5
movq -0x20(%rbp), %rsi
addq $0x14, %rsi
leaq -0x108(%rbp), %rdi
movq %rdi, -0x140(%rbp)
movl $0xe8, %edx
callq 0x3300
movq -0x130(%rbp), %rdi
movq -0x140(%rbp), %rsi
callq 0x71a0
jmp 0xb2b3
jmp 0xb2b5
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0xb234
movb $0x1, -0x109(%rbp)
testb $0x1, -0x109(%rbp)
jne 0xb2e5
movq -0x130(%rbp), %rdi
callq 0x6a00
movq -0x128(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0x3610
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x18090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xa, (%rax)
je 0xb4c7
movq -0x20(%rbp), %rax
cmpl $0x7, (%rax)
jne 0xb4cc
jmp 0xb5a0
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
addq $0x14, %rax
movq %rax, -0x98(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3620
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x3480
jmp 0xb50f
movq -0x88(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x3190
jmp 0xb521
movq -0xa0(%rbp), %rsi
movq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rdx
leaq -0x78(%rbp), %rcx
callq 0x9c30
jmp 0xb53b
leaq -0x78(%rbp), %rdi
callq 0x3280
leaq -0x40(%rbp), %rdi
callq 0x3280
leaq -0x41(%rbp), %rdi
callq 0x33e0
jmp 0xb4a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xb595
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xb58c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3280
leaq -0x40(%rbp), %rdi
callq 0x3280
leaq -0x41(%rbp), %rdi
callq 0x33e0
jmp 0xb5a9
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3610
nopw %cs:(%rax,%rax)
// File: vianna274[P]dropbox/src/Server.cpp
// Function: Dropbox::Server::makeConnection()
void Server::makeConnection(){
    MessageData packet = make_packet(TYPE_MAKE_BACKUP, 1, 1, -1, ipLocal.c_str());
    talkToPrimaryMtx.lock();
    talkToPrimary->send(&packet);
    talkToPrimaryMtx.unlock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xff0, %rsp            # imm = 0xFF0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xfe8(%rbp)
addq $0x9b8, %rdi            # imm = 0x9B8
callq 0x3180
movq %rax, %r9
leaq -0xfdc(%rbp), %rdi
movl $0x10, %esi
movl $0x1, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl %ecx, %edx
callq 0x97a0
movq -0xfe8(%rbp), %rdi
addq $0xc0, %rdi
callq 0x6a60
movq -0xfe8(%rbp), %rax
movq 0x178(%rax), %rdi
leaq -0xfdc(%rbp), %rsi
callq 0x17d90
movq -0xfe8(%rbp), %rdi
addq $0xc0, %rdi
callq 0x6a90
addq $0xff0, %rsp            # imm = 0xFF0
popq %rbp
retq
// File: vianna274[P]dropbox/src/Server.cpp
// Function: Dropbox::Server::removeFromBackup(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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Server::removeFromBackup(vector<string> backups, string main) {
    vector<string>::iterator it = backups.begin();
    vector<string> newBackups;
    for(it; it != backups.end(); it++) {
        if (main.compare(*it) == 0) {
            // it = backups.erase(it);
        } else {
            newBackups.push_back(*it);
        }
    }
    this->backups.clear();
    for(string backup: newBackups) {
        this->backups.push_back(backup);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, %rax
movq -0xb0(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq %rdx, -0xa0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x11ec0
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11880
movq -0xa8(%rbp), %rdi
callq 0x11f30
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11ef0
testb $0x1, %al
jne 0xe206
jmp 0xe273
leaq -0x20(%rbp), %rdi
callq 0x11f60
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x3050
movl %eax, -0xb4(%rbp)
jmp 0xe226
movl -0xb4(%rbp), %eax
cmpl $0x0, %eax
jne 0xe244
jmp 0xe25d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xe334
leaq -0x20(%rbp), %rdi
callq 0x11f60
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x11f80
jmp 0xe25b
jmp 0xe25d
jmp 0xe25f
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x11ff0
movq %rax, -0x58(%rbp)
jmp 0xe1e3
movq -0x98(%rbp), %rdi
addq $0x970, %rdi            # imm = 0x970
callq 0x12030
leaq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x11ec0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x11f30
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x11ef0
testb $0x1, %al
jne 0xe2bb
jmp 0xe322
leaq -0x68(%rbp), %rdi
callq 0x11f60
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x3190
jmp 0xe2d5
movq -0x98(%rbp), %rdi
addq $0x970, %rdi            # imm = 0x970
leaq -0x90(%rbp), %rsi
callq 0x11f80
jmp 0xe2f1
leaq -0x90(%rbp), %rdi
callq 0x3280
leaq -0x68(%rbp), %rdi
callq 0x12050
jmp 0xe2a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3280
jmp 0xe334
leaq -0x38(%rbp), %rdi
callq 0x11a00
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x11a00
movq -0x48(%rbp), %rdi
callq 0x3610
nopw %cs:(%rax,%rax)
// File: vianna274[P]dropbox/src/Server.cpp
// Function: Dropbox::Server::propagateNewBoss()
void Server::propagateNewBoss() {
    for (string ip : this->usersIp) {
        WrapperSocket userSocket(ip, 10000);
        MessageData packet = make_packet(TYPE_NEW_BOSS, 1, 1, -1, this->ipLocal.c_str());
        userSocket.send(&packet);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10a0, %rsp           # imm = 0x10A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1090(%rbp)
addq $0x988, %rax            # imm = 0x988
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11ec0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11f30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11ef0
testb $0x1, %al
jne 0xe4c4
jmp 0xe5e6
leaq -0x18(%rbp), %rdi
callq 0x11f60
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x1098(%rbp)
callq 0x3190
movq -0x1098(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x3190
jmp 0xe4f5
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
movl $0x2710, %edx           # imm = 0x2710
callq 0x17690
jmp 0xe50f
leaq -0xa8(%rbp), %rdi
callq 0x3280
movq -0x1090(%rbp), %rdi
addq $0x9b8, %rdi            # imm = 0x9B8
callq 0x3180
movq %rax, %r9
leaq -0x1088(%rbp), %rdi
movl $0x13, %esi
movl $0x1, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movl %ecx, %edx
callq 0x97a0
jmp 0xe551
leaq -0x88(%rbp), %rdi
leaq -0x1088(%rbp), %rsi
callq 0x17d90
jmp 0xe566
leaq -0x88(%rbp), %rdi
callq 0x17770
leaq -0x40(%rbp), %rdi
callq 0x3280
leaq -0x18(%rbp), %rdi
callq 0x12050
jmp 0xe4ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0xe5db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3280
jmp 0xe5db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x17770
leaq -0x40(%rbp), %rdi
callq 0x3280
jmp 0xe5ef
addq $0x10a0, %rsp           # imm = 0x10A0
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x3610
nopl (%rax,%rax)