LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<signed char>::resize(unsigned int)
void vector<signed char>::resize(typename vector<signed char>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1298
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x21ba
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned char>::resize(unsigned int)
void vector<unsigned char>::resize(typename vector<unsigned char>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x12bc
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x21f6
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<char>::resize(unsigned int)
void vector<char>::resize(typename vector<char>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x12e0
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x2232
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<short>::resize(unsigned int)
void vector<short int>::resize(typename vector<short int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1304
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x226e
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned short>::resize(unsigned int)
void vector<unsigned short int>::resize(typename vector<unsigned short int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1328
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x22b0
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::resize(unsigned int)
void vector<int>::resize(typename vector<int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x134c
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x22f2
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned int>::resize(unsigned int)
void vector<unsigned int>::resize(typename vector<unsigned int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1370
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x2336
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long>::resize(unsigned int)
void vector<long int>::resize(typename vector<long int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1394
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x237a
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned long>::resize(unsigned int)
void vector<unsigned long int>::resize(typename vector<unsigned long int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x13b8
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x23be
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long long>::resize(unsigned int)
void vector<long long int>::resize(typename vector<long long int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x13dc
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x2402
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned long long>::resize(unsigned int)
void vector<unsigned long long int>::resize(typename vector<unsigned long long int>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1400
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x2446
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<float>::resize(unsigned int)
void vector<float>::resize(typename vector<float>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1424
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x248a
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<double>::resize(unsigned int)
void vector<double>::resize(typename vector<double>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1448
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x24ce
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long double>::resize(unsigned int)
void vector<long double>::resize(typename vector<long double>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x146c
movl %ebx, (%r14)
movq %r14, %rdi
callq 0x2512
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<bool>::resize(unsigned int, bool const&)
void vector<bool>::resize(typename vector<bool>::size_type sz, const bool &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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x14b9
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x14a0
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x217e
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x14b9
movb (%r14), %sil
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x14a8
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<signed char>::resize(unsigned int, signed char const&)
void vector<signed char>::resize(typename vector<signed char>::size_type sz, const signed char &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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %eax
cmpl %esi, %eax
jae 0x1504
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x14ec
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x21ba
movl 0x4(%r15), %eax
movl %eax, %eax
movl %ebx, %ecx
cmpq %rcx, %rax
jae 0x1504
movb (%r14), %dl
movq 0x8(%r15), %rsi
movb %dl, (%rsi,%rax)
incq %rax
jmp 0x14f0
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned char>::resize(unsigned int, unsigned char const&)
void vector<unsigned char>::resize(typename vector<unsigned char>::size_type sz, const unsigned char &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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %eax
cmpl %esi, %eax
jae 0x154e
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x1536
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x21f6
movl 0x4(%r15), %eax
movl %eax, %eax
movl %ebx, %ecx
cmpq %rcx, %rax
jae 0x154e
movb (%r14), %dl
movq 0x8(%r15), %rsi
movb %dl, (%rsi,%rax)
incq %rax
jmp 0x153a
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<char>::resize(unsigned int, char const&)
void vector<char>::resize(typename vector<char>::size_type sz, const char &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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %eax
cmpl %esi, %eax
jae 0x1598
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x1580
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x2232
movl 0x4(%r15), %eax
movl %eax, %eax
movl %ebx, %ecx
cmpq %rcx, %rax
jae 0x1598
movb (%r14), %dl
movq 0x8(%r15), %rsi
movb %dl, (%rsi,%rax)
incq %rax
jmp 0x1584
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<short>::resize(unsigned int, short const&)
void vector<short int>::resize(typename vector<short int>::size_type sz, const short 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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x15e4
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x15ca
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x226e
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x15e4
movzwl (%r14), %esi
movw %si, (%rax,%rcx,2)
incq %rcx
jmp 0x15d2
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned short>::resize(unsigned int, unsigned short const&)
void vector<unsigned short int>::resize(typename vector<unsigned short int>::size_type sz, const unsigned short 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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x1630
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x1616
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x22b0
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x1630
movzwl (%r14), %esi
movw %si, (%rax,%rcx,2)
incq %rcx
jmp 0x161e
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<int>::resize(unsigned int, int const&)
void vector<int>::resize(typename vector<int>::size_type sz, const 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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x167a
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x1662
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x22f2
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x167a
movl (%r14), %esi
movl %esi, (%rax,%rcx,4)
incq %rcx
jmp 0x166a
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned int>::resize(unsigned int, unsigned int const&)
void vector<unsigned int>::resize(typename vector<unsigned int>::size_type sz, const unsigned 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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x16c4
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x16ac
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x2336
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x16c4
movl (%r14), %esi
movl %esi, (%rax,%rcx,4)
incq %rcx
jmp 0x16b4
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long>::resize(unsigned int, long const&)
void vector<long int>::resize(typename vector<long int>::size_type sz, const 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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x170f
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x16f6
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x237a
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x170f
movq (%r14), %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
jmp 0x16fe
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<unsigned long>::resize(unsigned int, unsigned long const&)
void vector<unsigned long int>::resize(typename vector<unsigned long int>::size_type sz, const unsigned 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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x175b
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x1742
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x23be
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x175b
movq (%r14), %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
jmp 0x174a
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<long long>::resize(unsigned int, long long const&)
void vector<long long int>::resize(typename vector<long long int>::size_type sz, const 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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x17a7
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x178e
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x2402
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x17a7
movq (%r14), %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
jmp 0x1796
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x17f3
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x17da
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x2446
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x17f3
movq (%r14), %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
jmp 0x17e2
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x1842
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x1826
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x248a
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x1842
movss (%r14), %xmm0
movss %xmm0, (%rax,%rcx,4)
incq %rcx
jmp 0x182e
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %ecx
cmpl %esi, %ecx
jae 0x1890
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x1874
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x24ce
movl 0x4(%r15), %ecx
movq 0x8(%r15), %rax
movl %ecx, %ecx
movl %ebx, %edx
cmpq %rdx, %rcx
jae 0x1890
movsd (%r14), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0x187c
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %eax
cmpl %esi, %eax
jae 0x18e4
movq %rdx, %r14
cmpl %ebx, (%r15)
jae 0x18c2
movl %ebx, (%r15)
movq %r15, %rdi
callq 0x2512
movl 0x4(%r15), %eax
movl %eax, %eax
movl %ebx, %ecx
movq %rax, %rdx
shlq $0x4, %rdx
addq 0x8(%r15), %rdx
cmpq %rcx, %rax
jae 0x18e4
fldt (%r14)
fstpt (%rdx)
incq %rax
addq $0x10, %rdx
jmp 0x18d1
movl %ebx, 0x4(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x1030
movq %rax, %r14
movq 0x8(%rbx), %r15
movl 0x4(%rbx), %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10b0
testq %r15, %r15
je 0x21af
movq %r15, %rdi
callq 0x10f0
movq %r14, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cmpl (%rdi), %eax
jne 0x2599
shll $0x2, %eax
movl %eax, (%rbx)
movq %rbx, %rdi
callq 0x22f2
movl 0x4(%rbx), %eax
movl (%r14), %ecx
movq 0x8(%rbx), %rdx
movl %eax, %eax
movl %ecx, (%rdx,%rax,4)
incl 0x4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/iostream_iter.cc
// Function: main
int main()
{
    istream_iterator<int> int_it(cin); // reads ints from cin
    istream_iterator<int> int_eof;     // end iterator value
	vector<int> v(int_it, int_eof);    // initialize v by reading cin

    sort(v.begin(), v.end());
    ostream_iterator<int> out(cout, " "); // write ints to cout
    unique_copy(v.begin(), v.end(), out); // write unique elements to cout
    cout << endl;                         // write a newline after the output
	ofstream out_file("data/outFile2");   // writes int to named file
	ostream_iterator<int> out_iter(out_file, " ");
	copy(v.begin(), v.end(), out_iter); 
	out_file << endl;  // write a newline at end of the file
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x280, %rsp            # imm = 0x280
movq 0x2d2f(%rip), %rsi      # 0x3fe0
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
callq 0x13d0
movq (%rbx), %rax
leaq -0x78(%rbp), %rsi
movq %rax, (%rsi)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%rsi)
movb 0xc(%rbx), %al
movb %al, 0xc(%rsi)
leaq -0x68(%rbp), %rdx
andq $0x0, (%rdx)
andl $0x0, 0x8(%rdx)
movb $0x0, 0xc(%rdx)
leaq -0x28(%rbp), %rbx
leaq -0x288(%rbp), %rcx
movq %rbx, %rdi
callq 0x13e2
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x1748
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0x2cbc(%rip), %rax      # 0x3fd0
leaq -0x58(%rbp), %rcx
movq %rax, (%rcx)
leaq 0xce2(%rip), %r14       # 0x2004
movq %r14, 0x8(%rcx)
leaq -0x288(%rbp), %rdi
callq 0x144e
movq 0x2c97(%rip), %rdi      # 0x3fd0
callq 0x1060
leaq 0xcc1(%rip), %rsi       # 0x2006
leaq -0x288(%rbp), %rbx
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x10e0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rcx
movq %rbx, (%rcx)
movq %r14, 0x8(%rcx)
leaq -0x38(%rbp), %rdi
callq 0x1493
leaq -0x288(%rbp), %rdi
callq 0x1060
leaq -0x288(%rbp), %rdi
callq 0x1100
leaq -0x28(%rbp), %rdi
callq 0x157c
xorl %eax, %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x13a4
movq %rax, %rbx
leaq -0x288(%rbp), %rdi
callq 0x1100
jmp 0x13be
jmp 0x13bb
jmp 0x13bb
jmp 0x13bb
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x157c
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x18(%rsp), %rbx
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x1428
xorl %r13d, %r13d
pushq $0x18
popq %r14
leaq 0x2aa0(%rip), %rbp      # 0x3d88
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpl $0x7, %r13d
je 0x1348
andq $0x0, 0x10(%rsp)
movq %r14, %rdi
callq 0x10f0
movq %rbp, (%rax)
movl %r13d, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10d0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1333
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x1160
movq %r15, %rdi
callq 0x1456
incl %r13d
jmp 0x12f2
leaq 0x18(%rsp), %rdi
callq 0x1464
movq 0x2c7f(%rip), %rdi      # 0x3fd8
leaq 0xca4(%rip), %rsi       # 0x2004
callq 0x10e0
leaq 0x40(%rsp), %rdi
callq 0x1180
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1382
movq %rax, %rbx
jmp 0x13a9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13a9
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x13a9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1456
leaq 0x40(%rsp), %rdi
callq 0x1180
movq %rbx, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x14ae
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x15ef
decq %rax
movq %rax, 0x58(%rbx)
jne 0x15e1
movq %rsp, %rdi
callq 0x1540
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x1140
movq %rsp, %rdi
callq 0x14ec
addq $0x10, %rsp
popq %rbx
retq
leaq 0xa2b(%rip), %rdi       # 0x2021
leaq 0xa2e(%rip), %rsi       # 0x202b
leaq 0xa31(%rip), %rcx       # 0x2035
pushq $0x11
popq %rdx
callq 0x1090
movq %rax, %rbx
movq %rsp, %rdi
callq 0x14ec
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
cmpl $0x2, %edi
jb 0x5b8e
shrl %edi
incl %eax
jmp 0x5b83
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq %esi, %rcx
movq (%rdi), %rdi
movl (%rdi,%rcx,4), %eax
movslq %edx, %rdx
cmpq %rdx, %rcx
jg 0x5c09
movl (%rdi,%rcx,4), %r8d
cmpl %eax, %r8d
cmoval %r8d, %eax
cmoval %ecx, %esi
incq %rcx
jmp 0x5bf1
shlq $0x20, %rsi
movl %eax, %eax
orq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
leaq 0x8(%rsp), %r12
cmpq 0x8(%r15), %r14
je 0x60d2
leaq 0x8(%r14), %rsi
movq 0x8(%rbx), %rcx
movq %r12, %rdi
xorl %edx, %edx
callq 0x54d0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x970e
movl %eax, %ebp
movq %r12, %rdi
callq 0x5210
testb %bpl, %bpl
je 0x60d2
addq $0x38, %r14
jmp 0x609a
movq %r14, %r12
cmpq 0x8(%r15), %r12
je 0x6113
leaq 0x8(%r12), %rsi
movq 0x8(%rbx), %rcx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
xorl %edx, %edx
callq 0x54d0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x9721
movl %eax, %ebp
movq %r13, %rdi
callq 0x5210
testb %bpl, %bpl
je 0x6113
addq $0x38, %r12
jmp 0x60d5
movq %r14, %rax
movq %r12, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5690
movq %rbx, %rdi
movq %r15, %rsi
callq 0x607e
movq %rax, %rbp
movq %rdx, %r12
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
movq %r14, %rsi
callq 0x974a
movq %rax, %r15
movq %rdx, %r14
movq 0x13e44(%rip), %rdi     # 0x19fc0
leaq 0xbeda(%rip), %rsi      # 0x1205d
callq 0x5480
movq %rax, %rdi
subq (%rbx), %rbp
pushq $0x38
popq %r13
movq %rbp, %rax
cqto
idivq %r13
movq %rax, %rsi
callq 0x5450
leaq 0xbec4(%rip), %rsi      # 0x1206d
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
subq (%rbx), %r12
movq %r12, %rax
cqto
idivq %r13
movq %rax, %rsi
callq 0x5450
movq %rax, %rdi
callq 0x5240
leaq 0xbea8(%rip), %rsi      # 0x1207e
movq 0x13de3(%rip), %rdi     # 0x19fc0
callq 0x5480
movq %rax, %rdi
subq (%rbx), %r15
movq %r15, %rax
cqto
idivq %r13
movq %rax, %rsi
callq 0x5450
leaq 0xbe8f(%rip), %rsi      # 0x1208e
movq %rax, %rdi
callq 0x5480
movq %rax, %rdi
subq (%rbx), %r14
movq %r14, %rax
cqto
idivq %r13
movq %rax, %rsi
callq 0x5450
movq %rax, %rdi
callq 0x5240
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x58e0
// File: /workspace/github_cpp_makefile_star2_O2/nilnilnil[P]autocomplete/./include/suggest.hpp
// Function: naive_suggest(PhraseMap&, SegmentTree&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
vp_t
naive_suggest(PhraseMap& pm, RMQ& st, std::string prefix, uint_t n = 16) {
    pvpi_t phrases = pm.query(prefix);
    std::vector<uint_t> indexes;
    vp_t ret;

    while (phrases.first != phrases.second) {
        indexes.push_back(phrases.first - pm.repr.begin());
        ++phrases.first;
    }

    while (ret.size() < n && !indexes.empty()) {
        uint_t mi = 0;
        for (size_t i = 1; i < indexes.size(); ++i) {
            if (pm.repr[indexes[i]].weight > pm.repr[indexes[mi]].weight) {
                mi = i;
            }
        }
        ret.push_back(pm.repr[indexes[mi]]);
        indexes.erase(indexes.begin() + mi);
    }
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x974a
movq %rax, %r13
movq %rdx, %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0xc(%rsp), %rbp
movq %r13, %r15
cmpq %r12, %r15
je 0x6923
movq %r13, %rax
subq (%r14), %rax
cqto
pushq $0x38
popq %rcx
idivq %rcx
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0xb1d6
addq $0x38, %r15
addq $0x38, %r13
jmp 0x68f5
movl 0x8(%rsp), %r15d
pushq $0x1
popq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
pushq $0x38
popq %rcx
idivq %rcx
cmpq %r15, %rax
jae 0x69df
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
je 0x69df
subq %rax, %rcx
sarq $0x2, %rcx
movq (%r14), %rsi
xorl %edi, %edi
movq %r12, %rdx
movl %edi, %r13d
cmpq %rcx, %rdx
jae 0x6996
movl (%rax,%rdx,4), %r8d
imulq $0x38, %r8, %r8
movl (%rsi,%r8), %r9d
movl (%rax,%r13,4), %r8d
imulq $0x38, %r8, %r10
movl %edx, %r8d
cmpl (%rsi,%r10), %r9d
ja 0x698e
movl %edi, %r8d
incq %rdx
movl %r8d, %edi
jmp 0x6966
movl (%rax,%r13,4), %eax
imulq $0x38, %rax, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x9870
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdx
leaq (%rax,%r13,4), %rsi
addq $0x4, %rsi
cmpq %rdx, %rsi
je 0x69d1
leaq (%rax,%r13,4), %rdi
subq %rsi, %rdx
callq 0x5880
movq 0x18(%rsp), %rdx
addq $-0x4, %rdx
movq %rdx, 0x18(%rsp)
jmp 0x692c
leaq 0x10(%rsp), %rdi
callq 0xb1a2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x69fd
movq %rax, %r14
movq %rbx, %rdi
callq 0x989c
leaq 0x10(%rsp), %rdi
callq 0xb1a2
movq %r14, %rdi
callq 0x58e0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
movb %al, (%rsp)
movb %al, 0x3ff(%rsp)
movq 0x20(%rsi), %r14
testq %r14, %r14
je 0x7760
movq %rdx, %r15
movq %r14, %rdi
callq 0x51e0
movq (%r15), %rdx
movq %rsp, %rcx
movl $0x3ff, %r8d            # imm = 0x3FF
movq %r14, %rdi
movq %rax, %rsi
callq 0xbccf
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x59a0
movq %rbx, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5210
movq %r14, %rdi
callq 0x58e0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %edi, %edx
leaq 0xaa3e(%rip), %rsi      # 0x121d3
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x50e0
leaq 0xc1da(%rip), %rsi      # 0x13983
movq %rbx, %rdi
callq 0x5140
testq %rax, %rax
je 0x77e2
movq %rax, %rbx
movq %rsp, %rdi
pushq $0x1
popq %rsi
pushq $0x64
popq %rdx
movq %rax, %rcx
callq 0x5790
testl %eax, %eax
js 0x77e7
decl %eax
cltq
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
callq 0x5810
movl %eax, %ebp
jmp 0x77ea
pushq $-0x1
popq %rbp
jmp 0x77f2
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x5490
movl %ebp, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nilnilnil[P]autocomplete/src/main.cpp
// Function: suggestions_json_array[abi:cxx11](std::vector<phrase_t, std::allocator<phrase_t>>&)
std::string
suggestions_json_array(vp_t& suggestions) {
    std::string ret = "[";
    ret.reserve(OUTPUT_SIZE_RESERVE);
    for (vp_t::iterator i = suggestions.begin(); i != suggestions.end(); ++i) {
        escape_special_chars(i->phrase);

        std::string trailer = i + 1 == suggestions.end() ? "\n" : ",\n";
        ret += "\"" + i->phrase + "\"" + trailer;
    }
    ret += "]";
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xa5ea(%rip), %rsi      # 0x12290
leaq 0x18(%rsp), %rdx
callq 0x97ec
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
callq 0x5830
movq %r15, 0x8(%rsp)
movq (%r14), %r15
leaq 0xa5d6(%rip), %rbp      # 0x122a2
leaq 0x78(%rsp), %r12
movq %r14, 0x10(%rsp)
cmpq 0x8(%r14), %r15
je 0x7d9c
addq $0x8, %r15
movq %r15, %rdi
callq 0x781c
addq $0x30, %r15
movq 0x10(%rsp), %rax
cmpq 0x8(%rax), %r15
leaq 0xa592(%rip), %rsi      # 0x12292
leaq 0xb537(%rip), %rax      # 0x1323e
cmoveq %rax, %rsi
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x97ec
addq $-0x30, %r15
movq %r12, %rdi
movq %rbp, %rbx
movq %rbp, %rsi
movq %r15, %rdx
callq 0x99f9
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r12, %r14
movq %r12, %rsi
movq %rbx, %rdx
callq 0x9973
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x18(%rsp), %rdx
callq 0x9954
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x59d0
movq %r14, %r12
movq %rbx, %rdi
callq 0x5210
leaq 0x38(%rsp), %rdi
callq 0x5210
movq %r14, %rdi
callq 0x5210
leaq 0x18(%rsp), %rdi
callq 0x5210
addq $0x30, %r15
movq 0x10(%rsp), %r14
jmp 0x7cd6
leaq 0xa528(%rip), %rsi      # 0x122cb
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5990
movq %r15, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7e10
movq %rax, %rbx
jmp 0x7dfa
movq %rax, %rbx
jmp 0x7df0
movq %rax, %rbx
jmp 0x7de6
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5210
leaq 0x38(%rsp), %rdi
callq 0x5210
leaq 0x78(%rsp), %rdi
callq 0x5210
leaq 0x18(%rsp), %rdi
callq 0x5210
jmp 0x7e0b
jmp 0x7e08
movq %rax, %rbx
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x58e0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xab0a(%rip), %rsi      # 0x12948
movq %rcx, %rdi
callq 0x9b38
testb %al, %al
je 0x7ee0
movq %r15, %rdi
callq 0x781c
leaq 0xa465(%rip), %rsi      # 0x122c2
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x99f9
leaq 0xa452(%rip), %rdx      # 0x122c6
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x9973
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x7c88
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x9992
leaq 0xa421(%rip), %rdx      # 0x122ca
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x9973
leaq 0x48(%rsp), %rdi
callq 0x5210
leaq 0x8(%rsp), %rdi
callq 0x5210
leaq 0x28(%rsp), %rdi
callq 0x5210
leaq 0x68(%rsp), %rdi
callq 0x5210
jmp 0x7eeb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x78fb
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5210
jmp 0x7f0f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5210
jmp 0x7f1e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5210
jmp 0x7f2d
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5210
movq %rbx, %rdi
callq 0x58e0
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdi
callq 0x58d0
leaq 0x9a2d(%rip), %rdi      # 0x122e4
movq %rax, %rsi
xorl %eax, %eax
callq 0x5060
leaq 0x9d06(%rip), %rdi      # 0x125ce
callq 0x57f0
leaq 0x9d0b(%rip), %rdi      # 0x125df
callq 0x57f0
leaq 0x9d14(%rip), %rdi      # 0x125f4
callq 0x57f0
leaq 0x9d29(%rip), %rdi      # 0x12615
callq 0x57f0
leaq 0x9d5a(%rip), %rdi      # 0x12652
callq 0x57f0
leaq 0x9d97(%rip), %rdi      # 0x1269b
callq 0x57f0
pushq $0xa
popq %rdi
callq 0x56b0
leaq 0x9dde(%rip), %rdi      # 0x126f6
popq %rax
jmp 0x57f0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x99d7(%rip), %r14      # 0x1230c
leaq 0x11be4(%rip), %r15     # 0x1a520
leaq 0x4(%rsp), %r12
movq 0x11660(%rip), %r13     # 0x19fa8
andl $0x0, 0x4(%rsp)
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x58b0
testl %eax, %eax
je 0x8984
cmpl $0x3f, %eax
je 0x89b0
cmpl $0x66, %eax
je 0x8984
cmpl $0x68, %eax
je 0x899e
cmpl $0x70, %eax
je 0x8991
cmpl $0x73, %eax
je 0x89a7
cmpl $-0x1, %eax
jne 0x8948
jmp 0x89e1
movq (%r13), %rax
movq %rax, 0x12059(%rip)     # 0x1a9e8
jmp 0x8948
movq (%r13), %rax
movq %rax, 0x11b74(%rip)     # 0x1a510
jmp 0x8948
movb $0x1, 0x1203c(%rip)     # 0x1a9e1
jmp 0x8948
movb $0x1, 0x12032(%rip)     # 0x1a9e0
jmp 0x8948
movq 0x11631(%rip), %rdi     # 0x19fe8
leaq 0x9955(%rip), %rsi      # 0x12313
callq 0x5480
movq 0x115ee(%rip), %rcx     # 0x19fb8
movl (%rcx), %esi
movq %rax, %rdi
callq 0x58c0
movq %rax, %rdi
callq 0x5240
jmp 0x8948
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
cmpq %rsi, %rax
je 0x9500
subq %rax, %rsi
shrq $0x2, %rsi
movq %r14, %rdi
callq 0x9cf2
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x2, %rcx
decl %ecx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9f24
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9cf2
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %edx, %edi
pushq $-0x1
popq %rax
subl %esi, %edi
jb 0x9709
movl %esi, %ebp
movl 0x18(%rbx), %ecx
cmpl %esi, %ecx
jbe 0x9709
movl %edx, %r14d
cmpl %edx, %ecx
jbe 0x9709
incl %edi
callq 0x5b81
movl %eax, %edx
pushq $-0x1
popq %rsi
movl %eax, %ecx
shll %cl, %esi
movl %ebp, %eax
leal (%r14,%rsi), %ecx
incl %ecx
movq (%rbx), %rsi
imulq $0x18, %rdx, %rdx
movq (%rsi,%rdx), %rdx
movl (%rdx,%rax,8), %esi
cmpl (%rdx,%rcx,8), %esi
cmovaq %rax, %rcx
movq (%rdx,%rcx,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movl %edx, %ebp
movb $0x0, 0x10(%rdi)
testl %esi, %esi
je 0x9ac4
movl %esi, %r15d
pushq $0xa
popq %r12
pushq $0x1
popq %r14
testl %r15d, %r15d
je 0x9ad3
movl %r15d, %eax
xorl %edx, %edx
divl %r12d
orb $0x30, %dl
movzbl %dl, %ecx
movl %eax, %r15d
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x59f0
jmp 0x9a9f
leaq 0x93a3(%rip), %rsi      # 0x12e6e
movq %rbx, %rdi
callq 0x59a0
testl %ebp, %ebp
je 0x9b11
movl %ebp, %r12d
cmpq %r12, 0x8(%rbx)
jae 0x9b11
leaq 0x9387(%rip), %r14      # 0x12e6e
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x99f9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5600
movq %r15, %rdi
callq 0x5210
cmpq %r12, 0x8(%rbx)
jb 0x9aea
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9b25
jmp 0x9b25
movq %rax, %r14
movq %rbx, %rdi
callq 0x5210
movq %r14, %rdi
callq 0x58e0