LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: malcolmyeh[P]CC3K/game.cc
// Function: Controller::gameInit(char)
void Controller::gameInit(char type) {
	this->floor = new Floor(1, false, false);
	this->display = new Display();
	this->display->readFloor("map.txt");
	for (int i = 0; i < 25; i++) {
		for (int j = 0; j < 79; j++) {
			char c = this->display->getChar(i, j);
			floor->displayGrid[i][j] = c;
			floor->defaultGrid[i][j] = c;
		}
	}

	this->floor->initFloor(type);
	this->display->updateDisplay(floor);
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0xff8, %edi            # imm = 0xFF8
callq 0x41d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x5d00
jmp 0x1a271
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movl $0x7b7, %edi            # imm = 0x7B7
movq %rdi, -0x80(%rbp)
callq 0x41d0
movq -0x80(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x78(%rbp)
xorl %esi, %esi
callq 0x4110
movq -0x78(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4300
movq -0x68(%rbp), %rdx
leaq 0x4a92(%rip), %rsi      # 0x1ed5a
leaq -0x40(%rbp), %rdi
callq 0x4270
jmp 0x1a2d3
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5840
jmp 0x1a2e2
leaq -0x40(%rbp), %rdi
callq 0x4130
leaq -0x41(%rbp), %rdi
callq 0x4200
movl $0x0, -0x48(%rbp)
cmpl $0x19, -0x48(%rbp)
jge 0x1a3d4
movl $0x0, -0x4c(%rbp)
cmpl $0x4f, -0x4c(%rbp)
jge 0x1a3c4
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x48(%rbp), %esi
movl -0x4c(%rbp), %edx
callq 0x5cd0
movb %al, %cl
movq -0x60(%rbp), %rax
movb %cl, -0x4d(%rbp)
movb -0x4d(%rbp), %sil
movq (%rax), %rcx
addq $0x820, %rcx            # imm = 0x820
movslq -0x48(%rbp), %rdx
imulq $0x4f, %rdx, %rdx
addq %rdx, %rcx
movslq -0x4c(%rbp), %rdx
movb %sil, (%rcx,%rdx)
movb -0x4d(%rbp), %dl
movq (%rax), %rax
addq $0x6, %rax
movslq -0x48(%rbp), %rcx
imulq $0x4f, %rcx, %rcx
addq %rcx, %rax
movslq -0x4c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x1a30c
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xff8, %esi            # imm = 0xFF8
callq 0x41e0
jmp 0x1a3fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1a3b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4130
leaq -0x41(%rbp), %rdi
callq 0x4200
jmp 0x1a3fd
jmp 0x1a3c6
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x1a2fb
movq -0x60(%rbp), %rax
movq (%rax), %rdi
movsbl -0x9(%rbp), %esi
callq 0x69e0
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rax), %rsi
callq 0x5c50
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x42f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x3ab40, %rsp          # imm = 0x3AB40
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d678(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x1e77
movq -0x1d678(%rbp), %rsi
movslq -0xc(%rbp), %rax
imulq $0x198, %rax, %rcx      # imm = 0x198
movq %rsi, %rax
addq %rcx, %rax
movq %rax, -0x1d680(%rbp)
addq $0x1184, %rsi           # imm = 0x1184
leaq -0x1d4d0(%rbp), %rdi
movl $0x1d4c0, %edx          # imm = 0x1D4C0
callq 0x1080
movq %rsp, %rdi
movl $0x3a98, %ecx           # imm = 0x3A98
leaq -0x1d4d0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x1d680(%rbp), %rdi
callq 0x22e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e11
movq -0x1d678(%rbp), %rdi
callq 0x2b30
movl $0x0, -0x1d4d4(%rbp)
cmpl $0xa, -0x1d4d4(%rbp)
jge 0x1fb6
movq -0x1d678(%rbp), %rax
movslq -0x1d4d4(%rbp), %rcx
imulq $0x198, %rcx, %rdx      # imm = 0x198
movq %rax, %rcx
addq %rdx, %rcx
movss 0x190(%rcx), %xmm1
movss 0x1180(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x1f5b
movq -0x1d678(%rbp), %rax
movslq -0x1d4d4(%rbp), %rcx
imulq $0x198, %rcx, %rdx      # imm = 0x198
movq %rax, %rcx
addq %rdx, %rcx
movss 0x190(%rcx), %xmm0
movss %xmm0, 0x1180(%rax)
movl $0x0, -0x1d4d8(%rbp)
movl -0x1d4d8(%rbp), %eax
cmpl 0x31b9(%rip), %eax      # 0x50c8
jge 0x1f59
movq -0x1d678(%rbp), %rax
movslq -0x1d4d4(%rbp), %rcx
imulq $0x198, %rcx, %rdx      # imm = 0x198
movq %rax, %rcx
addq %rdx, %rcx
movslq -0x1d4d8(%rbp), %rdx
cvtsi2ssl (%rcx,%rdx,4), %xmm0
movslq -0x1d4d8(%rbp), %rcx
movss %xmm0, 0xff0(%rax,%rcx,4)
movl -0x1d4d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d4d8(%rbp)
jmp 0x1f03
jmp 0x1f5b
movq -0x1d678(%rbp), %rsi
movslq -0x1d4d4(%rbp), %rax
imulq $0x198, %rax, %rax      # imm = 0x198
addq %rax, %rsi
leaq -0x1d670(%rbp), %rdi
movl $0x198, %edx            # imm = 0x198
callq 0x1080
movq %rsp, %rdi
movl $0x33, %ecx
leaq -0x1d670(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x1d678(%rbp), %rdi
callq 0x2c30
movl -0x1d4d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d4d4(%rbp)
jmp 0x1e8d
addq $0x3ab40, %rsp          # imm = 0x3AB40
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x30e4(%rip), %eax      # 0x50c8
jge 0x2060
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x30d2(%rip), %eax      # 0x50c8
jge 0x203f
movq -0x18(%rbp), %rax
addq $0x9c40, %rax           # imm = 0x9C40
movslq -0xc(%rbp), %rcx
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x2fb8(%rip), %rdi      # 0x4fd8
callq 0x1070
movq %rax, %rdi
leaq 0x1003(%rip), %rsi      # 0x3032
callq 0x10c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1fed
movq 0x2f92(%rip), %rdi      # 0x4fd8
movq 0x2f7b(%rip), %rsi      # 0x4fc8
callq 0x10d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1fdb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x3034(%rip), %eax      # 0x50c8
jge 0x217a
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x301e(%rip), %eax      # 0x50c8
jge 0x216a
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1184, %rcx           # imm = 0x1184
addq $0x13880, %rcx          # imm = 0x13880
movslq -0xc(%rbp), %rdx
imulq $0x190, %rdx, %rdx      # imm = 0x190
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movq %rax, %rcx
addq $0x1184, %rcx           # imm = 0x1184
addq $0x9c40, %rcx           # imm = 0x9C40
movslq -0xc(%rbp), %rdx
imulq $0x190, %rdx, %rdx      # imm = 0x190
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
addss (%rcx,%rdx,4), %xmm0
movss %xmm0, (%rcx,%rdx,4)
addq $0x1184, %rax           # imm = 0x1184
addq $0x9c40, %rax           # imm = 0x9C40
movslq -0xc(%rbp), %rcx
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x215a
movq -0x18(%rbp), %rax
addq $0x1184, %rax           # imm = 0x1184
addq $0x9c40, %rax           # imm = 0x9C40
movslq -0xc(%rbp), %rcx
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x215c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x20a1
jmp 0x216c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x208b
movq -0x18(%rbp), %rdi
addq $0x1184, %rdi           # imm = 0x1184
callq 0x28a0
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x1d500, %rsp          # imm = 0x1D500
leaq 0x10(%rbp), %rax
movq %rax, -0x1d500(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d4f8(%rbp)
movl $0x0, 0x190(%rax)
movl $0x0, -0xc(%rbp)
movl 0x2dac(%rip), %eax      # 0x50c8
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x1d4f0(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x2d76(%rip), %eax      # 0x50c8
jge 0x236e
movq -0x1d4f0(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2349
movq -0x1d4f8(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl 0x2d3d(%rip), %eax      # 0x50c8
jge 0x2446
movq -0x1d500(%rbp), %rsi
movq -0x1d4f0(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x1, (%rax,%rcx)
leaq -0x1d4e8(%rbp), %rdi
movl $0x1d4c0, %edx          # imm = 0x1D4C0
callq 0x1080
movl -0xc(%rbp), %edx
subq $0x1d4c0, %rsp          # imm = 0x1D4C0
movq %rsp, %rdi
movl $0x3a98, %ecx           # imm = 0x3A98
leaq -0x1d4e8(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x1d4f0(%rbp), %rsi
movq -0x1d4f8(%rbp), %rdi
callq 0x2490
movq -0x1d500(%rbp), %rcx
addq $0x1d4c0, %rsp          # imm = 0x1D4C0
movl %eax, %edx
movq -0x1d4f8(%rbp), %rax
movl %edx, -0x10(%rbp)
movslq -0xc(%rbp), %rdx
imulq $0x190, %rdx, %rdx      # imm = 0x190
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
addss 0x190(%rax), %xmm0
movss %xmm0, 0x190(%rax)
movl -0x10(%rbp), %edx
movslq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2382
movq -0x1d4f8(%rbp), %rax
movq -0x1d500(%rbp), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x190, %rdx, %rdx      # imm = 0x190
addq %rdx, %rcx
movss (%rcx), %xmm0
addss 0x190(%rax), %xmm0
movss %xmm0, 0x190(%rax)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x248(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x240(%rbp)
callq 0x10e0
movq -0x240(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x1060
jmp 0x2708
leaq -0x220(%rbp), %rdi
callq 0x1110
movb %al, -0x249(%rbp)
jmp 0x271c
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x2761
jmp 0x2728
movl $0x0, -0x4(%rbp)
movl $0x1, -0x230(%rbp)
jmp 0x27f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x1040
jmp 0x2811
movl $0x0, -0x234(%rbp)
movl -0x234(%rbp), %eax
cmpl 0x2951(%rip), %eax      # 0x50c8
jge 0x27e8
movl $0x0, -0x238(%rbp)
movl -0x238(%rbp), %eax
cmpl 0x2939(%rip), %eax      # 0x50c8
jge 0x27d5
movq -0x248(%rbp), %rax
movslq -0x234(%rbp), %rcx
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %rcx, %rax
movslq -0x238(%rbp), %rcx
leaq (%rax,%rcx,4), %rsi
leaq -0x220(%rbp), %rdi
callq 0x1030
jmp 0x27c2
jmp 0x27c4
movl -0x238(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x238(%rbp)
jmp 0x2783
jmp 0x27d7
movl -0x234(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x234(%rbp)
jmp 0x276b
movl $0x1, -0x4(%rbp)
movl $0x1, -0x230(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x1140
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x2784(%rip), %eax      # 0x50c8
jge 0x29b7
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x2772(%rip), %eax      # 0x50c8
jge 0x2999
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq 0x265e(%rip), %rdi      # 0x4fd8
callq 0x1070
movq %rax, %rdi
leaq 0x6a9(%rip), %rsi       # 0x3032
callq 0x10c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x294d
movq 0x2638(%rip), %rdi      # 0x4fd8
movq 0x2621(%rip), %rsi      # 0x4fc8
callq 0x10d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x293b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x1184, %rdi           # imm = 0x1184
callq 0x2690
movq -0x18(%rbp), %rdi
addq $0x1184, %rdi           # imm = 0x1184
callq 0x2820
movq -0x18(%rbp), %rdi
addq $0x1184, %rdi           # imm = 0x1184
callq 0x28a0
movq -0x18(%rbp), %rax
movss 0x600(%rip), %xmm0      # 0x300c
movss %xmm0, 0x1180(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x2a47
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movslq -0xc(%rbp), %rdx
imulq $0x198, %rdx, %rdx      # imm = 0x198
addq %rdx, %rax
movl %ecx, 0x194(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2a1b
movq -0x18(%rbp), %rdi
addq $0x1184, %rdi           # imm = 0x1184
callq 0x2920
movq 0x257a(%rip), %rdi      # 0x4fd8
movq 0x2563(%rip), %rsi      # 0x4fc8
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x1184, %rdi           # imm = 0x1184
movq -0x10(%rbp), %rsi
callq 0x26c0
movq -0x20(%rbp), %rdi
addq $0x1184, %rdi           # imm = 0x1184
callq 0x2820
movq -0x20(%rbp), %rdi
addq $0x1184, %rdi           # imm = 0x1184
callq 0x28a0
movq -0x20(%rbp), %rax
movss 0x548(%rip), %xmm0      # 0x300c
movss %xmm0, 0x1180(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x2aff
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movslq -0x14(%rbp), %rdx
imulq $0x198, %rdx, %rdx      # imm = 0x198
addq %rdx, %rax
movl %ecx, 0x194(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2ad3
movq -0x20(%rbp), %rdi
addq $0x1184, %rdi           # imm = 0x1184
callq 0x2920
movq 0x24c2(%rip), %rdi      # 0x4fd8
movq 0x24ab(%rip), %rsi      # 0x4fc8
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x2578(%rip), %eax      # 0x50c8
jge 0x2c22
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x2562(%rip), %eax      # 0x50c8
jge 0x2c12
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1184, %rcx           # imm = 0x1184
addq $0x9c40, %rcx           # imm = 0x9C40
movslq -0xc(%rbp), %rdx
imulq $0x190, %rdx, %rdx      # imm = 0x190
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x474(%rip), %xmm1      # 0x3018
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rcx,%rdx,4)
addq $0x1184, %rax           # imm = 0x1184
addq $0x9c40, %rax           # imm = 0x9C40
movslq -0xc(%rbp), %rcx
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x2c02
movq -0x18(%rbp), %rax
addq $0x1184, %rax           # imm = 0x1184
addq $0x9c40, %rax           # imm = 0x9C40
movslq -0xc(%rbp), %rcx
imulq $0x190, %rcx, %rcx      # imm = 0x190
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
jmp 0x2c04
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2b5d
jmp 0x2c14
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2b47
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
leaq 0x30(%rsp), %rdi
callq 0x2fa0
movq $0x64, 0x28(%rsp)
movq $0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
ja 0x276d
leaq 0x1c(%rsp), %rdi
callq 0xd180
jmp 0x2718
leaq 0x30(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x3200
jmp 0x2729
leaq 0x1c(%rsp), %rdi
callq 0xd1b0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2700
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x2788
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x1c(%rsp), %rdi
callq 0xd1b0
jmp 0x2788
leaq 0x30(%rsp), %rdi
callq 0x3260
jmp 0x2779
leaq 0x30(%rsp), %rdi
callq 0x2f20
addq $0x48, %rsp
retq
leaq 0x30(%rsp), %rdi
callq 0x2f20
movq 0x10(%rsp), %rdi
callq 0x21a0
nopl (%rax)
// File: 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 0x10540(%rip), %rdi     # 0x12fd8
leaq 0xb8ea(%rip), %rsi      # 0xe389
callq 0x2110
movq %rax, %rdi
movq 0x1051a(%rip), %rsi     # 0x12fc8
callq 0x2130
callq 0x23f0
callq 0x2370
callq 0x26e0
callq 0x27a0
popq %rax
retq
nopl (%rax)
// File: 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 0x10500(%rip), %rdi     # 0x12fd8
leaq 0xb66e(%rip), %rsi      # 0xe14d
callq 0x2110
movq %rax, %rdi
movq 0x104da(%rip), %rsi     # 0x12fc8
callq 0x2130
leaq 0x7(%rsp), %rdi
callq 0x3900
leaq 0x6(%rsp), %rdi
callq 0x3da0
popq %rax
retq
nopl (%rax)
// File: 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 0x104c0(%rip), %rdi     # 0x12fd8
leaq 0xb65c(%rip), %rsi      # 0xe17b
callq 0x2110
movq %rax, %rdi
movq 0x1049a(%rip), %rsi     # 0x12fc8
callq 0x2130
leaq 0x7(%rsp), %rdi
callq 0x3eb0
leaq 0x6(%rsp), %rdi
callq 0x4370
popq %rax
retq
nopl (%rax)
// File: 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 %rax
movq 0x10450(%rip), %rdi     # 0x12fd8
leaq 0xb5b0(%rip), %rsi      # 0xe13f
callq 0x2110
movq %rax, %rdi
movq 0x1042a(%rip), %rsi     # 0x12fc8
callq 0x2130
leaq 0x7(%rsp), %rdi
callq 0x48b0
movq 0x10424(%rip), %rdi     # 0x12fd8
leaq 0xb59d(%rip), %rsi      # 0xe158
callq 0x2110
movq %rax, %rdi
movq 0x103fe(%rip), %rsi     # 0x12fc8
callq 0x2130
leaq 0x6(%rsp), %rdi
callq 0x4d50
movq 0x103f8(%rip), %rdi     # 0x12fd8
leaq 0xb588(%rip), %rsi      # 0xe16f
callq 0x2110
movq %rax, %rdi
movq 0x103d2(%rip), %rsi     # 0x12fc8
callq 0x2130
leaq 0x5(%rsp), %rdi
callq 0x5200
popq %rax
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, 0x26(%rsp)
je 0x354a
movb $0x1, %al
movb %al, 0x26(%rsp)
jmp 0x354a
movb 0x26(%rsp), %al
testb $0x1, %al
jne 0x3554
jmp 0x3556
jmp 0x3575
leaq 0xae33(%rip), %rdi      # 0xe390
leaq 0xace6(%rip), %rsi      # 0xe24a
movl $0xa6, %edx
leaq 0xae3d(%rip), %rcx      # 0xe3ad
callq 0x2080
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rdi
movb $0x0, 0x27(%rsp)
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rcx)
shlq $0x2, %rax
addq %rax, %rsi
callq 0xd270
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0xd1b0
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x35cf
movq 0x8(%rsp), %rdi
callq 0xd1b0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, 0x17(%rsp)
je 0x375d
movb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x375d
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x3767
jmp 0x3769
jmp 0x3788
leaq 0xac20(%rip), %rdi      # 0xe390
leaq 0xaad3(%rip), %rsi      # 0xe24a
movl $0xae, %edx
leaq 0xac86(%rip), %rcx      # 0xe409
callq 0x2080
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, 0x7(%rsp)
jae 0x37a6
movb $0x1, %al
movb %al, 0x7(%rsp)
jmp 0x37a6
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x37b0
jmp 0x37b2
jmp 0x37d1
leaq 0xaa71(%rip), %rdi      # 0xe22a
leaq 0xaa8a(%rip), %rsi      # 0xe24a
movl $0xaf, %edx
leaq 0xac3d(%rip), %rcx      # 0xe409
callq 0x2080
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rcx
subq $0x1, %rcx
shlq $0x2, %rcx
addq %rcx, %rdi
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x67c0
movq 0x8(%rsp), %rdi
callq 0x3660
addq $0x28, %rsp
retq
nopl (%rax)
// File: sgalkina[P]data_structures/src/test_map.h
// Function: gtl::smoketest_map<gtl::vector_map<int, memcheck>>::value_semantics()
void smoketest_map<T>::value_semantics() {
  T vect_map;
  size_t n = 100;
  for (size_t i = 1; i <= n; ++i) {
    memcheck el;
    vect_map.add(i, el);
  }
  value_semantics_memory_test(vect_map);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x7230
movq $0x64, 0x30(%rsp)
movq $0x1, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rax
ja 0x3e78
leaq 0x24(%rsp), %rdi
callq 0xd180
jmp 0x3de1
movl 0x28(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0xd2e0
jmp 0x3dfa
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rdx
callq 0x7240
jmp 0x3e10
leaq 0xc(%rsp), %rdi
callq 0xd1b0
leaq 0x24(%rsp), %rdi
callq 0xd1b0
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x3dc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x3e93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x3e6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0xc(%rsp), %rdi
callq 0xd1b0
leaq 0x24(%rsp), %rdi
callq 0xd1b0
jmp 0x3e93
leaq 0x38(%rsp), %rdi
callq 0x7340
jmp 0x3e84
leaq 0x38(%rsp), %rdi
callq 0x7620
addq $0x58, %rsp
retq
leaq 0x38(%rsp), %rdi
callq 0x7620
movq 0x18(%rsp), %rdi
callq 0x21a0
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x40(%rsp), %rsi
callq 0x7660
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x72cf
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x28(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0xd2e0
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7690
jmp 0x72a4
movb $0x1, 0x57(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x76f0
jmp 0x731d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x76f0
jmp 0x7328
movq 0x8(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd2e0
movq (%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0xd310
jmp 0x72f2
leaq 0x18(%rsp), %rdi
callq 0xd1b0
movb $0x0, 0x57(%rsp)
jmp 0x731d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xd1b0
jmp 0x7328
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x21a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x6b70
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x6800
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x695f
movb $0x0, 0x37(%rsp)
jmp 0x6973
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7060
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: sgalkina[P]data_structures/src/test_map.h
// Function: gtl::smoketest_map<gtl::vector_map<int, int>>::search()
void smoketest_map<T>::search() {
  T map;
  int MAX = 10;
  for (size_t i = 0; i < MAX*MAX; ++i) {
    int element = rand() % MAX;
    map.add(element, element);
  }
  size_t steps = 2;
  size_t x = map.capacity() - steps + 1;
  size_t last_step;
  for (size_t i = 1; i <= steps; ++i) {
    last_step = x + map.capacity()*i;
    map.add(last_step, last_step);
  }
  assert(map.contains_key(last_step));
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x67f0
movl $0xa, 0x74(%rsp)
movq $0x0, 0x68(%rsp)
movq 0x68(%rsp), %rax
movl 0x74(%rsp), %ecx
imull 0x74(%rsp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x6a14
callq 0x2050
movl 0x74(%rsp), %ecx
cltd
idivl %ecx
movl %edx, 0x64(%rsp)
movl 0x64(%rsp), %edx
leaq 0x78(%rsp), %rdi
leaq 0x64(%rsp), %rsi
callq 0x6860
jmp 0x69e5
jmp 0x69e7
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x69aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x6b20
jmp 0x6b15
movq $0x2, 0x48(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x7210
movq %rax, 0x20(%rsp)
jmp 0x6a2e
movq 0x20(%rsp), %rax
subq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
movq $0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x48(%rsp), %rax
ja 0x6abb
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x7210
movq %rax, 0x18(%rsp)
jmp 0x6a71
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x38(%rsp), %edx
leaq 0x78(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x6860
jmp 0x6aa9
jmp 0x6aab
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x6a4a
movl 0x38(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6810
movb %al, 0xf(%rsp)
jmp 0x6ad8
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x6ae2
jmp 0x6ae4
jmp 0x6b03
leaq 0x7bdb(%rip), %rdi      # 0xe6c6
leaq 0x7812(%rip), %rsi      # 0xe304
movl $0x3b, %edx
leaq 0x7be4(%rip), %rcx      # 0xe6e2
callq 0x2080
leaq 0x78(%rsp), %rdi
callq 0x6b20
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x21a0
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x9230
testb $0x1, %al
jne 0x8e48
jmp 0x8e52
movq 0x20(%rsp), %rdi
callq 0x9320
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xd2e0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rdi, %rcx
addq $0x8, %rcx
callq 0x9610
movb %al, 0x1f(%rsp)
jmp 0x8e91
leaq 0x38(%rsp), %rdi
callq 0xd1b0
movb 0x1f(%rsp), %al
andb $0x1, %al
movb %al, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
je 0x8ed9
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x8ed9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd1b0
jmp 0x8ee4
movb 0x3f(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x21a0
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x81a0
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x8230
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x7f4f
movb $0x0, 0x47(%rsp)
jmp 0x7fa4
movq 0x8(%rsp), %rdi
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x20(%rsp)
movb $0x1, 0x24(%rsp)
movb $0x1, 0x25(%rsp)
addq $0x8, %rdi
movq 0x28(%rsp), %rsi
callq 0x8a10
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x1c(%rsp), %rdx
movq %rdx, (%rcx)
movl 0x24(%rsp), %edx
movl %edx, 0x8(%rcx)
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x8, %rdi
callq 0x8250
cmpq $0x0, %rax
jne 0x81d1
movq $0x0, 0x20(%rsp)
jmp 0x821d
movq (%rsp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
movq 0x10(%rsp), %rdx
callq 0x8260
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
callq 0x83e0
testb $0x1, 0x8(%rax)
je 0x8213
movq (%rsp), %rdi
callq 0x8230
movq %rax, 0x20(%rsp)
jmp 0x821d
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8250
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq %rax, %rdx
callq 0x8460
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8250
movq %rax, %rcx
movq 0x18(%rsp), %rax
addq 0x48(%rsp), %rcx
cmpq %rcx, %rax
jae 0x83b6
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x8250
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x83e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, 0x8(%rcx)
movb %al, 0x17(%rsp)
je 0x8338
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x83e0
movb 0x9(%rax), %al
xorb $-0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x83e0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, 0x8(%rcx)
movb %al, 0x7(%rsp)
jne 0x837f
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x83e0
movl (%rax), %eax
movq 0x50(%rsp), %rcx
cmpl (%rcx), %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x36(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x8397
testb $0x1, 0x36(%rsp)
je 0x83a1
movq 0x38(%rsp), %rax
addq $0x68, %rsp
retq
jmp 0x83a3
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x82b2
leaq 0x64b0(%rip), %rdi      # 0xe86d
leaq 0x64ce(%rip), %rsi      # 0xe892
movl $0x6f, %edx
leaq 0x64d1(%rip), %rcx      # 0xe8a1
callq 0x2080
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x68, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
callq 0x9740
cmpq $0x0, %rax
jne 0x9650
movb $0x0, 0x67(%rsp)
jmp 0x96f3
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x9ca0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x98a0
movq 0x8(%rsp), %rsi
movb 0x8(%rax), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x50(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x28(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0xd2e0
movb $0x0, 0x30(%rsp)
movb $0x0, 0x31(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x98a0
movq %rax, %rdi
leaq 0x28(%rsp), %rsi
callq 0x9e20
jmp 0x96c3
leaq 0x28(%rsp), %rdi
callq 0x9880
movb 0x37(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
jmp 0x96f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x9880
jmp 0x96fe
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x21a0
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb $0x0, 0x17(%rsp)
movq (%rdi), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
leaq 0x17(%rsp), %r8
callq 0xa560
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rax), %rax
movb $0x0, 0x8(%rax)
testb $0x1, 0x17(%rsp)
je 0xa1ff
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb $0x1, 0x17(%rsp)
movq (%rdi), %rsi
movq 0x18(%rsp), %rdx
leaq 0x17(%rsp), %rcx
callq 0xa9b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0xa28c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movb $0x0, 0x8(%rax)
testb $0x1, 0x17(%rsp)
je 0xa2a4
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa4ef
movq $0x0, 0x20(%rsp)
jmp 0xa555
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jne 0xa50b
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0xa555
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa539
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0xa4c0
movq %rax, 0x20(%rsp)
jmp 0xa555
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0xa4c0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl %ecx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0xa5e4
movq 0x20(%rsp), %rax
movb $0x1, (%rax)
movl $0x20, %edi
callq 0x2120
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x2c(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xa690
jmp 0xa5ba
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xa67c
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x20f0
jmp 0xa686
movl 0x2c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jne 0xa5ff
movl 0x28(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x4(%rax)
jmp 0xa668
movl 0x2c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa63a
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x2c(%rsp), %edx
movl 0x28(%rsp), %ecx
movq 0x20(%rsp), %r8
callq 0xa560
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xa666
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x2c(%rsp), %edx
movl 0x28(%rsp), %ecx
movq 0x20(%rsp), %r8
callq 0xa560
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0xa668
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xa6d0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x21a0
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xa6fb
jmp 0xa720
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xa720
movq 0x8(%rsp), %rdi
callq 0xa7e0
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xa738
jmp 0xa763
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xa754
jmp 0xa763
movq 0x8(%rsp), %rdi
callq 0xa860
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xa77b
jmp 0xa79d
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xa793
jmp 0xa79d
movq 0x8(%rsp), %rdi
callq 0xa8e0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0xa808
jmp 0xa827
leaq 0x4479(%rip), %rdi      # 0xec88
leaq 0x447c(%rip), %rsi      # 0xec92
movl $0x66, %edx
leaq 0x447f(%rip), %rcx      # 0xeca1
callq 0x2080
movq (%rsp), %rcx
movb 0x8(%rcx), %dl
movq 0x8(%rsp), %rax
andb $0x1, %dl
movb %dl, 0x8(%rax)
movb $0x1, 0x8(%rcx)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rcx)
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0xa888
jmp 0xa8a7
leaq 0x43f9(%rip), %rdi      # 0xec88
leaq 0x43fc(%rip), %rsi      # 0xec92
movl $0x71, %edx
leaq 0x4445(%rip), %rcx      # 0xece7
callq 0x2080
movq (%rsp), %rcx
movb 0x8(%rcx), %dl
movq 0x8(%rsp), %rax
andb $0x1, %dl
movb %dl, 0x8(%rax)
movb $0x1, 0x8(%rcx)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rcx)
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xa8e0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xac9c
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xac69
jmp 0xac9c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xa860
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdi
callq 0xa7e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xa8e0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xa8e0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xad82
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rsi
callq 0xa7b0
testb $0x1, %al
jne 0xad69
jmp 0xad82
movq 0x8(%rsp), %rdi
callq 0xa860
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xa8e0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)