LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/SYLOH[P]ant-sim/antsim.cpp
// Function: ant::genPath(map)
void ant::genPath(map mMap){
	pathLen = 0;
	int curNode = 0;
	int nextNode;
	bool visitedNodes[numNodes];
	for (int i = 0;i<numNodes;i++){
		visitedNodes[i]= false;
	}
	path[0] = 0;
	
	for(int i = 1;i<numNodes; i++){
		
		visitedNodes[curNode]=true;
		//select from remaining nodes
		nextNode = selectNextNode(mMap, visitedNodes, curNode);
		pathLen += mMap.distArray[curNode][nextNode];
		path[i] = nextNode;
		curNode = nextNode;
		
	}
	//adds in the return completing the circuit
	pathLen += mMap.distArray[curNode][0];
	
	

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
andl $0x0, 0x190(%rdi)
movl 0x2fd2(%rip), %ecx      # 0x50c0
movq %rsp, %r15
movq %rcx, %rax
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
xorl %eax, %eax
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
cmpq %rax, %rdx
je 0x211d
movb $0x0, (%r15,%rax)
incq %rax
jmp 0x210e
andl $0x0, (%rbx)
xorl %eax, %eax
pushq $0x1
popq %r13
xorps %xmm0, %xmm0
movslq %ecx, %rcx
movslq %eax, %r12
cmpq %rcx, %r13
jge 0x2194
movb $0x1, (%r15,%r12)
subq $0x1d4c0, %rsp          # imm = 0x1D4C0
movl $0x3a98, %ecx           # imm = 0x3A98
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x21b8
addq $0x1d4c0, %rsp          # imm = 0x1D4C0
movslq %eax, %rcx
imulq $0x190, %r12, %rdx      # imm = 0x190
addq %r14, %rdx
movss (%rdx,%rcx,4), %xmm0
addss 0x190(%rbx), %xmm0
movss %xmm0, 0x190(%rbx)
movl %ecx, (%rbx,%r13,4)
incq %r13
movl 0x2f2e(%rip), %ecx      # 0x50c0
jmp 0x2129
imulq $0x190, %r12, %rax      # imm = 0x190
addss (%r14,%rax), %xmm0
movss %xmm0, 0x190(%rbx)
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SYLOH[P]ant-sim/antsim.cpp
// Function: ant::selectNextNode(map, bool*, int)
int ant::selectNextNode(map mMap, bool * visitedNodes, int curNode){
	float total=0;
	float nodeCounter=0;
	float randResult;
	
	//create the random horizon
	for (int i = 0; i < numNodes; i++){
		if(!visitedNodes[i]){
			total += mMap.trailArray[curNode][i]*pow((1/mMap.distArray[curNode][i]),distWeight);
		}
	}
	srand((unsigned)time(0)+id);//reseed the RNG
	randResult = total * ((float)rand()/(float)RAND_MAX);//rolls the dice
	
	for (int i= 0; i < numNodes; i++){
		if(!visitedNodes[i]){
			nodeCounter += mMap.trailArray[curNode][i]*pow((1/mMap.distArray[curNode][i]),distWeight);
			if (nodeCounter >= randResult){
				return i;
			}
		}
	}
	
	return 0;	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x40(%rsp), %r12
movl 0x2eea(%rip), %eax      # 0x50c0
movslq %edx, %rdx
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
imulq $0x190, %rdx, %r13      # imm = 0x190
leaq (%rsp,%r13), %rdx
addq $0x40, %rdx
xorps %xmm3, %xmm3
movss 0xe16(%rip), %xmm2      # 0x3010
cmpq %rcx, %rax
je 0x222f
cmpb $0x0, (%rbx,%rcx)
jne 0x222a
cvtss2sd 0x9c40(%rdx,%rcx,4), %xmm0
movaps %xmm2, %xmm1
divss (%rdx,%rcx,4), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm0, %xmm1
cvtss2sd %xmm3, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm3
incq %rcx
jmp 0x21fa
xorl %r14d, %r14d
xorl %edi, %edi
movss %xmm3, 0xc(%rsp)
callq 0x10b0
addl 0x194(%r15), %eax
movl %eax, %edi
callq 0x10c0
callq 0x1050
movss 0xc(%rsp), %xmm4
movss 0xdb0(%rip), %xmm3      # 0x3010
cvtsi2ss %eax, %xmm0
mulss 0xda8(%rip), %xmm0      # 0x3014
movl 0x2e4e(%rip), %eax      # 0x50c0
testl %eax, %eax
cmovlel %r14d, %eax
mulss %xmm0, %xmm4
addq %r13, %r12
xorps %xmm0, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x22c3
cmpb $0x0, (%rbx,%rcx)
jne 0x22bb
cvtss2sd 0x9c40(%r12,%rcx,4), %xmm1
movaps %xmm3, %xmm2
divss (%r12,%rcx,4), %xmm2
cvtss2sd %xmm2, %xmm2
mulsd %xmm1, %xmm2
cvtss2sd %xmm0, %xmm0
addsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
ucomiss %xmm4, %xmm0
jae 0x22c0
incq %rcx
jmp 0x2284
movl %ecx, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/SYLOH[P]ant-sim/antsim.cpp
// Function: map::loadFile(char const*)
int map::loadFile(const char* fileName){
	ifstream file;
	file.open(fileName);
	if(! file.is_open()){
		return 0;
	}
	for(int i =0;i<numNodes;i++){
		for(int j =0; j<numNodes;j++){
			file>>distArray[i][j];
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x10e0
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1070
leaq 0x78(%rsp), %rdi
callq 0x1030
xorl %ebp, %ebp
testb %al, %al
je 0x236b
movl 0x2d9a(%rip), %eax      # 0x50c0
xorl %r12d, %r12d
pushq $0x1
popq %rbp
movq %rsp, %r14
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x236b
movq %rbx, %r15
xorl %r13d, %r13d
movslq %eax, %rcx
cmpq %rcx, %r13
jge 0x235f
movq %r14, %rdi
movq %r15, %rsi
callq 0x1130
incq %r13
movl 0x2d67(%rip), %eax      # 0x50c0
addq $0x4, %r15
jmp 0x233d
incq %r12
addq $0x190, %rbx            # imm = 0x190
jmp 0x232f
movq %rsp, %rdi
callq 0x1040
movl %ebp, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2389
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/SYLOH[P]ant-sim/antsim.cpp
// Function: map::printDists()
void map::printDists(){
	for(int i =0;i<numNodes;i++){
		for(int j =0; j<numNodes;j++){
			cout<<distArray[i][j]<<" ";
		}
		cout<<endl;
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x2bac(%rip), %r14      # 0x4fd8
leaq 0xc0f(%rip), %r15       # 0x3042
movslq 0x2c86(%rip), %rax      # 0x50c0
cmpq %rax, %r12
jge 0x2481
xorl %r13d, %r13d
cltq
cmpq %rax, %r13
jge 0x246d
movss (%rbx,%r13,4), %xmm0
movq %r14, %rdi
callq 0x1080
movq %rax, %rdi
movq %r15, %rsi
callq 0x10d0
incq %r13
movl 0x2c55(%rip), %eax      # 0x50c0
jmp 0x2442
movq %r14, %rdi
callq 0x1060
incq %r12
addq $0x190, %rbx            # imm = 0x190
jmp 0x2433
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/SYLOH[P]ant-sim/antsim.cpp
// Function: colony::colony()
colony::colony(){
	mMap.loadFile();
	mMap.initTrails();
	mMap.initUpdate();
	shortestPathLen = INT_MAX;
	for(int i=0; i< numAnts;i++){
		ants[i].id = i;
	}

	mMap.printDists();
	cout<<endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1184(%rdi), %rbx
movq %rbx, %rdi
callq 0x22d4
movq %rbx, %rdi
callq 0x239c
movq %rbx, %rdi
callq 0x23da
movl $0x4f000000, 0x1180(%r14) # imm = 0x4F000000
addq $0x194, %r14            # imm = 0x194
xorl %eax, %eax
cmpq $0xa, %rax
je 0x24db
movl %eax, (%r14)
incq %rax
addq $0x198, %r14            # imm = 0x198
jmp 0x24c6
movq %rbx, %rdi
callq 0x2416
movq 0x2aee(%rip), %rdi      # 0x4fd8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/SYLOH[P]ant-sim/antsim.cpp
// Function: colony::colony(char const*)
colony::colony(const char * fileName){
	mMap.loadFile(fileName);
	mMap.initTrails();
	mMap.initUpdate();
	shortestPathLen = INT_MAX;
	for(int i=0; i< numAnts;i++){
		ants[i].id = i;
	}

	mMap.printDists();
	cout<<endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1184(%rdi), %rbx
movq %rbx, %rdi
callq 0x22e0
movq %rbx, %rdi
callq 0x239c
movq %rbx, %rdi
callq 0x23da
movl $0x4f000000, 0x1180(%r14) # imm = 0x4F000000
addq $0x194, %r14            # imm = 0x194
xorl %eax, %eax
cmpq $0xa, %rax
je 0x2545
movl %eax, (%r14)
incq %rax
addq $0x198, %r14            # imm = 0x198
jmp 0x2530
movq %rbx, %rdi
callq 0x2416
movq 0x2a84(%rip), %rdi      # 0x4fd8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_cpp_makefile_star2_O2/SYLOH[P]ant-sim/antsim.cpp
// Function: colony::evaporateTrails()
void colony::evaporateTrails(){
	for(int i =0;i<numNodes;i++){
		for(int j =0; j<numNodes;j++){
			mMap.trailArray[i][j] *= (1-evaporationCoeff);
			if(mMap.trailArray[i][j] < minValue){
				mMap.trailArray[i][j]= minValue;
			}			
		}
	}
}

// Assembly:
movl 0x2b5a(%rip), %eax      # 0x50c0
addq $0xadc4, %rdi           # imm = 0xADC4
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
movsd 0xaa7(%rip), %xmm0      # 0x3028
cmpq %rdx, %rcx
je 0x25b7
xorl %esi, %esi
cmpq %rsi, %rax
je 0x25ab
cvtss2sd (%rdi,%rsi,4), %xmm1
mulsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
xorps %xmm2, %xmm2
maxss %xmm1, %xmm2
movss %xmm2, (%rdi,%rsi,4)
incq %rsi
jmp 0x2588
incq %rcx
addq $0x190, %rdi            # imm = 0x190
jmp 0x2581
retq
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/main.cpp
// Function: vector_smoketest()
void vector_smoketest() {
  gtl::vector<memcheck> vect;
  assert(vect.capacity() == 0);
  assert(vect.size() == 0);
  size_t n = 20;
  for (size_t i = 1; i <= n; ++i) {
    memcheck el;
    vect.push_back(std::move(el));
  }
  assert(memcheck::get_counter() == vect.size());
  assert(vect.size() == n);
  memcheck el;
  vect[10] = el;
  const gtl::vector<memcheck> vect2(vect);
  memcheck by_index = vect2[0];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0x10(%rsp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
pushq $0x14
popq %r15
leaq 0x28(%rsp), %r14
subq $0x1, %r15
jb 0x139e
movq %r14, %rdi
callq 0x6c00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a46
movq %r14, %rdi
callq 0x6c0e
jmp 0x137b
callq 0x6c9c
cmpq 0x20(%rsp), %rax
jne 0x144f
cmpq $0x14, %rax
jne 0x1468
leaq 0x8(%rsp), %rdi
callq 0x6c00
leaq 0x4(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6c84
leaq 0x10(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x1a84
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x6c90
leaq 0x4(%rsp), %rdi
callq 0x6c0e
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1ab6
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1b1a
leaq 0xc(%rsp), %rdi
movq %rax, %rsi
callq 0x6c84
leaq 0xc(%rsp), %rdi
callq 0x6c0e
leaq 0x28(%rsp), %rdi
callq 0x1a08
leaq 0x8(%rsp), %rdi
callq 0x6c0e
leaq 0x10(%rsp), %rdi
callq 0x1a08
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5c26(%rip), %rdi      # 0x707c
leaq 0x5be4(%rip), %rsi      # 0x7041
leaq 0x5c00(%rip), %rcx      # 0x7064
pushq $0x1b
jmp 0x147f
leaq 0x5c34(%rip), %rdi      # 0x70a3
leaq 0x5bcb(%rip), %rsi      # 0x7041
leaq 0x5be7(%rip), %rcx      # 0x7064
pushq $0x1c
popq %rdx
callq 0x1070
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1a08
jmp 0x14a8
jmp 0x14a5
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x6c0e
jmp 0x14a8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x14c0
jmp 0x14b3
jmp 0x14b3
movq %rax, %rbx
jmp 0x14c5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6c0e
leaq 0x10(%rsp), %rdi
callq 0x1a08
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/main.cpp
// Function: vector_value_semantics()
void vector_value_semantics() {
  gtl::vector<memcheck> vect;
  size_t n = 100;
  for (size_t i = 1; i <= n; ++i) {
    memcheck el;
    vect.push_back(el);
  }
  gtl::value_semantics_memory_test(vect);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x10(%rsp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
pushq $0x64
popq %r15
leaq 0xc(%rsp), %r14
subq $0x1, %r15
jb 0x151c
movq %r14, %rdi
callq 0x6c00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b4c
movq %r14, %rdi
callq 0x6c0e
jmp 0x14f9
leaq 0x10(%rsp), %rdi
callq 0x1b8a
leaq 0x10(%rsp), %rdi
callq 0x1a08
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x153c
movq %rax, %rbx
jmp 0x154e
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x6c0e
leaq 0x10(%rsp), %rdi
callq 0x1a08
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/main.cpp
// Function: vector_removal_operations()
void vector_removal_operations() {
  gtl::vector<memcheck> vect;
  size_t n = 3;
  for (size_t i = 1; i <= n; ++i) {
    memcheck el;
    vect.push_back(el);
  }
  assert(memcheck::get_counter() == n);
  for (size_t i = 1; i <= n; ++i) {
    vect.pop_back();
  }
  assert(memcheck::get_counter() == 0);

  gtl::vector<int> vect_int;
  int el = 100;
  vect_int.push_back(el);
  int int_from_vect = vect_int.pop_back();
  assert(int_from_vect == el);

  vect_int.push_back(1);
  vect_int.push_back(2);
  vect_int.swap_remove(0);
  assert(vect_int.size() == 1);
  assert(vect_int[0] == 2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0x30(%rsp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
pushq $0x3
popq %r15
leaq 0x10(%rsp), %r14
subq $0x1, %r15
jb 0x15a5
movq %r14, %rdi
callq 0x6c00
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b4c
movq %r14, %rdi
callq 0x6c0e
jmp 0x1582
callq 0x6c9c
cmpq $0x3, %rax
jne 0x1692
pushq $0x3
popq %r15
leaq 0x2c(%rsp), %rbx
leaq 0x30(%rsp), %r14
subq $0x1, %r15
jb 0x15dd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d64
movq %rbx, %rdi
callq 0x6c0e
jmp 0x15c2
callq 0x6c9c
testq %rax, %rax
jne 0x16ab
leaq 0x10(%rsp), %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
leaq 0xc(%rsp), %rsi
movl $0x64, (%rsi)
callq 0x1dcc
leaq 0x10(%rsp), %rdi
callq 0x1e04
cmpl 0xc(%rsp), %eax
jne 0x16c4
leaq 0x8(%rsp), %rsi
movl $0x1, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1e3e
leaq 0x8(%rsp), %rsi
movl $0x2, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1e3e
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1e76
cmpq $0x1, 0x10(%rbx)
jne 0x16dd
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x1ede
cmpl $0x2, (%rax)
jne 0x16f6
leaq 0x10(%rsp), %rdi
callq 0x1f10
leaq 0x30(%rsp), %rdi
callq 0x1a08
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5a1b(%rip), %rdi      # 0x70b4
leaq 0x59a1(%rip), %rsi      # 0x7041
leaq 0x5a2a(%rip), %rcx      # 0x70d1
pushq $0x34
jmp 0x170d
leaq 0x5972(%rip), %rdi      # 0x7024
leaq 0x5988(%rip), %rsi      # 0x7041
leaq 0x5a11(%rip), %rcx      # 0x70d1
pushq $0x38
jmp 0x170d
leaq 0x5a27(%rip), %rdi      # 0x70f2
leaq 0x596f(%rip), %rsi      # 0x7041
leaq 0x59f8(%rip), %rcx      # 0x70d1
pushq $0x3e
jmp 0x170d
leaq 0x5a22(%rip), %rdi      # 0x7106
leaq 0x5956(%rip), %rsi      # 0x7041
leaq 0x59df(%rip), %rcx      # 0x70d1
pushq $0x43
jmp 0x170d
leaq 0x5a1e(%rip), %rdi      # 0x711b
leaq 0x593d(%rip), %rsi      # 0x7041
leaq 0x59c6(%rip), %rcx      # 0x70d1
pushq $0x44
popq %rdx
callq 0x1070
jmp 0x1717
jmp 0x1717
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1f10
jmp 0x173c
jmp 0x172a
jmp 0x172a
movq %rax, %rbx
jmp 0x173c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6c0e
leaq 0x30(%rsp), %rdi
callq 0x1a08
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/main.cpp
// Function: test_vector()
void test_vector() {
  std::cout << "vector" << std::endl;
  vector_smoketest();
  vector_reserve();
  vector_value_semantics();
  vector_removal_operations();
}

// Assembly:
pushq %rax
movq 0xb882(%rip), %rdi      # 0xcfd8
leaq 0x59cf(%rip), %rsi      # 0x712c
callq 0x10e0
movq %rax, %rdi
callq 0x1060
callq 0x1359
callq 0x12ec
callq 0x14d7
popq %rax
jmp 0x1560
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/main.cpp
// Function: test_vector_map()
void test_vector_map() {
  std::cout << "vector_map" << std::endl;
  gtl::smoketest_map< gtl::vector_map<int, int> > test;
  test.smoketest();
  gtl::smoketest_map< gtl::vector_map<int, memcheck> > test_value;
  test_value.value_semantics();
}

// Assembly:
pushq %rax
movq 0xb851(%rip), %rdi      # 0xcfd8
leaq 0x59bc(%rip), %rsi      # 0x714a
callq 0x10e0
movq %rax, %rdi
callq 0x1060
leaq 0x7(%rsp), %rdi
callq 0x1f1e
leaq 0x6(%rsp), %rdi
callq 0x21fc
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/main.cpp
// Function: test_hash_map()
void test_hash_map() {
  std::cout << "hash_map" << std::endl;
  gtl::smoketest_map< gtl::hash_map<int, int> > test;
  test.smoketest();
  gtl::smoketest_map< gtl::hash_map<int, memcheck> > test_value;
  test_value.value_semantics();
}

// Assembly:
pushq %rax
movq 0xb81f(%rip), %rdi      # 0xcfd8
leaq 0x59b8(%rip), %rsi      # 0x7178
callq 0x10e0
movq %rax, %rdi
callq 0x1060
leaq 0x7(%rsp), %rdi
callq 0x22c6
leaq 0x6(%rsp), %rdi
callq 0x25b6
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/main.cpp
// Function: map_comparison()
void map_comparison() {
  std::cout << "vector_map vs vector_map" << std::endl;
  gtl::map_comparison_test< gtl::vector_map<int, int>, gtl::vector_map<int, int> > test;
  test.compare_random_queries();
  std::cout << "vector_map vs hash_map" << std::endl;
  gtl::map_comparison_test< gtl::vector_map<int, int>, gtl::hash_map<int, int> > test2;
  test2.compare_random_queries();
  std::cout << "tree_map vs hash_map" << std::endl;
  gtl::map_comparison_test< gtl::tree_map<int, int>, gtl::hash_map<int, int> > test3;
  test3.compare_random_queries();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0xb7c1(%rip), %rbx      # 0xcfd8
leaq 0x591e(%rip), %rsi      # 0x713c
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1060
leaq 0xf(%rsp), %rdi
callq 0x2920
leaq 0x5916(%rip), %rsi      # 0x7155
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1060
leaq 0xe(%rsp), %rdi
callq 0x2b94
leaq 0x590c(%rip), %rsi      # 0x716c
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1060
leaq 0xd(%rsp), %rdi
callq 0x2e08
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/main.cpp
// Function: main
int main(int argc, char* argv[]) {
  std::srand(std::time(0));
  // test_vector();
  // test_vector_map();
  // test_hash_map();
  // test_tree_map();
  // map_comparison();

  std::ofstream f("bin/benchmark.dat");
  f << "Map Addition Search Search+Add+Delete Deletion\n";
  std::cout << "benchmark vector map" << std::endl;
  f << "VectorMap" << " " << gtl::benchmark<gtl::vector_map<int, int>>();
  std::cout << "benchmark hash map" << std::endl;
  f << "HashMap" << " " << gtl::benchmark<gtl::hash_map<int, int, std::hash<int>>>();
  std::cout << "benchmark tree map" << std::endl;
  f << "TreeMap" << " " << gtl::benchmark<gtl::tree_map<int, int>>();
  return 0;
}

// Assembly:
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
xorl %edi, %edi
callq 0x10b0
movl %eax, %edi
callq 0x10d0
leaq 0x58e4(%rip), %rsi      # 0x7181
leaq 0x20(%rsp), %rbx
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x1100
leaq 0x58df(%rip), %rsi      # 0x7193
movq %rbx, %rdi
callq 0x10e0
movq 0xb715(%rip), %rdi      # 0xcfd8
leaq 0x58f9(%rip), %rsi      # 0x71c3
callq 0x10e0
movq %rax, %rdi
callq 0x1060
leaq 0x58fa(%rip), %rsi      # 0x71d8
leaq 0x20(%rsp), %rdi
callq 0x10e0
leaq 0x58f3(%rip), %rsi      # 0x71e2
movq %rax, %rdi
callq 0x10e0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x307f
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10a0
movq %rsp, %rdi
callq 0x1050
movq 0xb6bc(%rip), %rdi      # 0xcfd8
leaq 0x58c1(%rip), %rsi      # 0x71e4
callq 0x10e0
movq %rax, %rdi
callq 0x1060
leaq 0x58c0(%rip), %rsi      # 0x71f7
leaq 0x20(%rsp), %rdi
callq 0x10e0
leaq 0x589a(%rip), %rsi      # 0x71e2
movq %rax, %rdi
callq 0x10e0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x332b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10a0
movq %rsp, %rdi
callq 0x1050
movq 0xb663(%rip), %rdi      # 0xcfd8
leaq 0x5883(%rip), %rsi      # 0x71ff
callq 0x10e0
movq %rax, %rdi
callq 0x1060
leaq 0x5882(%rip), %rsi      # 0x7212
leaq 0x20(%rsp), %rdi
callq 0x10e0
leaq 0x5841(%rip), %rsi      # 0x71e2
movq %rax, %rdi
callq 0x10e0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35e2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10a0
movq %rsp, %rdi
callq 0x1050
leaq 0x20(%rsp), %rdi
callq 0x1140
xorl %eax, %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbx
retq
jmp 0x19e4
jmp 0x19f3
jmp 0x19e4
jmp 0x19f3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1050
jmp 0x19f6
jmp 0x19f3
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1140
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/test_map.h
// Function: void gtl::value_semantics_memory_test<gtl::vector<memcheck>>(gtl::vector<memcheck>&)
void value_semantics_memory_test(T & obj) {
  /*
   * Memcheck type has to be used in order to run this test
   */
  size_t old_counter = memcheck::get_counter();
  T obj2(obj);
  assert(memcheck::get_counter() == old_counter*2);
  T obj3(std::move(obj));
  assert(memcheck::get_counter() == old_counter*2);
  T obj4;
  obj4 = obj3;
  assert(memcheck::get_counter() == old_counter*3);
  T obj5;
  obj5 = std::move(obj3);
  assert(memcheck::get_counter() == old_counter*3);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %r14
callq 0x6c9c
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x1ab6
callq 0x6c9c
movq %rax, %r15
leaq (%rbx,%rbx), %rax
cmpq %rax, %r15
jne 0x1cba
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x3916
callq 0x6c9c
cmpq %r15, %rax
jne 0x1cd3
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1ab6
leaq 0x88(%rsp), %rdi
movq (%rdi), %rax
andq $0x0, (%rdi)
movq %rax, 0x20(%rsp)
movups 0x8(%rdi), %xmm0
movups %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
callq 0x1a08
callq 0x6c9c
movq %rax, %r14
leaq (%rbx,%rbx,2), %rax
cmpq %rax, %r14
jne 0x1cec
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3916
leaq 0x70(%rsp), %rdi
movq (%rdi), %rax
andq $0x0, (%rdi)
movq %rax, (%rsp)
movups 0x8(%rdi), %xmm0
movups %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
callq 0x1a08
callq 0x6c9c
cmpq %r14, %rax
jne 0x1d05
movq %rsp, %rdi
callq 0x1a08
leaq 0x20(%rsp), %rdi
callq 0x1a08
leaq 0x40(%rsp), %rdi
callq 0x1a08
leaq 0x58(%rsp), %rdi
callq 0x1a08
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x560a(%rip), %rdi      # 0x72cb
leaq 0x562c(%rip), %rsi      # 0x72f4
leaq 0x5634(%rip), %rcx      # 0x7303
pushq $0x45
jmp 0x1d1c
leaq 0x55f1(%rip), %rdi      # 0x72cb
leaq 0x5613(%rip), %rsi      # 0x72f4
leaq 0x561b(%rip), %rcx      # 0x7303
pushq $0x47
jmp 0x1d1c
leaq 0x5657(%rip), %rdi      # 0x734a
leaq 0x55fa(%rip), %rsi      # 0x72f4
leaq 0x5602(%rip), %rcx      # 0x7303
pushq $0x4a
jmp 0x1d1c
leaq 0x563e(%rip), %rdi      # 0x734a
leaq 0x55e1(%rip), %rsi      # 0x72f4
leaq 0x55e9(%rip), %rcx      # 0x7303
pushq $0x4d
popq %rdx
callq 0x1070
movq %rax, %rbx
jmp 0x1d48
jmp 0x1d29
movq %rax, %rbx
jmp 0x1d52
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a08
jmp 0x1d3e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1a08
leaq 0x40(%rsp), %rdi
callq 0x1a08
leaq 0x58(%rsp), %rdi
callq 0x1a08
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/vector.h
// Function: gtl::vector<memcheck>::pop_back()
T vector<T>::pop_back() {
  assert(size_ != 0 && "Empty vector");
  T last_element = std::move(array_[--size_]);
  array_[size_].~T();
  return last_element;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x1dac
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1(%rax), %rcx
movq %rcx, 0x10(%rsi)
leaq -0x4(,%rax,4), %rsi
addq 0x8(%r14), %rsi
callq 0x6c64
movq 0x10(%r14), %rdi
shlq $0x2, %rdi
addq 0x8(%r14), %rdi
callq 0x6c0e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x55c0(%rip), %rdi      # 0x7373
leaq 0x5480(%rip), %rsi      # 0x723a
leaq 0x55cf(%rip), %rcx      # 0x7390
movl $0xa6, %edx
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/vector.h
// Function: gtl::vector<int>::swap_remove(unsigned long)
void vector<T>::swap_remove(size_t index) {
  assert(size_ != 0 && "Empty vector");
  assert(index < size_ && "Out of bound");
  std::swap(array_[size_ - 1], array_[index]);
  pop_back();
}

// Assembly:
pushq %rax
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1e9f
cmpq %rsi, %rax
jbe 0x1ebe
movq 0x8(%rdi), %rcx
movl -0x4(%rcx,%rax,4), %edx
movl (%rcx,%rsi,4), %r8d
movl %r8d, -0x4(%rcx,%rax,4)
movl %edx, (%rcx,%rsi,4)
popq %rax
jmp 0x1e04
leaq 0x54cd(%rip), %rdi      # 0x7373
leaq 0x538d(%rip), %rsi      # 0x723a
leaq 0x5538(%rip), %rcx      # 0x73ec
movl $0xae, %edx
callq 0x1070
leaq 0x5355(%rip), %rdi      # 0x721a
leaq 0x536e(%rip), %rsi      # 0x723a
leaq 0x5519(%rip), %rcx      # 0x73ec
movl $0xaf, %edx
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/test_map.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> gtl::benchmark<gtl::hash_map<int, int, std::hash<int>>>()
std::string benchmark() {
  T map;
  return
    std::to_string(benchmark_operation<T, addition<T>>(map)) + " " +
    std::to_string(benchmark_operation<T, search<T>>(map)) + " " +
    std::to_string(benchmark_operation<T, mixed<T>>(map)) + " " +
    std::to_string(benchmark_operation<T, deletion<T>>(map)) + " " +
    "\n";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %r14
leaq 0x168(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x160(%rsp), %rdi
callq 0x5f9b
leaq 0x60(%rsp), %rdi
movq %rax, %rsi
callq 0x5b48
leaq 0x3e77(%rip), %rdx      # 0x71e2
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x5ac2
leaq 0x160(%rsp), %rdi
callq 0x6002
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x5b48
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x5ae1
leaq 0x3e2a(%rip), %rdx      # 0x71e2
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x5ac2
leaq 0x160(%rsp), %rdi
callq 0x6069
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x5b48
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x5ae1
leaq 0x3dda(%rip), %rdx      # 0x71e2
leaq 0x100(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x5ac2
leaq 0x160(%rsp), %rdi
callq 0x60d0
movq %rsp, %rdi
movq %rax, %rsi
callq 0x5b48
leaq 0x120(%rsp), %rdi
leaq 0x100(%rsp), %rsi
movq %rsp, %rdx
callq 0x5ae1
leaq 0x3d8e(%rip), %rdx      # 0x71e2
leaq 0x140(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x5ac2
leaq 0x3d51(%rip), %rdx      # 0x71c1
leaq 0x140(%rsp), %rsi
movq %r14, %rdi
callq 0x5ac2
leaq 0x140(%rsp), %rdi
callq 0x1050
leaq 0x120(%rsp), %rdi
callq 0x1050
movq %rsp, %rdi
callq 0x1050
leaq 0x100(%rsp), %rdi
callq 0x1050
leaq 0xe0(%rsp), %rdi
callq 0x1050
leaq 0x20(%rsp), %rdi
callq 0x1050
leaq 0xc0(%rsp), %rdi
callq 0x1050
leaq 0xa0(%rsp), %rdi
callq 0x1050
leaq 0x40(%rsp), %rdi
callq 0x1050
leaq 0x80(%rsp), %rdi
callq 0x1050
leaq 0x60(%rsp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x63c8
movq %r14, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x140(%rsp), %rdi
callq 0x1050
jmp 0x352c
movq %rax, %r14
leaq 0x120(%rsp), %rdi
callq 0x1050
jmp 0x353e
movq %rax, %r14
movq %rsp, %rdi
callq 0x1050
jmp 0x3564
movq %rax, %r14
jmp 0x3571
movq %rax, %r14
jmp 0x357e
movq %rax, %r14
jmp 0x359a
movq %rax, %r14
jmp 0x35a7
movq %rax, %r14
jmp 0x35be
movq %rax, %r14
leaq 0x100(%rsp), %rdi
callq 0x1050
leaq 0xe0(%rsp), %rdi
callq 0x1050
leaq 0x20(%rsp), %rdi
callq 0x1050
jmp 0x358d
movq %rax, %r14
leaq 0xc0(%rsp), %rdi
callq 0x1050
leaq 0xa0(%rsp), %rdi
callq 0x1050
leaq 0x40(%rsp), %rdi
callq 0x1050
leaq 0x80(%rsp), %rdi
callq 0x1050
leaq 0x60(%rsp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x63c8
movq %r14, %rdi
callq 0x1170
movq %rax, %r14
jmp 0x35b1
movq %rax, %r14
jmp 0x35c8
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/vector_map.h
// Function: gtl::vector_map<int, memcheck>::add(int const&, memcheck)
bool vector_map<K, V>::add(K const &key, V value) {
  V * old_value = lookup(key);
  if (!bool(old_value)) {
    Entry new_entry = {key, value};
    vector_.push_back(new_entry);
    return true;
  }
  *old_value = value;
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
callq 0x4142
movq %rax, %rbx
testq %rax, %rax
je 0x3ec9
leaq 0xc(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6c84
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6c90
leaq 0xc(%rsp), %rdi
jmp 0x3ef0
movl (%r14), %eax
leaq 0x14(%rsp), %r14
movl %eax, -0x4(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6c84
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x4104
movq %r14, %rdi
callq 0x6c0e
testq %rbx, %rbx
sete %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
jmp 0x3f17
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x6c0e
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/vector_map.h
// Function: gtl::vector_map<int, int>::remove(int const&)
bool vector_map<K, V>::remove(K const &key) {
  size_t index = find(key);
  if (index == size()) return false;
  vector_.swap_remove(index);
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3be4
movq %rax, %r14
movq 0x10(%rbx), %r15
cmpq %r15, %rax
je 0x3aec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3de0
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/hash_map.h
// Function: gtl::hash_map<int, memcheck, gtl::default_hash<int>>::add(int const&, memcheck const&)
bool hash_map<K, V, H>::add(K const &key, V const &value) {
  if (is_overloaded()) {
    reallocate();
  }
  bool result = add_to_vector(key, value, vector_);
  if (result) size_++;
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4d76
testb %al, %al
je 0x4b36
movq %rbx, %rdi
callq 0x4dd8
leaq 0xc(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6c84
leaq 0x8(%rbx), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4f60
movl %eax, %ebp
leaq 0xc(%rsp), %rdi
callq 0x6c0e
testb %bpl, %bpl
je 0x4b6d
incq 0x20(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x6c0e
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/hash_map.h
// Function: gtl::hash_map<int, int, gtl::default_hash<int>>::remove(int const&)
bool hash_map<K, V, H>::remove(K const &key) {
  size_t index = find(key);
  if (index == capacity()) return false;
  vector_[index] = {K(), V(), true, true};
  size_--;
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x45da
movq %rax, %r14
movq 0x8(%rbx), %r15
cmpq %r15, %rax
je 0x44d3
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x4964
andq $0x0, (%rax)
movw $0x101, 0x8(%rax)       # imm = 0x101
decq 0x20(%rbx)
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/hash_map.h
// Function: gtl::hash_map<int, int, gtl::default_hash<int>>::find(int const&) const
size_t hash_map<K, V, H>::find(K const &key) const {
  if (vector_.capacity() == 0) return 0;
  size_t insertion_index = insertion_point(vector_, key);
  if (vector_[insertion_index].is_empty) return capacity();
  return insertion_index;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x4612
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rsi
callq 0x461e
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x46ea
cmpb $0x0, 0x8(%rax)
je 0x4615
movq 0x8(%rbx), %r14
jmp 0x4615
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/hash_map.h
// Function: gtl::hash_map<int, int, gtl::default_hash<int>>::insertion_point(gtl::vector<gtl::hash_map<int, int, gtl::default_hash<int>>::Entry> const&, int const&) const
size_t hash_map<K, V, H>::insertion_point(vector<Entry> const & vect, K const &key) const {
  size_t initial_hash = hash(key, vect.capacity());
  for (size_t i = initial_hash; i < vect.capacity() + initial_hash; ++i) {
    size_t ind = i % vect.capacity();
    bool is_empty = vect[ind].is_empty && !vect[ind].is_deleted;
    bool is_found = !vect[ind].is_empty && vect[ind].key == key;
    if (is_empty || is_found) return ind;
  }
  assert(false && "Insertion point not found");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x4644
movslq (%rbx), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r15
jmp 0x4647
xorl %r15d, %r15d
movq %r15, %r12
movq (%r14), %rcx
leaq (%rcx,%r15), %rax
cmpq %rax, %r12
jae 0x46cc
xorl %ebp, %ebp
movq %r12, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r13
movq %r14, %rdi
movq %rdx, %rsi
callq 0x46ea
cmpb $0x1, 0x8(%rax)
jne 0x4687
movq %r14, %rdi
movq %r13, %rsi
callq 0x46ea
movb 0x9(%rax), %bpl
xorb $0x1, %bpl
movq %r14, %rdi
movq %r13, %rsi
callq 0x46ea
cmpb $0x0, 0x8(%rax)
je 0x469c
xorl %eax, %eax
jmp 0x46ae
movq %r14, %rdi
movq %r13, %rsi
callq 0x46ea
movl (%rax), %eax
cmpl (%rbx), %eax
sete %al
orb %al, %bpl
incq %r12
testb $0x1, %bpl
je 0x464a
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x317d(%rip), %rdi      # 0x7850
leaq 0x319b(%rip), %rsi      # 0x7875
leaq 0x31a3(%rip), %rcx      # 0x7884
pushq $0x6f
popq %rdx
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/hash_map.h
// Function: gtl::hash_map<int, memcheck, gtl::default_hash<int>>::reallocate()
void hash_map<K, V, H>::reallocate() {
  vector<Entry> new_vector;
  size_t capacity = vector_.capacity() == 0 ? 5 : vector_.capacity()*2;
  new_vector.reserve(capacity);
  for (size_t i = 0; i < new_vector.capacity(); ++i) {
    new_vector.push_back({K(), V(), true, false});
  }
  size_ = 0;
  for (size_t i = 0; i < vector_.capacity(); ++i) {
    if (!vector_[i].is_empty) {
      add_to_vector(vector_[i].key, vector_[i].value, new_vector);
    }
  }
  vector_ = std::move(new_vector);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
andq $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rdi), %rax
leaq (%rax,%rax), %rcx
testq %rax, %rax
pushq $0x5
popq %rsi
cmovneq %rcx, %rsi
leaq 0x50(%rsp), %rdi
callq 0x50bc
leaq 0x8(%rbx), %r14
leaq 0x50(%rsp), %rdi
callq 0x4ffe
leaq 0x30(%rsp), %r15
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
leaq 0x2c(%rsp), %r13
cmpq 0x10(%rsp), %rbp
jae 0x4e65
andl $0x0, 0x2c(%rsp)
movq %r15, %rdi
callq 0x6c00
movw $0x1, 0x34(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x503e
movq %r15, %rdi
callq 0x6c0e
incq %rbp
jmp 0x4e32
andq $0x0, 0x20(%rbx)
xorl %r15d, %r15d
leaq 0xc(%rsp), %r12
leaq 0x10(%rsp), %r13
cmpq (%r14), %r15
jae 0x4ed0
movq %r14, %rdi
movq %r15, %rsi
callq 0x507c
cmpb $0x0, 0x8(%rax)
jne 0x4ecb
movq %r14, %rdi
movq %r15, %rsi
callq 0x507c
movq %rax, %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x507c
leaq 0x4(%rax), %rsi
movq %r12, %rdi
callq 0x6c84
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x4f60
movq %r12, %rdi
callq 0x6c0e
incq %r15
jmp 0x4e77
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x50ac
movq 0x8(%rbx), %rax
leaq 0x38(%rsp), %rdi
movq (%rdi), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%rdi)
movq 0x10(%rbx), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rdi)
movq 0x18(%rbx), %rax
movq 0x10(%rdi), %rcx
movq %rcx, 0x18(%rbx)
movq %rax, 0x10(%rdi)
callq 0x4ffe
leaq 0x10(%rsp), %rdi
callq 0x4ffe
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f4b
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x4f44
jmp 0x4f4b
movq %rax, %rbx
movq %r15, %rdi
callq 0x6c0e
jmp 0x4f4e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4ffe
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/hash_map.h
// Function: gtl::hash_map<int, memcheck, gtl::default_hash<int>>::add_to_vector(int const&, memcheck, gtl::vector<gtl::hash_map<int, memcheck, gtl::default_hash<int>>::Entry>&)
bool hash_map<K, V, H>::add_to_vector(K const &key, V value, vector<Entry> & vect) {
  if (vector_.capacity() == 0) return 0;
  size_t ind = insertion_point(vect, key);
  bool result = vect[ind].is_empty;
  vect[ind] = {key, value, false, false};
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x4fd8
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rcx, %rsi
movq %r15, %rdx
callq 0x525c
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x507c
movb 0x8(%rax), %bl
movl (%r15), %eax
leaq 0x8(%rsp), %r15
movl %eax, -0x4(%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x6c84
andw $0x0, 0x4(%r15)
movq %r14, %rdi
movq %r13, %rsi
callq 0x507c
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x5328
movq %r15, %rdi
callq 0x6c0e
jmp 0x4fda
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x6c0e
movq %rbx, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::add(int, int)
bool tree_map<K, V>::add(K key, V value) {
  bool result = false;
  root_ = add(root_, key, value, result);
  root_->is_red = false;
  if (result) ++size_;
  return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ecx
movl %esi, %edx
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0xf(%rsp), %r14
movb %bpl, (%r14)
movq (%rdi), %rsi
movq %r14, %r8
callq 0x5650
movq %rax, (%rbx)
movb %bpl, 0x8(%rax)
movb (%r14), %al
cmpb $0x1, %al
jne 0x5502
incq 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::remove(int const&)
bool tree_map<K, V>::remove(K const & key) {
  bool result = true;
  root_ = remove(root_, key, result);
  if (root_) root_->is_red = false;
  if (result) --size_;
  return result;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0xf(%rsp), %rcx
movb $0x1, (%rcx)
movq (%rdi), %rsi
callq 0x582e
movq %rax, (%rbx)
testq %rax, %rax
je 0x5533
movb $0x0, 0x8(%rax)
movb 0xf(%rsp), %al
cmpb $0x1, %al
jne 0x553f
decq 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::get(gtl::tree_map<int, int>::Node*, int const&) const
auto tree_map<K, V>::get(Node * node, K const & key) const -> Node * {
  if (!node) return nullptr;
  if (node->key == key) return node;
  if (key < node->key) return get(node->left, key);
  return get(node->right, key);
}

// Assembly:
movq %rsi, %rax
movl (%rdx), %ecx
testq %rax, %rax
je 0x564f
movl (%rax), %edx
cmpl %ecx, %edx
je 0x564f
setle %dl
movzbl %dl, %edx
movq 0x10(%rax,%rdx,8), %rax
jmp 0x5637
retq
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::add(gtl::tree_map<int, int>::Node*, int, int, bool&)
typename tree_map<K, V>::Node * tree_map<K, V>::add(Node * node, K key, V value, bool & result) {
  if (!node) {
    result = true;
    return new Node(key, value);
  }

  if (key == node->key) node->value = value;
  else if (key < node->key) node->left = add(node->left, key, value, result);
  else node->right = add(node->right, key, value, result);

  return fix_up(node);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r15d
testq %rsi, %rsi
je 0x5671
movq %rsi, %rbx
movq %rdi, %r14
cmpl %r15d, (%rsi)
jne 0x5699
movl %ebp, 0x4(%rbx)
jmp 0x56c7
movb $0x1, %bl
movb %bl, (%r8)
pushq $0x20
popq %rdi
callq 0x10f0
movl %r15d, (%rax)
movl %ebp, 0x4(%rax)
movb %bl, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jle 0x56b2
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x5650
movq %rax, 0x10(%rbx)
jmp 0x56c7
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x5650
movq %rax, 0x18(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x56dc
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::fix_up(gtl::tree_map<int, int>::Node*)
auto tree_map<K, V>::fix_up(Node * node) -> Node * {
  if (is_red(node->right) && !is_red(node->left)) node = node->rotate_left();
  if (is_red(node->left) && is_red(node->left->left)) node = node->rotate_right();
  if (is_red(node->left) && is_red(node->right)) node->flip_colors();
  return node;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x5709
cmpb $0x1, 0x8(%rax)
jne 0x5709
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x56fe
cmpb $0x0, 0x8(%rax)
jne 0x5709
movq %rbx, %rdi
callq 0x575e
movq %rax, %rbx
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x5758
cmpb $0x1, 0x8(%rax)
jne 0x573b
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x573b
cmpb $0x1, 0x8(%rcx)
jne 0x573b
movq %rbx, %rdi
callq 0x579e
movq %rax, %rbx
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x5758
cmpb $0x1, 0x8(%rax)
jne 0x5758
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x5758
cmpb $0x1, 0x8(%rax)
jne 0x5758
movq %rbx, %rdi
callq 0x57de
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::Node::rotate_left()
auto tree_map<K, V>::Node::rotate_left() -> Node * {
  Node * x = right;
  assert(x->is_red);
  x->is_red = is_red;
  is_red = true;
  right = x->left;
  x->left = this;
  return x;
}

// Assembly:
movq 0x18(%rdi), %rax
cmpb $0x0, 0x8(%rax)
je 0x577f
movb 0x8(%rdi), %cl
movb %cl, 0x8(%rax)
movb $0x1, 0x8(%rdi)
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%rdi)
movq %rdi, 0x10(%rax)
retq
pushq %rax
leaq 0x24e4(%rip), %rdi      # 0x7c6b
leaq 0x24e7(%rip), %rsi      # 0x7c75
leaq 0x24ef(%rip), %rcx      # 0x7c84
pushq $0x66
popq %rdx
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::Node::rotate_right()
auto tree_map<K, V>::Node::rotate_right() -> Node * {
  Node * x = left;
  assert(x->is_red);
  x->is_red = is_red;
  is_red = true;
  left = x->right;
  x->right = this;
  return x;
}

// Assembly:
movq 0x10(%rdi), %rax
cmpb $0x0, 0x8(%rax)
je 0x57bf
movb 0x8(%rdi), %cl
movb %cl, 0x8(%rax)
movb $0x1, 0x8(%rdi)
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq %rdi, 0x18(%rax)
retq
pushq %rax
leaq 0x24a4(%rip), %rdi      # 0x7c6b
leaq 0x24a7(%rip), %rsi      # 0x7c75
leaq 0x24f5(%rip), %rcx      # 0x7cca
pushq $0x71
popq %rdx
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::remove(gtl::tree_map<int, int>::Node*, int const&, bool&)
auto tree_map<K, V>::remove(Node * node, K const & key, bool & result) -> Node * {
  if (!node) {
    result = false;
    return nullptr;
  }
  if (key < node->key) {
    if (!is_red(node->left) && (!node->left || !is_red(node->left->left))) node = move_red_left(node);
    node->left = remove(node->left, key, result);
  } else {
    if (is_red(node->left)) node = node->rotate_right();
    if (key == node->key && !node->right) {
      Node * temp = node->left;
      node->left = nullptr;
      delete node;
      return temp;
    }
    if (!is_red(node->right) && (!node->right || !is_red(node->right->left))) node = move_red_right(node);
    if (key == node->key) {
      Node * min_right = min(node->right);
      node->value = min_right->value;
      node->key = min_right->key;
      node->right = delete_min(node->right);
    } else {
      node->right = remove(node->right, key, result);
    }
  }
  return fix_up(node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
testq %rsi, %rsi
je 0x5896
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
movl (%rsi), %ecx
movq 0x10(%rsi), %rsi
cmpl %ecx, %eax
jge 0x58ac
testq %rsi, %rsi
je 0x586d
cmpb $0x0, 0x8(%rsi)
jne 0x587f
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x586d
cmpb $0x0, 0x8(%rax)
jne 0x587f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5968
movq %rax, %rbx
movq 0x10(%rax), %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x582e
movq %rax, 0x10(%rbx)
jmp 0x5951
movb $0x0, (%r15)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rsi, %rsi
je 0x58c8
cmpb $0x1, 0x8(%rsi)
jne 0x58c8
movq %rbx, %rdi
callq 0x579e
movq %rax, %rbx
movl (%r12), %eax
movl (%rbx), %ecx
movq 0x18(%rbx), %rdx
cmpl %ecx, %eax
jne 0x58f0
testq %rdx, %rdx
jne 0x58f5
movq 0x10(%rbx), %r14
andq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x59ae
movq %rbx, %rdi
callq 0x10c0
jmp 0x589d
testq %rdx, %rdx
je 0x590a
cmpb $0x0, 0x8(%rdx)
jne 0x591e
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0x590a
cmpb $0x0, 0x8(%rdx)
jne 0x591e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x59ee
movq %rax, %rbx
movl (%r12), %eax
movl (%rbx), %ecx
movq 0x18(%rbx), %rsi
movq %r14, %rdi
cmpl %ecx, %eax
jne 0x5942
callq 0x5a2a
movq (%rax), %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x5a3c
jmp 0x594d
movq %r12, %rdx
movq %r15, %rcx
callq 0x582e
movq %rax, 0x18(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x56dc
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::move_red_left(gtl::tree_map<int, int>::Node*)
auto tree_map<K, V>::move_red_left(Node * node) -> Node * {
  node->flip_colors();
  if (node->right && is_red(node->right->left)) {
    node->right = node->right->rotate_right();
    node = node->rotate_left();
    node->flip_colors();
  }
  return node;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x57de
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x59a8
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x59a8
cmpb $0x1, 0x8(%rax)
jne 0x59a8
callq 0x579e
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x575e
movq %rax, %rbx
movq %rax, %rdi
callq 0x57de
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::move_red_right(gtl::tree_map<int, int>::Node*)
auto tree_map<K, V>::move_red_right(Node * node) -> Node * {
  node->flip_colors();
  if (node->left && is_red(node->left->left)) {
    node = node->rotate_right();
    node->flip_colors();
  }
  return node;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x57de
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x5a25
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x5a25
cmpb $0x1, 0x8(%rax)
jne 0x5a25
movq %rbx, %rdi
callq 0x579e
movq %rax, %rbx
movq %rax, %rdi
callq 0x57de
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/sgalkina[P]data_structures/src/tree_map.h
// Function: gtl::tree_map<int, int>::delete_min(gtl::tree_map<int, int>::Node*)
auto tree_map<K, V>::delete_min(Node * node) -> Node * {
  if (!node) return nullptr;
  if (!node->left) {
    Node * temp = node->right;
    node->right = nullptr;
    delete node;
    return temp;
  }
  if (!is_red(node->left) && (!node->left || !is_red(node->left->left))) node = move_red_left(node);
  node->left = delete_min(node->left);
  return fix_up(node);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x5a99
movq %rsi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x5a9e
movq %rdi, %r14
cmpb $0x0, 0x8(%rsi)
jne 0x5a7b
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x5a69
cmpb $0x0, 0x8(%rax)
jne 0x5a7b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5968
movq %rax, %rbx
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x5a3c
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x56dc
xorl %r14d, %r14d
jmp 0x5ab7
movq 0x18(%rbx), %r14
andq $0x0, 0x18(%rbx)
movq %rbx, %rdi
callq 0x59ae
movq %rbx, %rdi
callq 0x10c0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq