LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Matan-Vinkler[P]Basic-File-System/myfs_main.cpp
// Function: split_cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<std::string> split_cmd(std::string cmd) {
	std::stringstream ss(cmd);
	std::string part;
	std::vector<std::string> ans;

	while (std::getline(ss, part, ' '))
		ans.push_back(part);

	return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
leaq -0x1c8(%rbp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x2290
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq -0x40(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x20, %edx
callq 0x2320
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3e97
movq %rbx, %rdi
movq %r15, %rsi
callq 0x55e4
jmp 0x3e6c
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3eac
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2220
movq 0x50e5(%rip), %rsi      # 0x8f98
leaq -0x1c8(%rbp), %rdi
callq 0x21b0
leaq -0x148(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5630
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3efe
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2220
movq 0x5093(%rip), %rsi      # 0x8f98
leaq -0x1c8(%rbp), %rdi
callq 0x21b0
leaq -0x148(%rbp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/gdaws[P]process-monitor/program_arguments.cpp
// Function: program_arguments::parser::add_argument(char const*, program_arguments::basic_binder*)
parser & parser::add_argument(const char * value_name, basic_binder * binding)
{
    if(m_argument_repeat_last) m_argument_repeat_last++;

    argument arg;
    arg.value_name = value_name;
    arg.binding = binding;
    m_arguments.push_back(arg);
    
    m_next_argument = m_arguments.begin();
    
    return *this;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x98(%rdi), %eax
testl %eax, %eax
je 0x3136
incl %eax
movl %eax, 0x98(%rbx)
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
movq 0x80(%rbx), %rsi
cmpq 0x88(%rbx), %rsi
je 0x3160
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x80(%rbx)
jmp 0x316c
leaq 0x78(%rbx), %rdi
movq %rsp, %rdx
callq 0x5a32
movq 0x78(%rbx), %rax
movq %rax, 0x90(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/pritpal20[P]vector/./vector.hpp
// Function: lni::vector<bool>::resize(unsigned int)
void vector<bool>::resize(typename vector<bool>::size_type sz) {
		if (sz > rsrv_sz) {
			rsrv_sz = sz;
			reallocate();
		}
		vec_sz = sz;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x12ae
movl %ebx, (%r14)
movl %ebx, %edi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x12aa
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1300
movl %ebx, (%r14)
movl %ebx, %edi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x12fc
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1352
movl %ebx, (%r14)
movl %ebx, %edi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x134e
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x13a4
movl %ebx, (%r14)
movl %ebx, %edi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x13a0
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x13fc
movl %ebx, (%r14)
movl %ebx, %edi
addq %rdi, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
addq %rdx, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x13f8
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1454
movl %ebx, (%r14)
movl %ebx, %edi
addq %rdi, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
addq %rdx, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x1450
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x14ae
movl %ebx, (%r14)
movl %ebx, %edi
shlq $0x2, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
shlq $0x2, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x14aa
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1508
movl %ebx, (%r14)
movl %ebx, %edi
shlq $0x2, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
shlq $0x2, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x1504
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1562
movl %ebx, (%r14)
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x155e
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x15bc
movl %ebx, (%r14)
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x15b8
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1616
movl %ebx, (%r14)
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x1612
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x1670
movl %ebx, (%r14)
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
shlq $0x3, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x166c
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x16ca
movl %ebx, (%r14)
movl %ebx, %edi
shlq $0x2, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
shlq $0x2, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x16c6
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl %esi, (%rdi)
jae 0x177e
movl %ebx, (%r14)
movl %ebx, %edi
shlq $0x4, %rdi
callq 0x1030
movq %rax, %r15
movq 0x8(%r14), %r12
movl 0x4(%r14), %edx
shlq $0x4, %rdx
movq %rax, %rdi
movq %r12, %rsi
callq 0x10b0
testq %r12, %r12
je 0x177a
movq %r12, %rdi
callq 0x10f0
movq %r15, 0x8(%r14)
movl %ebx, 0x4(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r13d
cmpl %esi, %r13d
jae 0x1802
movq %rdx, %r14
movl %ebx, %r12d
cmpl %ebx, (%r15)
jae 0x17e8
movl %ebx, (%r15)
movq %r12, %rdi
callq 0x1030
movq 0x8(%r15), %rbp
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x17e0
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1802
movq 0x8(%r15), %rcx
movb (%r14), %dl
movb %dl, (%rcx,%rax)
incq %rax
cmpq %rax, %r12
jne 0x17f4
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r13d
cmpl %esi, %r13d
jae 0x188a
movq %rdx, %r14
movl %ebx, %r12d
cmpl %ebx, (%r15)
jae 0x1870
movl %ebx, (%r15)
movq %r12, %rdi
callq 0x1030
movq 0x8(%r15), %rbp
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1868
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x188a
movb (%r14), %cl
movq 0x8(%r15), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r12
jne 0x1878
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r13d
cmpl %esi, %r13d
jae 0x1912
movq %rdx, %r14
movl %ebx, %r12d
cmpl %ebx, (%r15)
jae 0x18f8
movl %ebx, (%r15)
movq %r12, %rdi
callq 0x1030
movq 0x8(%r15), %rbp
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x18f0
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1912
movb (%r14), %cl
movq 0x8(%r15), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r12
jne 0x1900
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r13d
cmpl %esi, %r13d
jae 0x199a
movq %rdx, %r14
movl %ebx, %r12d
cmpl %ebx, (%r15)
jae 0x1980
movl %ebx, (%r15)
movq %r12, %rdi
callq 0x1030
movq 0x8(%r15), %rbp
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1978
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x199a
movb (%r14), %cl
movq 0x8(%r15), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r12
jne 0x1988
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1a2c
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1a10
movl %ebx, (%r15)
leaq (,%r13,2), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
addq %r12, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1a08
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1a2c
movq 0x8(%r15), %rcx
movzwl (%r14), %edx
movw %dx, (%rcx,%rax,2)
incq %rax
cmpq %rax, %r13
jne 0x1a1c
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1abe
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1aa2
movl %ebx, (%r15)
leaq (,%r13,2), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
addq %r12, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1a9a
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1abe
movq 0x8(%r15), %rcx
movzwl (%r14), %edx
movw %dx, (%rcx,%rax,2)
incq %rax
cmpq %rax, %r13
jne 0x1aae
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1b4f
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1b35
movl %ebx, (%r15)
leaq (,%r13,4), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
shlq $0x2, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1b2d
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1b4f
movq 0x8(%r15), %rcx
movl (%r14), %edx
movl %edx, (%rcx,%rax,4)
incq %rax
cmpq %rax, %r13
jne 0x1b41
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1bdf
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1bc5
movl %ebx, (%r15)
leaq (,%r13,4), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
shlq $0x2, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1bbd
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1bdf
movq 0x8(%r15), %rcx
movl (%r14), %edx
movl %edx, (%rcx,%rax,4)
incq %rax
cmpq %rax, %r13
jne 0x1bd1
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1c70
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1c55
movl %ebx, (%r15)
leaq (,%r13,8), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
shlq $0x3, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1c4d
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1c70
movq 0x8(%r15), %rcx
movq (%r14), %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x1c61
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1d02
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1ce7
movl %ebx, (%r15)
leaq (,%r13,8), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
shlq $0x3, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1cdf
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1d02
movq 0x8(%r15), %rcx
movq (%r14), %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x1cf3
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1d94
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1d79
movl %ebx, (%r15)
leaq (,%r13,8), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
shlq $0x3, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1d71
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1d94
movq 0x8(%r15), %rcx
movq (%r14), %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x1d85
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1e26
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1e0b
movl %ebx, (%r15)
leaq (,%r13,8), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
shlq $0x3, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1e03
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1e26
movq 0x8(%r15), %rcx
movq (%r14), %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x1e17
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1ebb
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1e9d
movl %ebx, (%r15)
leaq (,%r13,4), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
shlq $0x2, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1e95
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1ebb
movq 0x8(%r15), %rcx
movss (%r14), %xmm0
movss %xmm0, (%rcx,%rax,4)
incq %rax
cmpq %rax, %r13
jne 0x1ea9
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1f4f
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1f31
movl %ebx, (%r15)
leaq (,%r13,8), %rdi
callq 0x1030
movq 0x8(%r15), %rbp
shlq $0x3, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1f29
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1f4f
movq 0x8(%r15), %rcx
movsd (%r14), %xmm0
movsd %xmm0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x1f3d
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
movl 0x4(%rdi), %r12d
cmpl %esi, %r12d
jae 0x1fe5
movq %rdx, %r14
movl %ebx, %r13d
cmpl %ebx, (%r15)
jae 0x1fc4
movl %ebx, (%r15)
movq %r13, %rdi
shlq $0x4, %rdi
callq 0x1030
movq 0x8(%r15), %rbp
shlq $0x4, %r12
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x10b0
testq %rbp, %rbp
je 0x1fbc
movq %rbp, %rdi
callq 0x10f0
movq (%rsp), %rax
movq %rax, 0x8(%r15)
movl 0x4(%r15), %eax
cmpl %ebx, %eax
jae 0x1fe5
subq %rax, %r13
shlq $0x4, %rax
addq 0x8(%r15), %rax
fldt (%r14)
fstpt (%rax)
addq $0x10, %rax
decq %r13
jne 0x1fd7
movl %ebx, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdx
subq 0x8(%rdi), %rdx
incq %rsi
movl 0x4(%rdi), %eax
notq %rdx
addq %rax, %rdx
movq %rbx, %rdi
callq 0x1110
decl 0x4(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdx
subq 0x8(%rdi), %rdx
addq $0x2, %rsi
movl 0x4(%rdi), %eax
notq %rdx
shrq %rdx
addq %rax, %rdx
addq %rdx, %rdx
movq %rbx, %rdi
callq 0x1110
decl 0x4(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdx
subq 0x8(%rdi), %rdx
addq $0x4, %rsi
movl 0x4(%rdi), %eax
notq %rdx
shrq $0x2, %rdx
addq %rax, %rdx
shlq $0x2, %rdx
movq %rbx, %rdi
callq 0x1110
decl 0x4(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdx
subq 0x8(%rdi), %rdx
addq $0x8, %rsi
movl 0x4(%rdi), %eax
notq %rdx
shrq $0x3, %rdx
addq %rax, %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
callq 0x1110
decl 0x4(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdx
subq 0x8(%rdi), %rdx
addq $0x10, %rsi
movl 0x4(%rdi), %eax
notq %rdx
shrq $0x4, %rdx
addq %rax, %rdx
shlq $0x4, %rdx
movq %rbx, %rdi
callq 0x1110
decl 0x4(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x23de
movq %rdx, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdx
movl 0x4(%rdi), %eax
subq %r14, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1110
movl %ebx, %eax
subl %r14d, %eax
addl %eax, 0x4(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x24dd
movq %rdx, %r14
movq %rdi, %r15
movq %rdx, %rax
subq 0x8(%rdi), %rax
movl 0x4(%rdi), %edx
shrq %rax
subq %rax, %rdx
addq %rdx, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1110
subq %rbx, %r14
shrq %r14
subl %r14d, 0x4(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x2568
movq %rdx, %r14
movq %rdi, %r15
movq %rdx, %rax
subq 0x8(%rdi), %rax
movl 0x4(%rdi), %edx
shrq $0x2, %rax
subq %rax, %rdx
shlq $0x2, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1110
subq %rbx, %r14
shrq $0x2, %r14
subl %r14d, 0x4(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x25f8
movq %rdx, %r14
movq %rdi, %r15
movq %rdx, %rax
subq 0x8(%rdi), %rax
movl 0x4(%rdi), %edx
shrq $0x3, %rax
subq %rax, %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1110
subq %rbx, %r14
shrq $0x3, %r14
subl %r14d, 0x4(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpq %rdx, %rsi
je 0x2718
movq %rdx, %r14
movq %rdi, %r15
movq %rdx, %rax
subq 0x8(%rdi), %rax
movl 0x4(%rdi), %edx
shrq $0x4, %rax
subq %rax, %rdx
shlq $0x4, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1110
subq %rbx, %r14
shrq $0x4, %r14
subl %r14d, 0x4(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %edi
movl 0x4(%rbx), %r15d
cmpl %edi, %r15d
jne 0x294e
shll $0x2, %edi
movl %edi, (%rbx)
shlq $0x2, %rdi
callq 0x1030
movq %rax, %r12
movq 0x8(%rbx), %r13
shlq $0x2, %r15
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x10b0
testq %r13, %r13
je 0x294a
movq %r13, %rdi
callq 0x10f0
movq %r12, 0x8(%rbx)
movl (%r14), %eax
movq 0x8(%rbx), %rcx
movl 0x4(%rbx), %edx
movl %eax, (%rcx,%rdx,4)
incl 0x4(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
leaq 0x38(%rsp), %rbx
movaps %xmm0, -0x18(%rbx)
movaps %xmm0, -0x28(%rbx)
movq $0x0, -0x8(%rbx)
movq %rbx, %rdi
callq 0x1110
movq $0x7, 0x30(%rbx)
xorl %r12d, %r12d
leaq 0x2a8c(%rip), %r13      # 0x3d88
leaq 0x10(%rsp), %rbp
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq $0x0, 0x8(%rsp)
movl $0x18, %edi
callq 0x10e0
movq %r13, (%rax)
movl %r12d, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq %rax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x10d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1347
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x1160
cmpq $0x0, 0x8(%rsp)
jne 0x13d6
incl %r12d
cmpl $0x7, %r12d
jne 0x1309
leaq 0x10(%rsp), %rdi
callq 0x1478
movq 0x2c67(%rip), %rdi      # 0x3fd8
leaq 0xc8c(%rip), %rsi       # 0x2004
movl $0xd, %edx
callq 0x1100
movq %rbx, %rdi
callq 0x1180
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13c3
jmp 0x13c3
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13b1
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x13c6
cmpq $0x0, 0x8(%rsp)
jne 0x13d6
movq %rax, %r14
movq %rbx, %rdi
callq 0x1180
movq %r14, %rdi
callq 0x1170
callq 0x1040
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x14e4
movb $0x1, 0x8(%r14)
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x15b0
decq %rax
movq %rax, 0x58(%rbx)
jne 0x159e
leaq 0x8(%rsp), %rdi
callq 0x1520
addq $0x28, %rbx
movq %rbx, %rdi
callq 0x1140
leaq 0x8(%rsp), %rdi
callq 0x14ce
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0xa6a(%rip), %rdi       # 0x2021
leaq 0xa6d(%rip), %rsi       # 0x202b
leaq 0xa70(%rip), %rcx       # 0x2035
movl $0x11, %edx
callq 0x1090
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x14ce
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c77
xorl %eax, %eax
movl %edi, %ecx
shrl %ecx
incl %eax
cmpl $0x3, %edi
movl %ecx, %edi
ja 0x5c6c
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbx
leaq 0x28(%rsp), %r12
movq 0x8(%r15), %r13
cmpq %r13, %rbx
je 0x660a
leaq 0x8(%rbx), %rsi
movq 0x8(%r14), %rcx
movq %r12, %rdi
xorl %edx, %edx
callq 0x54e0
movq %r12, %rdi
movq %r14, %rsi
callq 0x5050
movl %eax, %ebp
shrl $0x1f, %ebp
jmp 0x660c
xorl %ebp, %ebp
cmpq %r13, %rbx
je 0x662d
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x662d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x54c0
testb %bpl, %bpl
je 0x6638
addq $0x38, %rbx
jmp 0x65dd
movq %rbx, %r12
movq 0x8(%r15), %rbp
cmpq %rbp, %r12
je 0x6681
leaq 0x8(%r12), %rsi
movq 0x8(%r14), %rcx
xorl %r13d, %r13d
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x54e0
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x6689
testq %rdx, %rdx
je 0x6686
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x54d0
testl %eax, %eax
sete %r13b
jmp 0x6689
xorl %r13d, %r13d
jmp 0x6689
movb $0x1, %r13b
cmpq %rbp, %r12
je 0x66aa
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x66aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x54c0
addq $0x38, %r12
testb %r13b, %r13b
jne 0x663b
addq $-0x38, %r12
movq %rbx, %rax
movq %r12, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0xc5f7
// File: /workspace/github_cpp_makefile_star2_O1/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 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xdf36
movq %rbx, %rdi
movq %r15, %rsi
callq 0x65c1
movq %rax, %rbp
movq %rdx, %r13
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6731
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x54c0
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0xcbab
movq %rax, %r15
movq %rdx, %r14
movq 0x1587b(%rip), %r12     # 0x1bfc8
leaq 0xe909(%rip), %rsi      # 0x1505d
movl $0xf, %edx
movq %r12, %rdi
callq 0x5590
subq (%rbx), %rbp
sarq $0x3, %rbp
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5460
movq %rax, %rbp
leaq 0xe8e2(%rip), %rsi      # 0x1506d
movl $0x10, %edx
movq %rax, %rdi
callq 0x5590
subq (%rbx), %r13
sarq $0x3, %r13
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %r13
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5460
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5480
movsbl %al, %esi
movq %r13, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5300
leaq 0xe895(%rip), %rsi      # 0x1507e
movl $0xf, %edx
movq %r12, %rdi
callq 0x5590
subq (%rbx), %r15
sarq $0x3, %r15
movabsq $0x6db6db6db6db6db7, %r13 # imm = 0x6DB6DB6DB6DB6DB7
imulq %r13, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x5460
movq %rax, %r15
leaq 0xe86e(%rip), %rsi      # 0x1508e
movl $0x10, %edx
movq %rax, %rdi
callq 0x5590
subq (%rbx), %r14
sarq $0x3, %r14
imulq %r13, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x5460
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5480
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5300
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6896
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x54c0
movq %rbx, %rdi
callq 0x58e0