LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/malcolmyeh[P]CC3K/game.cc
// Function: Controller::getScore()
double Controller::getScore() {
	if (floor->player->getRace() == "Human") { return (double)floor->player->getGold() * 1.5; }
	if (floor->player->getRace() == "Orc") { return (double)floor->player->getGold() / 2.0; }
	if (floor->player->getRace() == "Elf") { return (double)floor->player->getGold(); }
	if (floor->player->getRace() == "Dwarf") { return (double)floor->player->getGold() * 2.0; }
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0xfe0(%rax), %rsi
movq (%rsi), %rax
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq *0x28(%rax)
leaq 0x4d54(%rip), %rsi      # 0x1d9b0
movq %r15, %rdi
callq 0x4070
movl %eax, %r14d
movq (%r15), %rdi
leaq -0x30(%rbp), %r12
cmpq %r12, %rdi
je 0x18c7f
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4170
testl %r14d, %r14d
je 0x18d6b
movq (%rbx), %rax
movq 0xfe0(%rax), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x28(%rax)
leaq 0x4d2e(%rip), %rsi      # 0x1d9d0
movq %r15, %rdi
callq 0x4070
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x18cc1
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4170
testl %r14d, %r14d
je 0x18d89
movq (%rbx), %rax
movq 0xfe0(%rax), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x28(%rax)
leaq 0x4982(%rip), %rsi      # 0x1d666
movq %r15, %rdi
callq 0x4070
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x18d03
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4170
testl %r14d, %r14d
je 0x18da7
movq (%rbx), %rax
movq 0xfe0(%rax), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x28(%rax)
leaq 0x4d37(%rip), %rsi      # 0x1da5d
movq %r15, %rdi
callq 0x4070
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x18d45
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4170
xorpd %xmm0, %xmm0
testl %r14d, %r14d
jne 0x18dbb
movq (%rbx), %rax
movq 0xfe0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
addsd %xmm0, %xmm0
jmp 0x18dbb
movq (%rbx), %rax
movq 0xfe0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cvtsi2sd %eax, %xmm0
mulsd 0x4c39(%rip), %xmm0     # 0x1d9c0
jmp 0x18dbb
movq (%rbx), %rax
movq 0xfe0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cvtsi2sd %eax, %xmm0
mulsd 0x5073(%rip), %xmm0     # 0x1de18
jmp 0x18dbb
movq (%rbx), %rax
movq 0xfe0(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cvtsi2sd %eax, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/SYLOH[P]ant-sim/antsim.cpp
// Function: colony::runAnts()
void colony::runAnts(){
	for (int i = 0; i< numAnts; i++){
		ants[i].genPath(mMap);
	}
	
	evaporateTrails();

	for (int i = 0; i< numAnts; i++){
		
		if(ants[i].pathLen < shortestPathLen){
			shortestPathLen = ants[i].pathLen;
			
			for(int c = 0; c< numNodes;c++){
				shortestPath[c] = ants[i].path[c];
			}
		}
		depositePhermones(ants[i]);
	}
	

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3ab28, %rsp          # imm = 0x3AB28
movq %rdi, %rbp
leaq 0x1184(%rdi), %r14
xorl %ebx, %ebx
leaq 0x1d668(%rsp), %r15
leaq (%rbx,%rbp), %r12
movl $0x1d4c0, %edx          # imm = 0x1D4C0
movq %r15, %rdi
movq %r14, %rsi
callq 0x10a0
movl $0x3a98, %ecx           # imm = 0x3A98
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r12, %rdi
callq 0x2572
addq $0x198, %rbx            # imm = 0x198
cmpq $0xff0, %rbx            # imm = 0xFF0
jne 0x21bd
movq %rbp, %rdi
callq 0x2f92
leaq 0xadc4(%rbp), %r15
movl 0x3ecb(%rip), %r12d     # 0x60d8
leal -0x1(%r12), %r13d
movslq %r13d, %rax
movq %rax, 0x1d4c8(%rsp)
xorl %r14d, %r14d
movq %rbp, %rbx
imulq $0x198, %r14, %rsi      # imm = 0x198
movss 0x190(%rbp,%rsi), %xmm0
movss 0x1180(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x2268
movss %xmm0, 0x1180(%rbp)
testl %r12d, %r12d
jle 0x2268
xorl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ssl (%rbx,%rax,4), %xmm0
movss %xmm0, 0xff0(%rbp,%rax,4)
incq %rax
cmpq %rax, %r12
jne 0x224f
addq %rbp, %rsi
movl $0x198, %edx            # imm = 0x198
leaq 0x1d4d0(%rsp), %rdi
callq 0x10a0
xorps %xmm1, %xmm1
cvtss2sd 0x1d660(%rsp), %xmm1
cmpl $0x1, %r12d
jle 0x22da
movsd 0x1d91(%rip), %xmm0     # 0x4028
divsd %xmm1, %xmm0
movl 0x1d4d0(%rsp), %eax
movl %eax, %ecx
xorl %edx, %edx
movslq %ecx, %rsi
movslq 0x1d4d4(%rsp,%rdx,4), %rcx
incq %rdx
imulq $0x190, %rsi, %rsi      # imm = 0x190
addq %r15, %rsi
xorps %xmm1, %xmm1
cvtss2sd (%rsi,%rcx,4), %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rsi,%rcx,4)
cmpq %rdx, %r13
jne 0x22a6
jmp 0x22ed
movl 0x1d4d0(%rsp), %eax
movsd 0x1d3f(%rip), %xmm0     # 0x4028
divsd %xmm1, %xmm0
movq 0x1d4c8(%rsp), %rcx
movslq 0x1d4d0(%rsp,%rcx,4), %rcx
cltq
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %r15, %rcx
xorps %xmm1, %xmm1
cvtss2sd (%rcx,%rax,4), %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rcx,%rax,4)
incq %r14
addq $0x198, %rbx            # imm = 0x198
cmpq $0xa, %r14
jne 0x2223
addq $0x3ab28, %rsp          # imm = 0x3AB28
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/SYLOH[P]ant-sim/antsim.cpp
// Function: map::printTrails()
void map::printTrails(){
	for(int i =0;i<numNodes;i++){
		for(int j =0; j<numNodes;j++){
			cout<<trailArray[i][j]<<" ";
		}
		cout<<endl;
	}

}

// Assembly:
movl 0x3d8a(%rip), %eax      # 0x60d8
testl %eax, %eax
jle 0x23f7
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
addq $0x9c40, %rbx           # imm = 0x9C40
xorl %r12d, %r12d
movq 0x3c65(%rip), %r14      # 0x5fd8
leaq 0x1d30(%rip), %r15      # 0x40aa
testl %eax, %eax
jle 0x23b1
xorl %r13d, %r13d
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%r13,4), %xmm0
movq %r14, %rdi
callq 0x1130
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1100
incq %r13
movslq 0x3d2c(%rip), %rax      # 0x60d8
cmpq %rax, %r13
jl 0x2381
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
incq %r12
movslq 0x3cf6(%rip), %rax      # 0x60d8
addq $0x190, %rbx            # imm = 0x190
cmpq %rax, %r12
jl 0x237a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/SYLOH[P]ant-sim/antsim.cpp
// Function: colony::applyUpdate()
void colony::applyUpdate(){
	for(int i = 0; i< numNodes; i++){
		for(int j = 0; j< numNodes; j++){
			mMap.trailArray[i][j] += mMap.updateArray[i][j];
			if(mMap.trailArray[i][j]<0){
				mMap.trailArray[i][j]= 0;
			}
		}
	}
	mMap.initUpdate();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movslq 0x3cd1(%rip), %r14      # 0x60d8
testq %r14, %r14
jle 0x247e
movq %rdi, %rbx
leaq 0xadc4(%rdi), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movss 0x9c40(%rax,%rdx,4), %xmm0
addss (%rax,%rdx,4), %xmm0
xorps %xmm1, %xmm1
maxss %xmm0, %xmm1
movss %xmm1, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r14
jne 0x241a
incq %rcx
addq $0x190, %rax            # imm = 0x190
cmpq %r14, %rcx
jne 0x2418
testl %r14d, %r14d
jle 0x247e
addq $0x14a04, %rbx          # imm = 0x14A04
imulq $0x190, %r14, %r15      # imm = 0x190
shlq $0x2, %r14
xorl %r12d, %r12d
leaq (%rbx,%r12), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1070
addq $0x190, %r12            # imm = 0x190
cmpq %r12, %r15
jne 0x2464
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x190(%rdi)
movl 0x3b40(%rip), %r13d     # 0x60d8
movq %rsp, %rdi
leaq 0xf(%r13), %rax
andq $-0x10, %rax
subq %rax, %rdi
movq %rdi, %rsp
testl %r13d, %r13d
jle 0x2653
xorl %r12d, %r12d
movq %rdi, %r15
xorl %esi, %esi
movq %r13, %rdx
callq 0x1070
movl $0x0, (%rbx)
cmpq $0x1, %r13
je 0x2659
movl $0x1, %r14d
movq %r15, -0x30(%rbp)
movslq %r12d, %r13
movq -0x30(%rbp), %rax
movb $0x1, (%rax,%r13)
subq $0x1d4c0, %rsp          # imm = 0x1D4C0
movl $0x3a98, %ecx           # imm = 0x3A98
movq %rsp, %rdi
leaq 0x10(%rbp), %r15
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %rax, %rsi
movl %r13d, %edx
callq 0x2682
addq $0x1d4c0, %rsp          # imm = 0x1D4C0
movl %eax, %r12d
cltq
imulq $0x190, %r13, %rcx      # imm = 0x190
addq %r15, %rcx
movss (%rcx,%rax,4), %xmm0
addss 0x190(%rbx), %xmm0
movss %xmm0, 0x190(%rbx)
movl %eax, (%rbx,%r14,4)
incq %r14
movslq 0x3a90(%rip), %rcx      # 0x60d8
cmpq %rcx, %r14
jl 0x25dc
leaq 0x10(%rbp), %r14
jmp 0x265e
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
xorl %eax, %eax
imulq $0x190, %rax, %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_O3/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, %r14
leaq 0x40(%rsp), %r12
movslq 0x3a37(%rip), %rax      # 0x60d8
movslq %edx, %r13
testq %rax, %rax
jle 0x2704
imulq $0x190, %r13, %rcx      # imm = 0x190
addq %r12, %rcx
xorps %xmm3, %xmm3
xorl %edx, %edx
movss 0x1950(%rip), %xmm0     # 0x4010
cmpb $0x0, (%rbx,%rdx)
jne 0x26f4
xorps %xmm1, %xmm1
cvtss2sd 0x9c40(%rcx,%rdx,4), %xmm1
movaps %xmm0, %xmm2
divss (%rcx,%rdx,4), %xmm2
cvtss2sd %xmm2, %xmm2
mulsd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtss2sd %xmm3, %xmm1
addsd %xmm2, %xmm1
xorps %xmm3, %xmm3
cvtsd2ss %xmm1, %xmm3
incq %rdx
cmpq %rdx, %rax
jne 0x26c0
movss %xmm3, 0xc(%rsp)
jmp 0x270d
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x10c0
addl 0x194(%r14), %eax
movl %eax, %edi
callq 0x10d0
callq 0x1060
movslq 0x39a7(%rip), %rcx      # 0x60d8
testq %rcx, %rcx
jle 0x27a8
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x18cf(%rip), %xmm0     # 0x4014
movss 0xc(%rsp), %xmm4
mulss %xmm0, %xmm4
imulq $0x190, %r13, %rax      # imm = 0x190
addq %rax, %r12
xorps %xmm1, %xmm1
xorl %r15d, %r15d
movss 0x18a9(%rip), %xmm0     # 0x4010
cmpb $0x0, (%rbx,%r15)
jne 0x279d
xorps %xmm2, %xmm2
cvtss2sd 0x9c40(%r12,%r15,4), %xmm2
movaps %xmm0, %xmm3
divss (%r12,%r15,4), %xmm3
cvtss2sd %xmm3, %xmm3
mulsd %xmm2, %xmm3
cvtss2sd %xmm1, %xmm1
addsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
ucomiss %xmm4, %xmm1
jae 0x27a8
incq %r15
cmpq %r15, %rcx
jne 0x2767
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10f0
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x1080
leaq 0x78(%rsp), %rdi
callq 0x1040
xorl %ebp, %ebp
testb %al, %al
je 0x285b
movl 0x38ca(%rip), %eax      # 0x60d8
movl $0x1, %ebp
testl %eax, %eax
jle 0x285b
xorl %r12d, %r12d
movq %rsp, %r14
testl %eax, %eax
jle 0x2849
movq %rbx, %r15
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
callq 0x1160
incq %r13
movl 0x389d(%rip), %eax      # 0x60d8
movslq %eax, %rcx
addq $0x4, %r15
cmpq %rcx, %r13
jl 0x2827
jmp 0x284c
movslq %eax, %rcx
incq %r12
addq $0x190, %rbx            # imm = 0x190
cmpq %rcx, %r12
jl 0x281d
movq %rsp, %rdi
callq 0x1050
movl %ebp, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2879
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl 0x36ae(%rip), %eax      # 0x60d8
testl %eax, %eax
jle 0x2acc
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x3590(%rip), %r14      # 0x5fd8
leaq 0x165b(%rip), %r15      # 0x40aa
testl %eax, %eax
jle 0x2a86
xorl %r13d, %r13d
xorps %xmm0, %xmm0
cvtss2sd (%rbx,%r13,4), %xmm0
movq %r14, %rdi
callq 0x1130
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1100
incq %r13
movslq 0x3657(%rip), %rax      # 0x60d8
cmpq %rax, %r13
jl 0x2a56
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
incq %r12
movslq 0x3621(%rip), %rax      # 0x60d8
addq $0x190, %rbx            # imm = 0x190
cmpq %rax, %r12
jl 0x2a4f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x313f(%rip), %rax      # 0x60d8
testq %rax, %rax
jle 0x2fe4
addq $0xadc4, %rdi           # imm = 0xADC4
xorl %ecx, %ecx
movsd 0x1081(%rip), %xmm0     # 0x4030
xorl %edx, %edx
xorps %xmm1, %xmm1
cvtss2sd (%rdi,%rdx,4), %xmm1
mulsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
xorps %xmm2, %xmm2
maxss %xmm1, %xmm2
movss %xmm2, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0x2fb1
incq %rcx
addq $0x190, %rdi            # imm = 0x190
cmpq %rax, %rcx
jne 0x2faf
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7f3c
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
callq 0x1d7e
callq 0x7f3c
movq %rax, %r15
leaq (%rbx,%rbx), %rax
cmpq %rax, %r15
jne 0x1f6a
movq (%r14), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movq %rax, (%r14)
movq 0x8(%r14), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x10(%r14)
callq 0x7f3c
cmpq %r15, %rax
jne 0x1f89
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1d7e
leaq 0x70(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x20(%rsp)
movq $0x0, (%rdi)
movups 0x8(%rdi), %xmm0
movups %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
callq 0x1cf8
callq 0x7f3c
movq %rax, %r14
leaq (%rbx,%rbx,2), %rax
cmpq %rax, %r14
jne 0x1fa8
movups 0x8(%rsp), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, 0x40(%rsp)
leaq 0x88(%rsp), %rdi
movq %rax, (%rdi)
movups %xmm1, 0x8(%rdi)
movq %rcx, 0x50(%rsp)
callq 0x1cf8
callq 0x7f3c
cmpq %r14, %rax
jne 0x1fc7
leaq 0x40(%rsp), %rdi
callq 0x1cf8
leaq 0x20(%rsp), %rdi
callq 0x1cf8
leaq 0x8(%rsp), %rdi
callq 0x1cf8
leaq 0x58(%rsp), %rdi
callq 0x1cf8
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6346(%rip), %rdi      # 0x82b7
leaq 0x6368(%rip), %rsi      # 0x82e0
leaq 0x6370(%rip), %rcx      # 0x82ef
movl $0x45, %edx
callq 0x1080
leaq 0x6327(%rip), %rdi      # 0x82b7
leaq 0x6349(%rip), %rsi      # 0x82e0
leaq 0x6351(%rip), %rcx      # 0x82ef
movl $0x47, %edx
callq 0x1080
leaq 0x6387(%rip), %rdi      # 0x8336
leaq 0x632a(%rip), %rsi      # 0x82e0
leaq 0x6332(%rip), %rcx      # 0x82ef
movl $0x4a, %edx
callq 0x1080
leaq 0x6368(%rip), %rdi      # 0x8336
leaq 0x630b(%rip), %rsi      # 0x82e0
leaq 0x6313(%rip), %rcx      # 0x82ef
movl $0x4d, %edx
callq 0x1080
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1cf8
jmp 0x2002
movq %rax, %rbx
jmp 0x200c
movq %rax, %rbx
jmp 0x2016
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1cf8
leaq 0x8(%rsp), %rdi
callq 0x1cf8
leaq 0x58(%rsp), %rdi
callq 0x1cf8
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2070
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1(%rax), %rcx
movq %rcx, 0x10(%rsi)
leaq -0x4(,%rax,4), %rsi
addq 0x8(%r14), %rsi
callq 0x7f04
movq 0x10(%r14), %rdi
shlq $0x2, %rdi
addq 0x8(%r14), %rdi
callq 0x7ea6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x62e8(%rip), %rdi      # 0x835f
leaq 0x61a8(%rip), %rsi      # 0x8226
leaq 0x62f7(%rip), %rcx      # 0x837c
movl $0xa6, %edx
callq 0x1080
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20f3
cmpq %rsi, %rax
jbe 0x2112
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 0x2090
leaq 0x6265(%rip), %rdi      # 0x835f
leaq 0x6125(%rip), %rsi      # 0x8226
leaq 0x62d0(%rip), %rcx      # 0x83d8
movl $0xae, %edx
callq 0x1080
leaq 0x60ed(%rip), %rdi      # 0x8206
leaq 0x6106(%rip), %rsi      # 0x8226
leaq 0x62b1(%rip), %rcx      # 0x83d8
movl $0xaf, %edx
callq 0x1080
nop
// File: /workspace/github_cpp_makefile_star2_O3/sgalkina[P]data_structures/src/vector_map.h
// Function: gtl::vector_map<int, int>::add(int const&, int)
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
pushq %rax
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
callq 0x53c6
movq %rax, %r14
testq %rax, %rax
je 0x516a
movl %ebx, (%r14)
jmp 0x519a
movl (%r12), %r12d
movq 0x10(%r15), %rax
cmpq (%r15), %rax
jne 0x5183
movq %r15, %rdi
callq 0x5300
movq 0x10(%r15), %rax
movq 0x8(%r15), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x10(%r15)
shlq $0x20, %rbx
orq %r12, %rbx
movq %rbx, (%rcx,%rax,8)
testq %r14, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x51cd
movq 0x8(%rdi), %rcx
movl (%rsi), %edx
xorl %esi, %esi
cmpl %edx, (%rcx,%rsi,8)
je 0x51cf
incq %rsi
cmpq %rsi, %rax
jne 0x51be
jmp 0x51d4
xorl %esi, %esi
cmpq %rax, %rsi
jne 0x51d8
xorl %eax, %eax
jmp 0x51df
callq 0x541a
movb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x5f68
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
js 0x5f25
cvtsi2ss %rcx, %xmm0
jmp 0x5f3a
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
testq %rax, %rax
js 0x5f46
cvtsi2ss %rax, %xmm1
jmp 0x5f5b
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
ucomiss 0x20ba(%rip), %xmm0     # 0x8020
jb 0x5f70
movq %rbx, %rdi
callq 0x61ce
leaq 0x4(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x7f24
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x63a4
movl %eax, %ebp
leaq 0x4(%rsp), %rdi
callq 0x7ea6
testb %bpl, %bpl
je 0x5fa6
incq 0x20(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x7ea6
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x5c42
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x5afd
cmpq %rax, 0x18(%rbx)
jbe 0x5b05
movq 0x10(%rbx), %rdx
leaq (%rax,%rax,2), %rsi
movq $0x0, (%rdx,%rsi,4)
movw $0x101, 0x8(%rdx,%rsi,4) # imm = 0x101
decq 0x20(%rbx)
cmpq %rcx, %rax
setne %al
popq %rbx
retq
leaq 0x26fa(%rip), %rdi      # 0x8206
leaq 0x2713(%rip), %rsi      # 0x8226
leaq 0x2e1f(%rip), %rcx      # 0x8939
movl $0xa0, %edx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
cmpq $0x0, 0x8(%rdi)
je 0x5c74
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
callq 0x5c98
cmpq %rax, 0x18(%rbx)
jbe 0x5c78
movq 0x10(%rbx), %rcx
leaq (%rax,%rax,2), %rdx
cmpb $0x0, 0x8(%rcx,%rdx,4)
je 0x5c76
movq 0x8(%rbx), %rax
jmp 0x5c76
xorl %eax, %eax
popq %rbx
retq
leaq 0x2587(%rip), %rdi      # 0x8206
leaq 0x25a0(%rip), %rsi      # 0x8226
leaq 0x2c38(%rip), %rcx      # 0x88c5
movl $0x9a, %edx
callq 0x1080
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movq %rdx, %rdi
movq (%rsi), %r8
testq %r8, %r8
je 0x5cb1
movslq (%rdi), %rax
xorl %edx, %edx
divq %r8
movq %rdx, %rcx
jmp 0x5cb3
xorl %ecx, %ecx
leaq (%rcx,%r8), %rax
cmpq %rax, %rcx
jae 0x5cf8
movq 0x8(%rsi), %r9
movq 0x10(%rsi), %rsi
movl (%rdi), %edi
movq %r8, %r10
movq %rcx, %rax
xorl %edx, %edx
divq %r8
cmpq %rdx, %rsi
jbe 0x5d1c
leaq (%rdx,%rdx,2), %rax
leaq (%r9,%rax,4), %rax
cmpb $0x0, 0x8(%rax)
je 0x5cec
cmpb $0x0, 0x9(%rax)
jne 0x5cf0
jmp 0x5d17
cmpl %edi, (%rax)
je 0x5d17
incq %rcx
decq %r10
jne 0x5cc9
leaq 0x2b0b(%rip), %rdi      # 0x880a
leaq 0x2b29(%rip), %rsi      # 0x882f
leaq 0x2b31(%rip), %rcx      # 0x883e
movl $0x6f, %edx
callq 0x1080
movq %rdx, %rax
popq %rcx
retq
leaq 0x24e3(%rip), %rdi      # 0x8206
leaq 0x24fc(%rip), %rsi      # 0x8226
leaq 0x2b94(%rip), %rcx      # 0x88c5
movl $0x9a, %edx
callq 0x1080
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movq 0x8(%rdi), %rcx
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
movl $0x5, %ecx
cmovneq %rdx, %rcx
movq %rcx, 0x38(%rsp)
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %rdi
movq %rax, 0x48(%rsp)
callq 0x1030
leaq 0x38(%rsp), %rdi
movq %rax, 0x8(%rdi)
callq 0x64aa
cmpq $0x0, 0x10(%rsp)
je 0x627a
leaq 0x30(%rsp), %r14
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
leaq 0x2c(%rsp), %r12
movl $0x0, 0x2c(%rsp)
movq %r14, %rdi
callq 0x7e98
movw $0x1, 0x34(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f4
movq %r14, %rdi
callq 0x7ea6
incq %r13
movq 0x10(%rsp), %rcx
cmpq %rcx, %r13
jb 0x6241
jmp 0x627c
xorl %ecx, %ecx
movq $0x0, 0x20(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x62f7
movl $0x4, %r12d
xorl %r13d, %r13d
leaq 0xc(%rsp), %r14
leaq 0x10(%rsp), %r15
cmpq %r13, 0x18(%rbx)
jbe 0x6355
movq 0x10(%rbx), %rbp
cmpb $0x0, 0x4(%rbp,%r12)
jne 0x62e4
leaq (%r12,%rbp), %rsi
movq %r14, %rdi
callq 0x7f24
leaq (%r12,%rbp), %rsi
addq $-0x4, %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x63a4
movq %r14, %rdi
callq 0x7ea6
movq 0x8(%rbx), %rax
incq %r13
addq $0xc, %r12
cmpq %rax, %r13
jb 0x62a0
movq 0x10(%rsp), %rcx
jmp 0x62f9
xorl %eax, %eax
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rsi
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rcx, 0x8(%rbx)
leaq 0x50(%rsp), %rdi
movq %rax, (%rdi)
movq 0x10(%rbx), %rax
movq %rdx, 0x10(%rbx)
movq %rax, 0x8(%rdi)
movq 0x18(%rbx), %rax
movq %rsi, 0x18(%rbx)
movq %rax, 0x10(%rdi)
callq 0x64aa
movq %r14, %rdi
callq 0x64aa
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1eaa(%rip), %rdi      # 0x8206
leaq 0x1ec3(%rip), %rsi      # 0x8226
leaq 0x2690(%rip), %rcx      # 0x89fa
movl $0xa0, %edx
callq 0x1080
jmp 0x6382
jmp 0x6382
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x638d
movq %rax, %rbx
jmp 0x6392
movq %rax, %rbx
movq %r14, %rdi
callq 0x7ea6
leaq 0x10(%rsp), %rdi
callq 0x64aa
movq %rbx, %rdi
callq 0x1190
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x6455
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rcx, %rsi
movq %rbx, %rdx
callq 0x6660
cmpq %rax, 0x10(%r14)
jbe 0x6468
movq %rax, %r12
movq 0x8(%r14), %rax
leaq (%r12,%r12,2), %r13
movb 0x8(%rax,%r13,4), %bpl
movl (%rbx), %eax
leaq 0x10(%rsp), %rbx
movl %eax, -0x4(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7f24
movw $0x0, 0x4(%rbx)
cmpq %r12, 0x10(%r14)
jbe 0x6468
movq 0x8(%r14), %r14
movl 0xc(%rsp), %eax
movl %eax, (%r14,%r13,4)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x7f04
leaq (%r14,%r13,4), %r14
leaq 0x4(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7f30
leaq 0x8(%rsp), %rdi
callq 0x7ea6
movzwl 0x14(%rsp), %eax
movw %ax, 0x8(%r14)
movq %rbx, %rdi
callq 0x7ea6
jmp 0x6457
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d97(%rip), %rdi      # 0x8206
leaq 0x1db0(%rip), %rsi      # 0x8226
leaq 0x257d(%rip), %rcx      # 0x89fa
movl $0xa0, %edx
callq 0x1080
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7ea6
jmp 0x6499
movq %rax, %r14
movq %rbx, %rdi
callq 0x7ea6
movq %r14, %rdi
callq 0x1190
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6980
movq %rax, (%rbx)
movb %bpl, 0x8(%rax)
movb (%r14), %al
cmpb $0x1, %al
jne 0x6832
incq 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6b56
movq %rax, (%rbx)
testq %rax, %rax
je 0x6863
movb $0x0, 0x8(%rax)
movb 0xf(%rsp), %al
cmpb $0x1, %al
jne 0x686f
decq 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x69a1
movq %rsi, %rbx
movq %rdi, %r14
cmpl %r15d, (%rsi)
jne 0x69cb
movl %ebp, 0x4(%rbx)
jmp 0x69f9
movb $0x1, %bl
movb %bl, (%r8)
movl $0x20, %edi
callq 0x1110
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 0x69e4
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x6980
movq %rax, 0x10(%rbx)
jmp 0x69f9
movq 0x18(%rbx), %rsi
movq %r14, %rdi
movl %r15d, %edx
movl %ebp, %ecx
callq 0x6980
movq %rax, 0x18(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6a0e
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
movq %rsi, %rax
movq 0x18(%rsi), %rcx
testq %rcx, %rcx
je 0x6a38
cmpb $0x1, 0x8(%rcx)
jne 0x6a38
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x6a30
cmpb $0x0, 0x8(%rcx)
jne 0x6a38
movq %rax, %rdi
callq 0x6a8a
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x6a88
cmpb $0x1, 0x8(%rcx)
jne 0x6a67
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
je 0x6a67
cmpb $0x1, 0x8(%rdx)
jne 0x6a67
movq %rax, %rdi
callq 0x6acc
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x6a88
cmpb $0x1, 0x8(%rcx)
jne 0x6a88
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x6a88
cmpb $0x1, 0x8(%rdx)
jne 0x6a88
xorb $0x1, 0x8(%rax)
xorb $0x1, 0x8(%rcx)
xorb $0x1, 0x8(%rdx)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6aab
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 0x2172(%rip), %rdi      # 0x8c25
leaq 0x2175(%rip), %rsi      # 0x8c2f
leaq 0x217d(%rip), %rcx      # 0x8c3e
movl $0x66, %edx
callq 0x1080
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6aed
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 0x2130(%rip), %rdi      # 0x8c25
leaq 0x2133(%rip), %rsi      # 0x8c2f
leaq 0x2181(%rip), %rcx      # 0x8c84
movl $0x71, %edx
callq 0x1080
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6bbe
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdx), %eax
movl (%rsi), %ecx
movq 0x10(%rsi), %rsi
cmpl %ecx, %eax
jge 0x6bd4
testq %rsi, %rsi
je 0x6b95
cmpb $0x0, 0x8(%rsi)
jne 0x6ba7
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x6b95
cmpb $0x0, 0x8(%rax)
jne 0x6ba7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c9e
movq %rax, %rbx
movq 0x10(%rax), %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x6b56
movq %rax, 0x10(%rbx)
jmp 0x6c87
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 0x6bf0
cmpb $0x1, 0x8(%rsi)
jne 0x6bf0
movq %rbx, %rdi
callq 0x6acc
movq %rax, %rbx
movl (%r12), %eax
movl (%rbx), %ecx
movq 0x18(%rbx), %rdx
cmpl %ecx, %eax
jne 0x6c1b
testq %rdx, %rdx
jne 0x6c20
movq 0x10(%rbx), %r14
movq $0x0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x6d06
movq %rbx, %rdi
callq 0x10e0
jmp 0x6bc5
testq %rdx, %rdx
je 0x6c35
cmpb $0x0, 0x8(%rdx)
jne 0x6c49
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0x6c35
cmpb $0x0, 0x8(%rdx)
jne 0x6c49
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6d46
movq %rax, %rbx
movl (%r12), %eax
movl (%rbx), %ecx
movq 0x18(%rbx), %rsi
cmpl %ecx, %eax
jne 0x6c75
movq %rsi, %rcx
movq %rcx, %rax
testq %rcx, %rcx
je 0x6c65
movq 0x10(%rax), %rcx
testq %rcx, %rcx
jne 0x6c54
movq (%rax), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x6da4
jmp 0x6c83
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x6b56
movq %rax, 0x18(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6a0e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorb $0x1, 0x8(%rsi)
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x6cb3
xorb $0x1, 0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x6d01
xorb $0x1, 0x8(%rdi)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x6d01
cmpb $0x1, 0x8(%rax)
jne 0x6d01
callq 0x6acc
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x6a8a
movq %rax, %rbx
xorb $0x1, 0x8(%rax)
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x6cf4
xorb $0x1, 0x8(%rax)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x6d01
xorb $0x1, 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rsi, %rax
xorb $0x1, 0x8(%rsi)
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x6d5a
xorb $0x1, 0x8(%rcx)
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x6d67
xorb $0x1, 0x8(%rdx)
pushq %rax
testq %rcx, %rcx
je 0x6da2
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x6da2
cmpb $0x1, 0x8(%rcx)
jne 0x6da2
movq %rax, %rdi
callq 0x6acc
xorb $0x1, 0x8(%rax)
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x6d95
xorb $0x1, 0x8(%rcx)
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x6da2
xorb $0x1, 0x8(%rcx)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6e01
movq %rsi, %rbx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x6e06
movq %rdi, %r14
cmpb $0x0, 0x8(%rsi)
jne 0x6de3
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x6dd1
cmpb $0x0, 0x8(%rax)
jne 0x6de3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c9e
movq %rax, %rbx
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x6da4
movq %rax, 0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6a0e
xorl %r14d, %r14d
jmp 0x6e22
movq 0x18(%rbx), %r14
movq $0x0, 0x18(%rbx)
movq %rbx, %rdi
callq 0x6d06
movq %rbx, %rdi
callq 0x10e0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/sgalkina[P]data_structures/src/test_map.h
// Function: long gtl::benchmark_operation<gtl::vector_map<int, int>, gtl::search<gtl::vector_map<int, int>>>(gtl::vector_map<int, int>&)
clock_t benchmark_operation(T & map) {
  U op;
  size_t n_runs = 100;
  clock_t min_time = LONG_MAX;
  for (size_t i = 0; i < n_runs; ++i) {
    clock_t start_time = std::clock();
    op(map);
    clock_t end_time = std::clock();
    clock_t t = (end_time - start_time) % CLOCKS_PER_SEC;
    if (t < min_time) min_time = t;
  }
  return min_time;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movabsq $0x7fffffffffffffff, %rbx # imm = 0x7FFFFFFFFFFFFFFF
xorl %r15d, %r15d
movabsq $0x431bde82d7b634db, %r12 # imm = 0x431BDE82D7B634DB
callq 0x1090
movq %rax, %r14
movq 0x620a(%rip), %rax      # 0xd0f0
leaq (%rax,%rax), %rcx
shlq $0x4, %rax
cmpq %rcx, %rax
je 0x6f15
xorl %r13d, %r13d
callq 0x1050
incq %r13
movq 0x61eb(%rip), %rax      # 0xd0f0
leaq (%rax,%rax), %rcx
shlq $0x4, %rax
subq %rcx, %rax
cmpq %rax, %r13
jb 0x6ef6
callq 0x1090
movq %rax, %rcx
subq %r14, %rcx
movq %rcx, %rax
imulq %r12
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
subq %rax, %rcx
cmpq %rbx, %rcx
cmovlq %rcx, %rbx
incq %r15
cmpq $0x64, %r15
jne 0x6ed7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sgalkina[P]data_structures/src/test_map.h
// Function: gtl::mixed<gtl::vector_map<int, int>>::operator()(gtl::vector_map<int, int>&)
void operator() (T & map) {
    for (size_t i = 0; i < 10*n_operations; ++i) {
      map.lookup(rand() % max_number);
    }
    for (size_t i = 0; i < 3*n_operations; ++i) {
      int el = rand() % max_number;
      map.add(el, 0);
    }
    for (size_t i = 0; i < n_operations; ++i) {
      int el = rand() % max_number;
      map.remove(el);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x5f85(%rip), %rax      # 0xd0f0
leaq (%rax,%rax), %rcx
leaq (%rcx,%rcx,4), %rcx
testq %rcx, %rcx
je 0x71b6
xorl %r15d, %r15d
leaq 0xc(%rsp), %r14
callq 0x1050
cltq
xorl %edx, %edx
divq 0x5f58(%rip)            # 0xd0e8
movl %edx, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53c6
incq %r15
movq 0x5f47(%rip), %rax      # 0xd0f0
leaq (%rax,%rax), %rcx
leaq (%rcx,%rcx,4), %rcx
cmpq %rcx, %r15
jb 0x7180
testq %rax, %rax
je 0x722f
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
callq 0x1050
cltq
xorl %edx, %edx
divq 0x5f15(%rip)            # 0xd0e8
movl %edx, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5148
incq %r15
movq 0x5f02(%rip), %rax      # 0xd0f0
leaq (%rax,%rax,2), %rcx
cmpq %rcx, %r15
jb 0x71c3
testq %rax, %rax
je 0x722f
xorl %r15d, %r15d
leaq 0x4(%rsp), %r14
callq 0x1050
cltq
xorl %edx, %edx
divq 0x5ed4(%rip)            # 0xd0e8
movl %edx, 0x4(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51ac
incq %r15
cmpq 0x5ec3(%rip), %r15      # 0xd0f0
jb 0x7204
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sgalkina[P]data_structures/src/memcheck.cpp
// Function: memcheck::~memcheck()
memcheck::~memcheck()
  {
    assert(value_ != memcheck::DESTRUCTOR_VALUE && "Double free");
    assert(value_ == memcheck::CONSTRUCTOR_VALUE && "Not initialized memory");
    value_ = memcheck::DESTRUCTOR_VALUE;
    --counter;
  }

// Assembly:
pushq %rax
movl (%rdi), %eax
cmpl $0xcafebabe, %eax       # imm = 0xCAFEBABE
jne 0x7ebf
movl $0xdeadbeef, (%rdi)     # imm = 0xDEADBEEF
decq 0x5253(%rip)            # 0xd110
popq %rax
retq
cmpl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
jne 0x7ee5
leaq 0x140c(%rip), %rdi      # 0x92d9
leaq 0x143b(%rip), %rsi      # 0x930f
leaq 0x1445(%rip), %rcx      # 0x9320
movl $0x11, %edx
callq 0x1080
leaq 0x144a(%rip), %rdi      # 0x9336
leaq 0x141c(%rip), %rsi      # 0x930f
leaq 0x1426(%rip), %rcx      # 0x9320
movl $0x12, %edx
callq 0x1080
// File: /workspace/github_cpp_makefile_star2_O3/zyLiu6707[P]Arknights-Pull-Simulation/./utils.h
// Function: get_random_seed()
uint_fast64_t get_random_seed() {
  std::random_device rd;  // uses RDRND or /dev/urandom
                          // if you want use a specific token, do not use
                          // "/dev/random" on Linux, which is much slower
  std::mt19937_64 mt64(rd());
  auto random_seed = mt64();
  return random_seed;
}

// Assembly:
pushq %rbx
subq $0x1d50, %rsp           # imm = 0x1D50
leaq 0x9c8(%rsp), %rbx
movq %rbx, %rdi
callq 0x501e
movq %rbx, %rdi
callq 0x21f0
movl %eax, %esi
movq %rsi, (%rsp)
movl $0x1, %eax
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
movq %rsi, %rdx
shrq $0x3e, %rdx
xorq %rsi, %rdx
imulq %rcx, %rdx
addq %rax, %rdx
movq %rdx, (%rsp,%rax,8)
incq %rax
movq %rdx, %rsi
cmpq $0x138, %rax            # imm = 0x138
jne 0x248b
movq %rsp, %rdi
movq $0x138, 0x9c0(%rdi) # imm = 0x138
callq 0x5098
movq %rax, %rbx
leaq 0x9c8(%rsp), %rdi
callq 0x2170
movq %rbx, %rax
addq $0x1d50, %rsp           # imm = 0x1D50
popq %rbx
retq
jmp 0x24f6
jmp 0x24de
movq %rax, %rbx
leaq 0x9c8(%rsp), %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2260
movq %rax, %rdi
callq 0x5243