LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned long long>::resize(unsigned int, unsigned long long const&)
void vector<unsigned long long int>::resize(typename vector<unsigned long long int>::size_type sz, const unsigned long long int &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1cdb
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x1c9f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3b40
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1cd9
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1caa
jmp 0x1cdb
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<float>::resize(unsigned int, float const&)
void vector<float>::resize(typename vector<float>::size_type sz, const float &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1d6d
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x1d2f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3bd0
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1d6b
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movss (%rcx), %xmm0
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movss %xmm0, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1d3a
jmp 0x1d6d
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::resize(unsigned int, double const&)
void vector<double>::resize(typename vector<double>::size_type sz, const double &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1dfd
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x1dbf
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3c60
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1dfb
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movsd (%rcx), %xmm0
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1dca
jmp 0x1dfd
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long double>::resize(unsigned int, long double const&)
void vector<long double>::resize(typename vector<long double>::size_type sz, const long double &c) {
		if (sz > vec_sz) {
			if (sz > rsrv_sz) {
				rsrv_sz = sz;
				reallocate();
			}
			size_type i;
			for (i = vec_sz; i < sz; ++i)
				arr[i] = c;
		}
		vec_sz = sz;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x4(%rcx), %eax
jbe 0x1e8d
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl (%rcx), %eax
jbe 0x1e4f
movq (%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
callq 0x3cf0
movq (%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x1e8b
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
fldt (%rcx)
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
shlq $0x4, %rcx
fstpt (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1e5a
jmp 0x1e8d
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<bool>::erase(bool const*)
typename vector<bool>::iterator vector<bool>::erase(typename vector<bool>::const_iterator it) {
		iterator iit = &arr[it - arr];
		memmove(iit, iit + 1, (vec_sz - (it - arr) - 1) * sizeof(bool));
		--vec_sz;
		return iit;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
movq 0x18(%rsp), %rdx
movq 0x8(%rcx), %rsi
subq %rsi, %rdx
addq %rdx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
subq %rax, %rdx
subq $0x1, %rdx
shlq $0x0, %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<short>::erase(short const*)
typename vector<short int>::iterator vector<short int>::erase(typename vector<short int>::const_iterator it) {
		iterator iit = &arr[it - arr];
		memmove(iit, iit + 1, (vec_sz - (it - arr) - 1) * sizeof(short int));
		--vec_sz;
		return iit;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
movq 0x18(%rsp), %rdx
movq 0x8(%rcx), %rsi
subq %rsi, %rdx
sarq %rdx
shlq %rdx
addq %rdx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x2, %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq %rax
subq %rax, %rdx
subq $0x1, %rdx
shlq %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::erase(int const*)
typename vector<int>::iterator vector<int>::erase(typename vector<int>::const_iterator it) {
		iterator iit = &arr[it - arr];
		memmove(iit, iit + 1, (vec_sz - (it - arr) - 1) * sizeof(int));
		--vec_sz;
		return iit;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
movq 0x18(%rsp), %rdx
movq 0x8(%rcx), %rsi
subq %rsi, %rdx
sarq $0x2, %rdx
shlq $0x2, %rdx
addq %rdx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x4, %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x2, %rax
subq %rax, %rdx
subq $0x1, %rdx
shlq $0x2, %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long>::erase(long const*)
typename vector<long int>::iterator vector<long int>::erase(typename vector<long int>::const_iterator it) {
		iterator iit = &arr[it - arr];
		memmove(iit, iit + 1, (vec_sz - (it - arr) - 1) * sizeof(long int));
		--vec_sz;
		return iit;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
movq 0x18(%rsp), %rdx
movq 0x8(%rcx), %rsi
subq %rsi, %rdx
sarq $0x3, %rdx
shlq $0x3, %rdx
addq %rdx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
subq %rax, %rdx
subq $0x1, %rdx
shlq $0x3, %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long double>::erase(long double const*)
typename vector<long double>::iterator vector<long double>::erase(typename vector<long double>::const_iterator it) {
		iterator iit = &arr[it - arr];
		memmove(iit, iit + 1, (vec_sz - (it - arr) - 1) * sizeof(long double));
		--vec_sz;
		return iit;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
movq 0x18(%rsp), %rdx
movq 0x8(%rcx), %rsi
subq %rsi, %rdx
sarq $0x4, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
subq %rax, %rdx
subq $0x1, %rdx
shlq $0x4, %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<bool>::erase(bool const*, bool const*)
typename vector<bool>::iterator vector<bool>::erase(typename vector<bool>::const_iterator first, typename vector<bool>::const_iterator last) {
		iterator f = &arr[first - arr];
		if (first == last) return f;
		memmove(f, last, (vec_sz - (last - arr)) * sizeof(bool));
		vec_sz -= last - first;
		return f;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x28dd
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x292e
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
subq %rax, %rdx
shlq $0x0, %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq %rcx, %rdx
movl 0x4(%rax), %ecx
subq %rdx, %rcx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<short>::erase(short const*, short const*)
typename vector<short int>::iterator vector<short int>::erase(typename vector<short int>::const_iterator first, typename vector<short int>::const_iterator last) {
		iterator f = &arr[first - arr];
		if (first == last) return f;
		memmove(f, last, (vec_sz - (last - arr)) * sizeof(short int));
		vec_sz -= last - first;
		return f;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x2ba3
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2bf9
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq %rax
subq %rax, %rdx
shlq %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq %rcx, %rdx
sarq %rdx
movl 0x4(%rax), %ecx
subq %rdx, %rcx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::erase(int const*, int const*)
typename vector<int>::iterator vector<int>::erase(typename vector<int>::const_iterator first, typename vector<int>::const_iterator last) {
		iterator f = &arr[first - arr];
		if (first == last) return f;
		memmove(f, last, (vec_sz - (last - arr)) * sizeof(int));
		vec_sz -= last - first;
		return f;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x2, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x2d25
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2d7e
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x2, %rax
subq %rax, %rdx
shlq $0x2, %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq %rcx, %rdx
sarq $0x2, %rdx
movl 0x4(%rax), %ecx
subq %rdx, %rcx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long long>::erase(long long const*, long long const*)
typename vector<long long int>::iterator vector<long long int>::erase(typename vector<long long int>::const_iterator first, typename vector<long long int>::const_iterator last) {
		iterator f = &arr[first - arr];
		if (first == last) return f;
		memmove(f, last, (vec_sz - (last - arr)) * sizeof(long long int));
		vec_sz -= last - first;
		return f;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x2ea5
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2efe
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq %rcx, %rdx
sarq $0x3, %rdx
movl 0x4(%rax), %ecx
subq %rdx, %rcx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned long long>::erase(unsigned long long const*, unsigned long long const*)
typename vector<unsigned long long int>::iterator vector<unsigned long long int>::erase(typename vector<unsigned long long int>::const_iterator first, typename vector<unsigned long long int>::const_iterator last) {
		iterator f = &arr[first - arr];
		if (first == last) return f;
		memmove(f, last, (vec_sz - (last - arr)) * sizeof(unsigned long long int));
		vec_sz -= last - first;
		return f;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x2f65
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2fbe
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq %rcx, %rdx
sarq $0x3, %rdx
movl 0x4(%rax), %ecx
subq %rdx, %rcx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long double>::erase(long double const*, long double const*)
typename vector<long double>::iterator vector<long double>::erase(typename vector<long double>::const_iterator first, typename vector<long double>::const_iterator last) {
		iterator f = &arr[first - arr];
		if (first == last) return f;
		memmove(f, last, (vec_sz - (last - arr)) * sizeof(long double));
		vec_sz -= last - first;
		return f;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x31a5
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x31fe
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x4(%rcx), %eax
movl %eax, %edx
movq 0x18(%rsp), %rax
movq 0x8(%rcx), %rcx
subq %rcx, %rax
sarq $0x4, %rax
subq %rax, %rdx
shlq $0x4, %rdx
callq 0x1110
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq %rcx, %rdx
sarq $0x4, %rdx
movl 0x4(%rax), %ecx
subq %rdx, %rcx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<bool>::reallocate()
inline void vector<T>::reallocate() {
		T *tarr = new T[rsrv_sz];
		memcpy(tarr, arr, vec_sz * sizeof(T));
		delete [] arr;
		arr = tarr;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
movl %eax, %edi
callq 0x1030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rsi
movl 0x4(%rax), %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0x10b0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x35ae
movq 0x10(%rsp), %rdi
callq 0x10f0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::push_back(int const&)
void vector<T>::push_back(const T &val) {
		if (vec_sz == rsrv_sz) {
			rsrv_sz <<= 2;
			reallocate();
		}
		arr[vec_sz] = val;
		++vec_sz;
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x3dfe
movq (%rsp), %rdi
movl (%rdi), %eax
shll $0x2, %eax
movl %eax, (%rdi)
callq 0x3870
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl (%rcx), %esi
movq 0x8(%rax), %rcx
movl 0x4(%rax), %edx
movl %esi, (%rcx,%rdx,4)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: amukherj[P]concurrencyts/latch.cc
// Function: main
int main() {
  std::experimental::latch latch(7);
  for (int i = 0; i < 7; ++i) {
    std::thread thr([&, i]() {
      std::this_thread::sleep_for(std::chrono::seconds(5));
      std::cout << "Thread " << i << " done\n";
      latch.count_down();
    });
    thr.detach();
  }

  latch.wait();
  std::cout << "Latch opened\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
movl $0x7, %esi
callq 0x1830
movl $0x0, -0x6c(%rbp)
cmpl $0x7, -0x6c(%rbp)
jge 0x1380
movl -0x6c(%rbp), %eax
movl %eax, -0x88(%rbp)
leaq -0x68(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x13d0
jmp 0x1330
leaq -0x78(%rbp), %rdi
callq 0x1170
jmp 0x133b
leaq -0x78(%rbp), %rdi
callq 0x1870
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x1307
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x13b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1870
jmp 0x13b5
leaq -0x68(%rbp), %rdi
callq 0x18a0
jmp 0x138b
movq 0x4c46(%rip), %rdi      # 0x5fd8
leaq 0x1c6b(%rip), %rsi      # 0x3004
callq 0x10f0
jmp 0x13a0
leaq -0x68(%rbp), %rdi
callq 0x1920
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x1920
movq -0x90(%rbp), %rdi
callq 0x1180
nopw (%rax,%rax)
// File: amukherj[P]concurrencyts/./latch.h
// Function: concurrencyts::latch::count_down()
void count_down() {
    std::unique_lock<std::mutex> ul{lock};
    assert(count > 0);
    if (--count == 0) {
      ul.unlock();
      done.notify_all();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1a20
movq -0x30(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jbe 0x1dca
jmp 0x1de9
leaq 0x1250(%rip), %rdi      # 0x3021
leaq 0x1253(%rip), %rsi      # 0x302b
movl $0x11, %edx
leaq 0x1251(%rip), %rcx      # 0x3035
callq 0x10a0
movq -0x30(%rbp), %rcx
movq 0x58(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x58(%rcx)
cmpq $0x0, %rax
jne 0x1e30
leaq -0x18(%rbp), %rdi
callq 0x1ba0
jmp 0x1e0a
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x1150
jmp 0x1e30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1ab0
jmp 0x1e3f
leaq -0x18(%rbp), %rdi
callq 0x1ab0
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1180
nopl (%rax,%rax)
// File: nilnilnil[P]autocomplete/./include/utils.hpp
// Function: log2(unsigned int)
uint_t log2(uint_t n) {
    uint_t lg2 = 0;
    while (n > 1) {
        n /= 2;
        ++lg2;
    }
    return lg2;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x1, -0x4(%rsp)
jbe 0x5dba
movl -0x4(%rsp), %eax
shrl %eax
movl %eax, -0x4(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x5d9c
movl -0x8(%rsp), %eax
retq
nop
// File: nilnilnil[P]autocomplete/./include/segtree.hpp
// Function: segtree::naive_query_max(std::vector<unsigned int, std::allocator<unsigned int>> const&, int, int)
pui_t
    naive_query_max(vui_t const& v, int i, int j) {
        uint_t mv = v[i];
        uint_t mi = i;
        while (i <= j) {
            if (v[i] > mv) {
                mv = v[i];
                mi = i;
            }
            ++i;
        }
        return pui_t(mv, mi);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xd380
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jg 0x5ea9
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xd380
movl (%rax), %eax
cmpl 0xc(%rsp), %eax
jbe 0x5e9c
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xd380
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x5e5e
leaq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0xd3a0
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: nilnilnil[P]autocomplete/./include/phrase_map.hpp
// Function: naive_query(PhraseMap&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
pvpi_t
naive_query(PhraseMap &pm, std::string prefix) {
    vpi_t f = pm.repr.begin(), l = pm.repr.begin();
    while (f != pm.repr.end() && f->phrase.substr(0, prefix.size()) < prefix) {
        ++f;
    }
    l = f;
    while (l != pm.repr.end() && l->phrase.substr(0, prefix.size()) == prefix) {
        ++l;
    }
    return std::make_pair(f, l);
}

// Assembly:
subq $0xc8, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xda50
movq %rax, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xda50
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xdac0
movq %rax, 0x90(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xda80
movb %al, %cl
movb $0x0, 0x6f(%rsp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x2f(%rsp)
jne 0x6724
jmp 0x6772
leaq 0xa0(%rsp), %rdi
callq 0xdb30
movq 0x30(%rsp), %rdi
addq $0x8, %rax
movq %rax, 0x20(%rsp)
callq 0x5380
movq 0x20(%rsp), %rsi
movq %rax, %rcx
leaq 0x70(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x5590
movq 0x30(%rsp), %rsi
movb $0x1, 0x6f(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xdaf0
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
movb %al, 0x1f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0x6783
jmp 0x678d
leaq 0x70(%rsp), %rdi
callq 0x5320
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x6797
jmp 0x67a9
leaq 0xa0(%rsp), %rdi
callq 0xdb40
jmp 0x66e6
movq 0xa0(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xdac0
movq %rax, 0x60(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xda80
movb %al, %cl
movb $0x0, 0x3f(%rsp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1e(%rsp)
jne 0x67f1
jmp 0x683f
leaq 0x98(%rsp), %rdi
callq 0xdb30
movq 0x30(%rsp), %rdi
addq $0x8, %rax
movq %rax, 0x10(%rsp)
callq 0x5380
movq 0x10(%rsp), %rsi
movq %rax, %rcx
leaq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x5590
movq 0x30(%rsp), %rsi
movb $0x1, 0x3f(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdb60
movb %al, 0x1e(%rsp)
movb 0x1e(%rsp), %al
movb %al, 0xf(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x6850
jmp 0x685a
leaq 0x40(%rsp), %rdi
callq 0x5320
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x6864
jmp 0x6876
leaq 0x98(%rsp), %rdi
callq 0xdb40
jmp 0x67b9
leaq 0xa0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xdc00
movq %rax, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xb8(%rsp), %rax
movq 0xc0(%rsp), %rdx
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/./include/phrase_map.hpp
// Function: show_indexes(PhraseMap&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void
show_indexes(PhraseMap &pm, std::string prefix) {
    pvpi_t nq = naive_query(pm, prefix);
    pvpi_t q  = pm.query(prefix);

    cout<<"naive[first] = "<<nq.first - pm.repr.begin()<<", naive[last] = "<<nq.second - pm.repr.begin()<<endl;
    cout<<"phmap[first] = "<<q.first - pm.repr.begin()<<", phmap[last] = "<<q.second - pm.repr.begin()<<endl;
}

// Assembly:
subq $0xe8, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x5220
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x66a0
movq %rdx, 0x58(%rsp)
movq %rax, 0x60(%rsp)
jmp 0x6916
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rcx
movq %rcx, 0xc8(%rsp)
movq %rax, 0xd0(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x5320
movq 0x40(%rsp), %rsi
movq 0xe0(%rsp), %rdi
callq 0xdc40
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x24662(%rip), %rdi     # 0x2afc8
leaq 0x1b6d4(%rip), %rsi     # 0x22041
callq 0x5550
movq %rax, 0x8(%rsp)
leaq 0xc8(%rsp), %rax
movq %rax, (%rsp)
movq 0xe0(%rsp), %rdi
callq 0xda50
movq (%rsp), %rdi
movq %rax, 0x80(%rsp)
leaq 0x80(%rsp), %rsi
callq 0xdca0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5ae0
movq %rax, %rdi
leaq 0x1b691(%rip), %rsi     # 0x22051
callq 0x5550
movq %rax, 0x18(%rsp)
leaq 0xc8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0xe0(%rsp), %rdi
callq 0xda50
movq 0x10(%rsp), %rdi
movq %rax, 0x78(%rsp)
leaq 0x78(%rsp), %rsi
callq 0xdca0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x5ae0
movq %rax, %rdi
movq 0x24595(%rip), %rsi     # 0x2afa8
callq 0x55a0
movq 0x245a9(%rip), %rdi     # 0x2afc8
leaq 0x1b63c(%rip), %rsi     # 0x22062
callq 0x5550
movq %rax, 0x28(%rsp)
leaq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xe0(%rsp), %rdi
callq 0xda50
movq 0x20(%rsp), %rdi
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rsi
callq 0xdca0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x5ae0
movq %rax, %rdi
leaq 0x1b5fd(%rip), %rsi     # 0x22072
callq 0x5550
movq %rax, 0x38(%rsp)
leaq 0x88(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
movq 0xe0(%rsp), %rdi
callq 0xda50
movq 0x30(%rsp), %rdi
movq %rax, 0x68(%rsp)
leaq 0x68(%rsp), %rsi
callq 0xdca0
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x5ae0
movq %rax, %rdi
movq 0x244e0(%rip), %rsi     # 0x2afa8
callq 0x55a0
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x5320
movq 0xa0(%rsp), %rdi
callq 0x5a40
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/src/main.cpp
// Function: file_size(char const*)
size_t
file_size(const char *path) {
    struct stat sbuf;
    int r = stat(path, &sbuf);

    assert(r == 0);
    if (r < 0) {
        return 0;
    }

    return sbuf.st_size;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x54e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x9afa
movq $0x0, 0xa0(%rsp)
jmp 0x9b07
movq 0x38(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: nilnilnil[P]autocomplete/src/main.cpp
// Function: get_qs(mg_request_info const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string
get_qs(const struct mg_request_info *request_info, std::string const& key) {
    char val[1024];
    std::string rv;

    val[1023] = val[0] = '\0';
    // printf("query string: %s\n", request_info->query_string);

    int val_len = 0;
    if (request_info->query_string) {
        val_len = mg_get_var(request_info->query_string, 
                             strlen(request_info->query_string), 
                             key.c_str(), val, 1023);
        rv = val;
    }
    return rv;
}

// Assembly:
subq $0x458, %rsp            # imm = 0x458
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x450(%rsp)
movq %rsi, 0x448(%rsp)
movq %rdx, 0x440(%rsp)
movb $0x0, 0x3f(%rsp)
callq 0x57f0
movb $0x0, 0x40(%rsp)
movb $0x0, 0x43f(%rsp)
movl $0x0, 0x38(%rsp)
movq 0x448(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x9bf8
movq 0x448(%rsp), %rax
movq 0x20(%rax), %rdi
movq %rdi, (%rsp)
callq 0x5230
movq %rax, 0x8(%rsp)
movq 0x440(%rsp), %rdi
callq 0x5200
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x40(%rsp), %rcx
movl $0x3ff, %r8d            # imm = 0x3FF
callq 0x17210
movl %eax, 0x14(%rsp)
jmp 0x9bc3
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x38(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x57c0
jmp 0x9bdc
jmp 0x9bf8
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x5320
jmp 0x9c1b
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x9c0e
movq 0x18(%rsp), %rdi
callq 0x5320
movq 0x20(%rsp), %rax
addq $0x458, %rsp            # imm = 0x458
retq
movq 0x30(%rsp), %rdi
callq 0x5a40
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/src/main.cpp
// Function: get_memory_usage(int)
int
get_memory_usage(pid_t pid) {
    char cbuff[4096];
    sprintf(cbuff, "pmap -x %d | tail -n +3 | awk 'BEGIN { S=0;T=0 } { if (match($3, /\\-/)) {S=1} if (S==0) {T+=$3} } END { print T }'", pid);
    FILE *pf = popen(cbuff, "r");
    if (!pf) {
        return -1;
    }
    int r = fread(cbuff, 1, 100, pf);
    if (r < 0) {
        fclose(pf);
        return -1;
    }
    cbuff[r-1] = '\0';
    r = atoi(cbuff);
    fclose(pf);
    return r;
}

// Assembly:
subq $0x1018, %rsp           # imm = 0x1018
movl %edi, 0x1010(%rsp)
leaq 0x10(%rsp), %rdi
movl 0x1010(%rsp), %edx
leaq 0x18566(%rip), %rsi     # 0x221b7
movb $0x0, %al
callq 0x50f0
leaq 0x10(%rsp), %rdi
leaq 0x19d2a(%rip), %rsi     # 0x2398e
callq 0x5160
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9c83
movl $0xffffffff, 0x1014(%rsp) # imm = 0xFFFFFFFF
jmp 0x9cef
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rcx
movl $0x1, %esi
movl $0x64, %edx
callq 0x58e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x9cbe
movq 0x8(%rsp), %rdi
callq 0x5560
movl $0xffffffff, 0x1014(%rsp) # imm = 0xFFFFFFFF
jmp 0x9cef
movl 0x4(%rsp), %eax
subl $0x1, %eax
cltq
movb $0x0, 0x10(%rsp,%rax)
leaq 0x10(%rsp), %rdi
callq 0x5950
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
callq 0x5560
movl 0x4(%rsp), %eax
movl %eax, 0x1014(%rsp)
movl 0x1014(%rsp), %eax
addq $0x1018, %rsp           # imm = 0x1018
retq
nop
// File: nilnilnil[P]autocomplete/src/main.cpp
// Function: escape_special_chars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void
escape_special_chars(std::string& str) {
    std::string ret;
    ret.reserve(str.size() + 10);
    for (size_t j = 0; j < str.size(); ++j) {
        switch (str[j]) {
        case '"':
            ret += "\\\"";
            break;

        case '\\':
            ret += "\\\\";
            break;

        case '\n':
            ret += "\\n";
            break;

        case '\t':
            ret += "\\t";
            break;

        default:
            ret += str[j];
        }
    }
    ret.swap(str);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x57f0
movq 0x60(%rsp), %rdi
callq 0x5380
movq 0x20(%rsp), %rdi
movq %rax, %rsi
addq $0xa, %rsi
callq 0x5970
jmp 0x9d95
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rdi
callq 0x5380
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x9ebd
movq 0x60(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x5b90
movq %rax, 0x10(%rsp)
jmp 0x9dd9
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x9, %eax
je 0x9e69
jmp 0x9dec
movl 0xc(%rsp), %eax
subl $0xa, %eax
je 0x9e54
jmp 0x9df7
movl 0xc(%rsp), %eax
subl $0x22, %eax
je 0x9e2a
jmp 0x9e02
movl 0xc(%rsp), %eax
subl $0x5c, %eax
je 0x9e3f
jmp 0x9e7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5320
jmp 0x9edb
leaq 0x18437(%rip), %rsi     # 0x22268
leaq 0x40(%rsp), %rdi
callq 0x5530
jmp 0x9e3d
jmp 0x9ea8
leaq 0x18425(%rip), %rsi     # 0x2226b
leaq 0x40(%rsp), %rdi
callq 0x5530
jmp 0x9e52
jmp 0x9ea8
leaq 0x18413(%rip), %rsi     # 0x2226e
leaq 0x40(%rsp), %rdi
callq 0x5530
jmp 0x9e67
jmp 0x9ea8
leaq 0x18401(%rip), %rsi     # 0x22271
leaq 0x40(%rsp), %rdi
callq 0x5530
jmp 0x9e7c
jmp 0x9ea8
movq 0x60(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x5b90
movq %rax, (%rsp)
jmp 0x9e93
movq (%rsp), %rax
movsbl (%rax), %esi
leaq 0x40(%rsp), %rdi
callq 0x5330
jmp 0x9ea6
jmp 0x9ea8
jmp 0x9eaa
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x9d9e
movq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x53a0
leaq 0x40(%rsp), %rdi
callq 0x5320
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x5a40
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/src/main.cpp
// Function: results_json(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<phrase_t, std::allocator<phrase_t>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string
results_json(std::string q, vp_t& suggestions, std::string const& type) {
    if (type == "list") {
        escape_special_chars(q);
        return "[ \"" + q + "\", " + suggestions_json_array(suggestions) + " ]";
    }
    else {
        return rich_suggestions_json_array(suggestions);
    }
}

// Assembly:
subq $0xd8, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
leaq 0x18088(%rip), %rsi     # 0x22950
callq 0xe990
testb $0x1, %al
jne 0xa8d6
jmp 0xa9f3
movq 0x10(%rsp), %rdi
callq 0x9d60
movq 0x10(%rsp), %rdx
leaq 0x179ba(%rip), %rsi     # 0x222a6
leaq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe710
movq 0x8(%rsp), %rsi
leaq 0x179a3(%rip), %rdx     # 0x222aa
leaq 0x78(%rsp), %rdi
callq 0xe5d0
jmp 0xa913
movq 0xc0(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xa530
jmp 0xa927
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xe620
jmp 0xa940
movq 0x18(%rsp), %rdi
leaq 0x17962(%rip), %rdx     # 0x222ae
leaq 0x98(%rsp), %rsi
callq 0xe5d0
jmp 0xa95b
leaq 0x98(%rsp), %rdi
callq 0x5320
leaq 0x28(%rsp), %rdi
callq 0x5320
leaq 0x78(%rsp), %rdi
callq 0x5320
leaq 0x58(%rsp), %rdi
callq 0x5320
jmp 0xaa05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xa9e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xa9dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xa9d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5320
leaq 0x28(%rsp), %rdi
callq 0x5320
leaq 0x78(%rsp), %rdi
callq 0x5320
leaq 0x58(%rsp), %rdi
callq 0x5320
jmp 0xaa12
movq 0x18(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x9ef0
movq 0x20(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x5a40
nopl (%rax)
// File: nilnilnil[P]autocomplete/src/main.cpp
// Function: show_usage(char**)
void
show_usage(char *argv[]) {
    printf("Usage: %s [OPTION]...\n", basename(argv[0]));
    printf("Start lib-face.\n\n");
    printf("Optional arguments:\n\n");
    printf("-h, --help           This screen\n");
    printf("-f, --file=PATH      Path of the file containing the phrases\n");
    printf("-p, --port=PORT      TCP port on which to start lib-face (default: 6767)\n");
    printf("-s, --sorted         If specified, the input file (PATH) is assumed to be sorted by phrase\n");
    printf("\n");
    printf("Please visit https://code.google.com/p/lib-face/ for more information.\n");
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x5a30
movq %rax, %rsi
leaq 0x1682d(%rip), %rdi     # 0x222c8
movb $0x0, %al
callq 0x5070
leaq 0x16836(%rip), %rdi     # 0x222df
movb $0x0, %al
callq 0x5070
leaq 0x1683a(%rip), %rdi     # 0x222f1
movb $0x0, %al
callq 0x5070
leaq 0x16842(%rip), %rdi     # 0x22307
movb $0x0, %al
callq 0x5070
leaq 0x16856(%rip), %rdi     # 0x22329
movb $0x0, %al
callq 0x5070
leaq 0x16886(%rip), %rdi     # 0x22367
movb $0x0, %al
callq 0x5070
leaq 0x168c2(%rip), %rdi     # 0x223b1
movb $0x0, %al
callq 0x5070
leaq 0x167f2(%rip), %rdi     # 0x222ef
movb $0x0, %al
callq 0x5070
leaq 0x16902(%rip), %rdi     # 0x2240d
movb $0x0, %al
callq 0x5070
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: nilnilnil[P]autocomplete/src/main.cpp
// Function: parse_options(int, char**)
void
parse_options(int argc, char *argv[]) {
    int c;

    while (1) {
        int option_index = 0;
        static struct option long_options[] = {
            {"file", 1, 0, 'f'},
            {"port", 1, 0, 'p'},
            {"sorted", 0, 0, 's'},
            {"help", 0, 0, 'h'},
            {0, 0, 0, 0}
        };

        c = getopt_long(argc, argv, "f:p:sh",
                        long_options, &option_index);

        if (c == -1)
            break;

        switch (c) {
        case 0:
        case 'f':
            DCERR("File: "<<optarg<<endl);
            ac_file = optarg;
            break;

        case 'p':
            DCERR("Port: "<<optarg<<" ("<<atoi(optarg)<<")\n");
            port = optarg;
            break;

        case 's':
            DCERR("File is Sorted\n");
            ac_sorted = true;
            break;
          
        case 'h':
            opt_show_help = true;
            break;

        case '?':
            cerr<<"ERROR::Invalid option: "<<optopt<<endl;
            break;
        }
    }


}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
leaq 0x16921(%rip), %rdx     # 0x22466
leaq 0x1fab4(%rip), %rcx     # 0x2b600
leaq 0x10(%rsp), %r8
callq 0x59f0
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0xbb66
jmp 0xbc1b
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xbbab
jmp 0xbb74
movl 0xc(%rsp), %eax
subl $0x3f, %eax
je 0xbbe3
jmp 0xbb7f
movl 0xc(%rsp), %eax
subl $0x66, %eax
je 0xbbab
jmp 0xbb8a
movl 0xc(%rsp), %eax
subl $0x68, %eax
je 0xbbda
jmp 0xbb95
movl 0xc(%rsp), %eax
subl $0x70, %eax
je 0xbbbe
jmp 0xbba0
movl 0xc(%rsp), %eax
subl $0x73, %eax
je 0xbbd1
jmp 0xbc16
movq 0x1f3fe(%rip), %rax     # 0x2afb0
movq (%rax), %rax
movq %rax, 0x1ff9c(%rip)     # 0x2bb58
jmp 0xbc16
movq 0x1f3eb(%rip), %rax     # 0x2afb0
movq (%rax), %rax
movq %rax, 0x1fa21(%rip)     # 0x2b5f0
jmp 0xbc16
movb $0x1, 0x1ff78(%rip)     # 0x2bb50
jmp 0xbc16
movb $0x1, 0x1ff70(%rip)     # 0x2bb51
jmp 0xbc16
movq 0x1f406(%rip), %rdi     # 0x2aff0
leaq 0x1687c(%rip), %rsi     # 0x2246d
callq 0x5550
movq %rax, %rdi
movq 0x1f3c0(%rip), %rax     # 0x2afc0
movl (%rax), %esi
callq 0x5a20
movq %rax, %rdi
movq 0x1f397(%rip), %rsi     # 0x2afa8
callq 0x55a0
jmp 0xbb2d
addq $0x28, %rsp
retq
// File: nilnilnil[P]autocomplete/src/main.cpp
// Function: handle_stats(mg_event, mg_connection*, mg_request_info const*)
static void*
handle_stats(enum mg_event event,
             struct mg_connection *conn,
             const struct mg_request_info *request_info) {
    print_HTTP_response(conn, 200, "OK");
    mg_printf(conn, "Answered %d queries\n", nreq);
    mg_printf(conn, "Uptime: %s\n", get_uptime().c_str());

    if (building) {
        mg_printf(conn, "Data Store is busy\n");
    }
    else {
        mg_printf(conn, "Data store size: %d entries\n", pm.repr.size());
    }
    mg_printf(conn, "Memory usage: %d MiB\n", get_memory_usage(getpid())/1024);

    return (void*)"";
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x1545d(%rip), %rdx     # 0x2260b
leaq 0x15425(%rip), %rcx     # 0x225da
movl $0xc8, %esi
callq 0x9d00
movq 0x58(%rsp), %rdi
movq 0x1e975(%rip), %rdx     # 0x2bb40
leaq 0x154b5(%rip), %rsi     # 0x22687
xorl %eax, %eax
movb %al, 0x23(%rsp)
callq 0x17030
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb5d0
movq 0x10(%rsp), %rdi
callq 0x5200
movq 0x18(%rsp), %rdi
movq %rax, %rdx
movb 0x23(%rsp), %al
leaq 0x15489(%rip), %rsi     # 0x2269c
callq 0x17030
jmp 0xd21a
leaq 0x30(%rsp), %rdi
callq 0x5320
testb $0x1, 0x1e90d(%rip)     # 0x2bb38
je 0xd25c
movq 0x58(%rsp), %rdi
leaq 0x1546f(%rip), %rsi     # 0x226a8
movb $0x0, %al
callq 0x17030
jmp 0xd288
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5320
jmp 0xd2c5
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x1e883(%rip), %rdi     # 0x2baf0
callq 0xe000
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x1543b(%rip), %rsi     # 0x226bc
movb $0x0, %al
callq 0x17030
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
callq 0x5890
movl %eax, %edi
callq 0x9c30
movq (%rsp), %rdi
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movl %eax, %edx
leaq 0x15427(%rip), %rsi     # 0x226d9
movb $0x0, %al
callq 0x17030
leaq 0x15030(%rip), %rax     # 0x222f0
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5a40
nop
// File: nilnilnil[P]autocomplete/./include/segtree.hpp
// Function: SegmentTree::initialize(std::vector<unsigned int, std::allocator<unsigned int>> const&)
void initialize(vui_t const& elems) {
        if (elems.empty()) {
            this->initialize(0);
        }
        else {
            this->initialize(elems.size());
            this->_init(0, 0, elems.size() - 1, elems);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe1d0
testb $0x1, %al
jne 0xd488
jmp 0xd496
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xef40
jmp 0xd4d4
movq 0x18(%rsp), %rdi
callq 0xd4e0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0xef40
movq 0x18(%rsp), %rdi
callq 0xd4e0
movq 0x8(%rsp), %rdi
subq $0x1, %rax
movl %eax, %ecx
movq 0x18(%rsp), %r8
xorl %edx, %edx
movl %edx, %esi
callq 0xfc60
movq %rax, 0x10(%rsp)
addq $0x28, %rsp
retq
nopl (%rax)
// File: nilnilnil[P]autocomplete/./include/sparsetable.hpp
// Function: SparseTable::query_max(unsigned int, unsigned int)
pui_t
    query_max(uint_t qf, uint_t ql) {
        if (qf >= this->len || ql >= this->len || ql < qf) {
            return make_pair(minus_one, minus_one);
        }

        const int rlen = ql - qf + 1;
        const size_t ti = log2(rlen);
        const size_t f = qf, l = ql + 1 - (1 << ti);

        // cerr<<"query_max("<<qf<<", "<<ql<<"), ti: "<<ti<<", f: "<<f<<", l: "<<l<<endl;
        if (this->repr[ti][f].first > this->repr[ti][l].first) {
            return this->repr[ti][f];
        }
        else {
            return this->repr[ti][l];
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x18(%rcx), %eax
jae 0xd93c
movq 0x8(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x18(%rcx), %eax
jae 0xd93c
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0xd955
leaq 0x14e0d(%rip), %rsi     # 0x22750
movq %rsi, %rdi
callq 0x11060
movq %rax, 0x40(%rsp)
jmp 0xda2e
movl 0x30(%rsp), %eax
subl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %edi
callq 0x5d90
movq 0x8(%rsp), %rdi
movl %eax, %eax
movq %rax, 0x20(%rsp)
movl 0x34(%rsp), %eax
movq %rax, 0x18(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movq 0x20(%rsp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl %ecx, %eax
movl %eax, %eax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rsi
callq 0x10130
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0xfde0
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rsi
callq 0x10130
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0xfde0
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
jbe 0xda0a
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10130
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0xfde0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0xda2e
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10130
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0xfde0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: nilnilnil[P]autocomplete/src/main.cpp
// Function: uint_to_string[abi:cxx11](unsigned int, unsigned int)
inline std::string
uint_to_string(uint_t n, uint_t pad = 0) {
    std::string ret;
    if (!n) {
        ret = "0";
    }
    else {
        while (n) {
            ret.insert(0, 1, ('0' + (n % 10)));
            n /= 10;
        }
    }
    while (pad && ret.size() < pad) {
        ret = "0" + ret;
    }

    return ret;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
callq 0x57f0
cmpl $0x0, 0x5c(%rsp)
jne 0xe8a1
movq 0x10(%rsp), %rdi
leaq 0x145fb(%rip), %rsi     # 0x22e76
callq 0x57c0
jmp 0xe882
jmp 0xe8f5
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x5320
jmp 0xe979
jmp 0xe8a3
cmpl $0x0, 0x5c(%rsp)
je 0xe8f3
movq 0x10(%rsp), %rdi
movl 0x5c(%rsp), %eax
movl %eax, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
imulq %rdx, %rax
shrq $0x23, %rax
movl %eax, %edx
addl %edx, %edx
movl %edx, %eax
leal (%rax,%rax,4), %eax
subl %eax, %ecx
orl $0x30, %ecx
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x5ba0
jmp 0xe8e0
movl 0x5c(%rsp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, 0x5c(%rsp)
jmp 0xe8a3
jmp 0xe8f5
jmp 0xe8f7
xorl %eax, %eax
cmpl $0x0, 0x58(%rsp)
movb %al, 0xf(%rsp)
je 0xe91c
movq 0x10(%rsp), %rdi
callq 0x5380
movl 0x58(%rsp), %ecx
cmpq %rcx, %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xe926
jmp 0xe959
movq 0x10(%rsp), %rdx
leaq 0x14544(%rip), %rsi     # 0x22e76
leaq 0x20(%rsp), %rdi
callq 0xe710
jmp 0xe93e
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5710
leaq 0x20(%rsp), %rdi
callq 0x5320
jmp 0xe8f7
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0xe96f
movq 0x10(%rsp), %rdi
callq 0x5320
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x5a40
nopw %cs:(%rax,%rax)
nopl (%rax)