LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: eva23511[P]OS-Virtual-Memory-Management/pager.cpp
// Function: ClockPager::SelectVictimFrame(std::vector<Frame*, std::allocator<Frame*>>, std::vector<Process*, std::allocator<Process*>>, unsigned long)
Frame * ClockPager::SelectVictimFrame(vector<Frame *> frame_table, vector<Process *> processes, unsigned long timestamp) {
    hand++;
    if (hand >= frame_table.size()) {
        hand = 0;
    }
    
    while (processes[frame_table[hand]->pid]->page_table[frame_table[hand]->vpage]->referenced) {
        processes[frame_table[hand]->pid]->page_table[frame_table[hand]->vpage]->referenced = 0;

        hand++;
        if (hand >= frame_table.size()) {
            hand = 0;
        }
    }
    return frame_table[hand];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x7450
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0xad30
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0xad32
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq 0x8(%rax), %rsi
callq 0x5510
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movslq 0x4(%rax), %rsi
callq 0x5410
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rcx
addq $0x20, %rcx
movq %rcx, -0x50(%rbp)
movslq 0x8(%rax), %rsi
callq 0x5510
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movslq 0x8(%rax), %rsi
callq 0x5430
movq (%rax), %rax
movl (%rax), %eax
shrl %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xae2f
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq 0x8(%rax), %rsi
callq 0x5510
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movslq 0x4(%rax), %rsi
callq 0x5410
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rcx
addq $0x20, %rcx
movq %rcx, -0x60(%rbp)
movslq 0x8(%rax), %rsi
callq 0x5510
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movslq 0x8(%rax), %rsi
callq 0x5430
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rcx
movl (%rcx), %edx
andl $-0x3, %edx
orl $0x0, %edx
movl %edx, (%rcx)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
callq 0x7450
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jb 0xae2a
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0xad32
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq 0x8(%rax), %rsi
callq 0x5510
movq (%rax), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: macfergus[P]baduk/cppsrc/apps/randomplay.cpp
// Function: main
int main() {
    auto game = baduk::newGame(19, 7.5);
    baduk::RandomBot black_bot;
    baduk::RandomBot white_bot;

    while (!game->isOver()) {
        std::cout << game->board() << "\n";
        auto next_agent =
            game->nextPlayer() == baduk::Stone::black ?
                &black_bot :
                &white_bot;
        const auto next_move = next_agent->selectMove(*game);

        game = game->applyMove(next_move);
    }
    std::cout << game->board() << "\n";

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x13, %esi
movss 0x1631(%rip), %xmm0     # 0x41634
callq 0x44a0
leaq -0x28(%rbp), %rdi
callq 0xb810
jmp 0x40013
leaq -0x48(%rbp), %rdi
callq 0xb810
jmp 0x4001e
jmp 0x40020
leaq -0x18(%rbp), %rdi
callq 0xb8c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movb %al, -0x81(%rbp)
jmp 0x4003d
movb -0x81(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4004e
jmp 0x40192
leaq -0x18(%rbp), %rdi
callq 0xb8c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x90(%rbp)
jmp 0x4006c
movq -0x90(%rbp), %rsi
movq 0xff3e(%rip), %rdi      # 0x4ffb8
callq 0x3dcf0
movq %rax, -0x98(%rbp)
jmp 0x40088
movq -0x98(%rbp), %rdi
leaq 0x1575(%rip), %rsi      # 0x4160b
callq 0x31e0
jmp 0x4009d
leaq -0x18(%rbp), %rdi
callq 0xb8c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movl %eax, -0x9c(%rbp)
jmp 0x400ba
movl -0x9c(%rbp), %eax
cmpl $0x0, %eax
jne 0x400d2
leaq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x400df
leaq -0x48(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0x400df
movq -0xa8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb8e0
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movb %dl, -0xb1(%rbp)
movq %rax, -0xb0(%rbp)
jmp 0x4011f
movb -0xb1(%rbp), %al
movq -0xb0(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
movb -0x68(%rbp), %al
movb %al, -0x58(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb8c0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq *%rax
jmp 0x40160
leaq -0x18(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xb910
leaq -0x80(%rbp), %rdi
callq 0xb940
jmp 0x40020
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb960
jmp 0x401fd
leaq -0x18(%rbp), %rdi
callq 0xb8c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0xc8(%rbp)
jmp 0x401b0
movq -0xc8(%rbp), %rsi
movq 0xfdfa(%rip), %rdi      # 0x4ffb8
callq 0x3dcf0
movq %rax, -0xd0(%rbp)
jmp 0x401cc
movq -0xd0(%rbp), %rdi
leaq 0x1431(%rip), %rsi      # 0x4160b
callq 0x31e0
jmp 0x401e1
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb960
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3370
// File: dramninjasUMD[P]BOBSim/./Globals.h
// Function: BOBSim::log2(unsigned int)
uint inline log2(unsigned value)
{
	uint logbase2 = 0;
	unsigned orig = value;
	value>>=1;
	while(value>0)
	{
		value >>= 1;
		logbase2++;
	}
	if(1<<logbase2<orig)logbase2++;
	return logbase2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jbe 0xb695
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xb67c
movl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
cmpl -0xc(%rbp), %eax
jae 0xb6ad
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dramninjasUMD[P]BOBSim/./Globals.h
// Function: BOBSim::log2_64(unsigned long)
uint inline log2_64(uint64_t value)
{
	uint logbase2 = 0;
	uint64_t orig = value;
	value>>=1;
	while(value>0)
	{
		value>>=1;
		logbase2++;
	}
	if(1<<logbase2<orig)logbase2++;
	return logbase2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jbe 0xb6ff
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb6e2
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
cmpq -0x18(%rbp), %rax
jae 0xb71a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: dramninjasUMD[P]BOBSim/BOBWrapper.cpp
// Function: BOBSim::getPageWalkLogicOp(unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>*)
void *getPageWalkLogicOp(uint64_t baseAddr, vector<uint64_t> *args)
{
	if (!args)
	{
		ERROR(" == Got a logic op without an arguments vector");
	}

	LogicOperation *lo = new LogicOperation(LogicOperation::PAGE_TABLE_WALK, *args);
	return (void*)(lo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13f02
movq 0x24152(%rip), %rdi     # 0x37ff0
leaq 0x1626b(%rip), %rsi     # 0x2a110
callq 0x31c0
movq %rax, %rdi
leaq 0x17062(%rip), %rsi     # 0x2af16
callq 0x31c0
movq %rax, %rdi
leaq 0x161f6(%rip), %rsi     # 0x2a0b9
callq 0x31c0
movq %rax, %rdi
movl $0xc7, %esi
callq 0x3380
movq %rax, %rdi
leaq 0x16242(%rip), %rsi     # 0x2a121
callq 0x31c0
movq %rax, %rdi
leaq 0x17037(%rip), %rsi     # 0x2af25
callq 0x31c0
movq %rax, %rdi
movq 0x240ab(%rip), %rsi     # 0x37fa8
callq 0x3200
movl $0x20, %edi
callq 0x31d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movl $0x2, %esi
callq 0x1f410
jmp 0x13f26
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x31f0
movq -0x20(%rbp), %rdi
callq 0x33a0
nopl (%rax,%rax)
// File: dramninjasUMD[P]BOBSim/BOBWrapper.cpp
// Function: BOBSim::BOBWrapper::AddTransaction(unsigned long, bool, int, void*)
bool BOBWrapper::AddTransaction(uint64_t addr, bool isWrite, int coreID, void *logicOperation)
{
	int openPort;
	bool isLogicOp = logicOperation != NULL;
	TransactionType type = isLogicOp ? LOGIC_OPERATION : (isWrite ? DATA_WRITE : DATA_READ) ;
	Transaction *trans;

	if ((openPort = FindOpenPort(coreID)) > -1)
	{
		trans = new Transaction(type, TRANSACTION_SIZE, addr);
		trans->portID = openPort;
		trans->coreID=coreID;
		if (isLogicOp)
		{
			trans->logicOpContents = logicOperation;
		}
		if(currentClockCycle<5000)
		{
			DEBUG("!! "<<*trans<<" to port "<<openPort);
		}
		if (isWrite)
			writesPerCycle++;
		else
			readsPerCycle++;

		AddTransaction(trans, openPort);
	}
	else 
	{
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
je 0x13fa3
movl $0x3, %eax
movl %eax, -0x5c(%rbp)
jmp 0x13fb6
movb -0x19(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x20(%rbp), %esi
callq 0x16ee0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
jle 0x140f5
movl $0x90, %edi
callq 0x31d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movl -0x34(%rbp), %esi
movl 0x2435b(%rip), %edx     # 0x3834c
movq -0x18(%rbp), %rcx
callq 0x293f0
jmp 0x13ffc
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x20(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x20(%rax)
testb $0x1, -0x2d(%rbp)
je 0x1404b
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x1404b
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x90, %esi
callq 0x31f0
jmp 0x1410a
movq -0x58(%rbp), %rax
cmpq $0x1388, 0x8(%rax)      # imm = 0x1388
jae 0x140af
leaq 0x24314(%rip), %rax     # 0x38374
cmpl $0x0, (%rax)
je 0x140ad
movq 0x23f5c(%rip), %rdi     # 0x37fc8
leaq 0x16ee1(%rip), %rsi     # 0x2af54
callq 0x31c0
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x294b0
movq %rax, %rdi
leaq 0x16eca(%rip), %rsi     # 0x2af58
callq 0x31c0
movq %rax, %rdi
movl -0x2c(%rbp), %esi
callq 0x3380
movq %rax, %rdi
movq 0x23f00(%rip), %rsi     # 0x37fa8
callq 0x3200
jmp 0x140af
testb $0x1, -0x19(%rbp)
je 0x140cd
movq -0x58(%rbp), %rax
movq 0xc0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xc0(%rax)
jmp 0x140e3
movq -0x58(%rbp), %rax
movq 0xb8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xb8(%rax)
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x14120
jmp 0x140fb
movb $0x0, -0x1(%rbp)
jmp 0x140ff
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x33a0
nopw %cs:(%rax,%rax)
// File: dramninjasUMD[P]BOBSim/BOBWrapper.cpp
// Function: BOBSim::BOBWrapper::FindOpenPort(unsigned int)
inline int BOBWrapper::FindOpenPort(uint coreID)
{
	switch(portHeuristic)
	{
	case FIRST_AVAILABLE:
		for (unsigned i=0; i<NUM_PORTS; i++)
		{
			if (isPortAvailable(i))
			{
				return i;
			}
		}
		break;
	case PER_CORE:
		if(isPortAvailable(coreID%NUM_PORTS))
		{
			return coreID%NUM_PORTS;
		}
		break;
	case ROUND_ROBIN:
		int startIndex = portRoundRobin;
		do
		{
			if(isPortAvailable(portRoundRobin))
			{
				int i=portRoundRobin;
				portRoundRobin=(portRoundRobin+1)%NUM_PORTS;
				return i;
			}
			else
			{
				portRoundRobin=(portRoundRobin+1)%NUM_PORTS;
			}
		}
		while(startIndex!=portRoundRobin);

		break;
	};
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x2163f(%rip), %eax     # 0x3853c
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x16f21
jmp 0x16f06
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x16f9f
jmp 0x16f14
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x16f65
jmp 0x17029
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0x2143e(%rip), %rcx     # 0x38370
cmpl (%rcx), %eax
jae 0x16f60
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x17280
testb $0x1, %al
jne 0x16f48
jmp 0x16f53
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17030
jmp 0x16f55
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x16f28
jmp 0x17029
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
leaq 0x213fd(%rip), %rcx     # 0x38370
xorl %edx, %edx
divl (%rcx)
movl %edx, %esi
callq 0x17280
testb $0x1, %al
jne 0x16f84
jmp 0x16f9a
movl -0x14(%rbp), %eax
leaq 0x213e2(%rip), %rcx     # 0x38370
xorl %edx, %edx
divl (%rcx)
movl %edx, -0x4(%rbp)
jmp 0x17030
jmp 0x17029
movq -0x30(%rbp), %rax
movl 0x6b0(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movl 0x6b0(%rdi), %esi
callq 0x17280
testb $0x1, %al
jne 0x16fc1
jmp 0x16ff4
movq -0x30(%rbp), %rax
movl 0x6b0(%rax), %ecx
movl %ecx, -0x20(%rbp)
movl 0x6b0(%rax), %eax
addl $0x1, %eax
leaq 0x21392(%rip), %rcx     # 0x38370
xorl %edx, %edx
divl (%rcx)
movq -0x30(%rbp), %rax
movl %edx, 0x6b0(%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x17030
movq -0x30(%rbp), %rax
movl 0x6b0(%rax), %eax
addl $0x1, %eax
leaq 0x21368(%rip), %rcx     # 0x38370
xorl %edx, %edx
divl (%rcx)
movq -0x30(%rbp), %rax
movl %edx, 0x6b0(%rax)
jmp 0x17018
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x6b0(%rcx), %eax
jne 0x16fac
jmp 0x17029
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: dramninjasUMD[P]BOBSim/BankState.cpp
// Function: BOBSim::BankState::UpdateStateChange()
void BankState::UpdateStateChange()
{
	if(stateChangeCountdown>0)
	{
		stateChangeCountdown--;

		if(stateChangeCountdown==0)
		{
			switch(lastCommand)
			{
			case REFRESH:
				currentBankState = IDLE;
				break;
			case WRITE_P:
			case READ_P:
				currentBankState = PRECHARGING;
				stateChangeCountdown = tRP;
				lastCommand = PRECHARGE;
				break;
			case PRECHARGE:
				currentBankState = IDLE;
				break;
			default:
				ERROR("== WTF STATE? : "<<lastCommand);
				exit(0);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x3c(%rax)
jbe 0x18b0f
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3c(%rax)
cmpl $0x0, 0x3c(%rax)
jne 0x18b0d
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x18a8a
movq -0x18(%rbp), %rax
leaq 0x12988(%rip), %rcx     # 0x2b3cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x18b0b
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movl 0x1f8ec(%rip), %ecx     # 0x38358
movl %ecx, 0x3c(%rax)
movl $0x6, 0x38(%rax)
jmp 0x18b0b
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x18b0b
movq 0x1f55f(%rip), %rdi     # 0x37ff0
leaq 0x11678(%rip), %rsi     # 0x2a110
callq 0x31c0
movq %rax, %rdi
leaq 0x1294d(%rip), %rsi     # 0x2b3f4
callq 0x31c0
movq %rax, %rdi
leaq 0x11603(%rip), %rsi     # 0x2a0b9
callq 0x31c0
movq %rax, %rdi
movl $0x4a, %esi
callq 0x3380
movq %rax, %rdi
leaq 0x1164f(%rip), %rsi     # 0x2a121
callq 0x31c0
movq %rax, %rdi
leaq 0x12921(%rip), %rsi     # 0x2b402
callq 0x31c0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x3380
movq %rax, %rdi
movq 0x1f4a9(%rip), %rsi     # 0x37fa8
callq 0x3200
xorl %edi, %edi
callq 0x3270
jmp 0x18b0d
jmp 0x18b0f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dramninjasUMD[P]BOBSim/BankState.cpp
// Function: BOBSim::operator<<(std::ostream&, BOBSim::BankState const&)
ostream &operator<<(ostream &out, const BankState &bs)
{
	//out << dec <<" == Bank State " <<endl;
	switch(bs.currentBankState)
	{
	case IDLE:
		out<<"    State : Idle" <<endl;
		break;
	case ROW_ACTIVE:
		out<<"    State : Active" <<endl;
		break;
	case PRECHARGING:
		out<<"    State : Precharging" <<endl;
		break;
	case REFRESHING:
		out<<"    State : Refreshing" <<endl;
		break;
	}
	/*
	out<<"    StateChange    : " << bs.stateChangeCountdown<<endl;
	out<<"    OpenRowAddress : " << bs.openRowAddress <<endl;
	out<<"    nextRead       : " << bs.nextRead <<endl;
	out<<"    nextWrite      : " << bs.nextWrite <<endl;
	out<<"    nextActivate   : " << bs.nextActivate <<endl;
	out<<"    nextStrobeMin  : " << bs.nextStrobeMin << endl;
	out<<"    nextStrobeMax  : " << bs.nextStrobeMax << endl;
	*/
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x18bda
movq -0x18(%rbp), %rax
leaq 0x12895(%rip), %rcx     # 0x2b3e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x128b0(%rip), %rsi     # 0x2b413
callq 0x31c0
movq %rax, %rdi
movq 0x1f436(%rip), %rsi     # 0x37fa8
callq 0x3200
jmp 0x18bda
movq -0x8(%rbp), %rdi
leaq 0x128a0(%rip), %rsi     # 0x2b424
callq 0x31c0
movq %rax, %rdi
movq 0x1f415(%rip), %rsi     # 0x37fa8
callq 0x3200
jmp 0x18bda
movq -0x8(%rbp), %rdi
leaq 0x12892(%rip), %rsi     # 0x2b437
callq 0x31c0
movq %rax, %rdi
movq 0x1f3f4(%rip), %rsi     # 0x37fa8
callq 0x3200
jmp 0x18bda
movq -0x8(%rbp), %rdi
leaq 0x12889(%rip), %rsi     # 0x2b44f
callq 0x31c0
movq %rax, %rdi
movq 0x1f3d3(%rip), %rsi     # 0x37fa8
callq 0x3200
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dramninjasUMD[P]BOBSim/LogicLayerInterface.cpp
// Function: BOBSim::LogicLayerInterface::ReceiveLogicOperation(BOBSim::Transaction*, unsigned int)
void LogicLayerInterface::ReceiveLogicOperation(Transaction *trans, unsigned i)
{
	if (DEBUG_LOGIC) DEBUG("== Received in logic layer "<<simpleControllerID<<" on cycle "<<currentClockCycle<<" : "<<*trans);
	if (trans->transactionType == LOGIC_OPERATION)
	{
		pendingLogicOpsQueue.push_back(trans);
	}
	else
	{
		newOperationQueue.push_back(trans);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x1b894(%rip)     # 0x38546
je 0x1cd2d
leaq 0x1b6b9(%rip), %rax     # 0x38374
cmpl $0x0, (%rax)
je 0x1cd2b
movq 0x1b301(%rip), %rdi     # 0x37fc8
leaq 0xed47(%rip), %rsi      # 0x2ba15
callq 0x31c0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x32d0
movq %rax, %rdi
leaq 0xea2c(%rip), %rsi      # 0x2b718
callq 0x31c0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3070
movq %rax, %rdi
leaq 0xe463(%rip), %rsi      # 0x2b16e
callq 0x31c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x294b0
movq %rax, %rdi
movq 0x1b282(%rip), %rsi     # 0x37fa8
callq 0x3200
jmp 0x1cd2d
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x1cd49
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
leaq -0x10(%rbp), %rsi
callq 0x1e0b0
jmp 0x1cd5a
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
leaq -0x10(%rbp), %rsi
callq 0xbfd0
addq $0x20, %rsp
popq %rbp
retq
// File: dramninjasUMD[P]BOBSim/Rank.cpp
// Function: BOBSim::Rank::Update()
void Rank::Update()
{
	for(unsigned i=0; i<NUM_BANKS; i++)
	{
		bankStates[i].UpdateStateChange();
	}

	for(unsigned i=0; i<readReturnCountdown.size(); i++)
	{
		readReturnCountdown[i]--;
	}
	if(readReturnCountdown.size()>0 && readReturnCountdown[0]==0)
	{
		(*ReadReturnCallback)(readReturnQueue[0],id);
		readReturnCountdown.erase(readReturnCountdown.begin());
		readReturnQueue.erase(readReturnQueue.begin());
	}

	//increment clock cycle
	currentClockCycle++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x163a0(%rip), %eax     # 0x38444
jae 0x220c8
movq -0x48(%rbp), %rax
movq 0x50(%rax), %rdi
movl -0xc(%rbp), %eax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x189f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2209b
movl $0x0, -0x10(%rbp)
movq -0x48(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
callq 0x17100
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x22113
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0xbec0
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x220cf
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x17100
cmpq $0x0, %rax
jbe 0x221e8
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbec0
cmpl $0x0, (%rax)
jne 0x221e8
movq -0x48(%rbp), %rdi
movq 0x48(%rdi), %rax
movq %rax, -0x68(%rbp)
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x230d0
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rsi
movl 0x10(%rax), %edx
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x48(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x60(%rbp)
addq $0x18, %rdi
callq 0x18510
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x23160
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x230f0
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x58(%rbp)
addq $0x30, %rdi
callq 0x23210
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x23240
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x231a0
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x70, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/rev-iters.cc
// Function: main
int main()
{
    vector<int> vec = {0,1,2,3,4,5,6,7,8,9};
    // reverse iterator of vector from back to front
    for (auto r_iter = vec.crbegin(); // binds r_iter to the last element
              r_iter != vec.crend();  // one before first element
              ++r_iter)          // decrements the iterator one element
        cout << *r_iter << endl; // prints 9, 8, 7, . . . 0
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movabsq $0x900000008, %rax      # imm = 0x900000008
movq %rax, -0x40(%rbp)
movups 0x1dad(%rip), %xmm0     # 0x3014
movaps %xmm0, -0x50(%rbp)
movups 0x1d92(%rip), %xmm0     # 0x3004
movaps %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0xa, -0x28(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x13b0
movq -0x90(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x13d0
jmp 0x12b0
leaq -0x61(%rbp), %rdi
callq 0x1450
leaq -0x80(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1470
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x14f0
movq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x14c0
movb %al, -0x91(%rbp)
jmp 0x12f5
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x1304
jmp 0x1389
leaq -0x80(%rbp), %rdi
callq 0x1540
movq %rax, -0xa8(%rbp)
jmp 0x1316
movq -0xa8(%rbp), %rax
movl (%rax), %esi
movq 0x3cb2(%rip), %rdi      # 0x4fd8
callq 0x10e0
movq %rax, -0xb0(%rbp)
jmp 0x1334
movq -0xb0(%rbp), %rdi
movq 0x3c86(%rip), %rsi      # 0x4fc8
callq 0x10b0
jmp 0x1349
jmp 0x134b
leaq -0x80(%rbp), %rdi
callq 0x1570
jmp 0x1356
jmp 0x12c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x1450
jmp 0x13a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15a0
jmp 0x13a5
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15a0
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x10f0
nop
// File: kingufl[P]Rmapper/src/KDTree.cpp
// Function: KDNode::KDNode(std::vector<int, std::allocator<int>> const&, unsigned long const&, std::shared_ptr<KDNode> const&, std::shared_ptr<KDNode> const&)
KDNode::KDNode(const point_t &pt, const size_t &idx_, const KDNodePtr &left_,
               const KDNodePtr &right_) {
    x = pt;
    index = idx_;
    left = left_;
    right = right_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x5120
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x58(%rbp)
callq 0x5140
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x48(%rbp)
callq 0x5140
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5160
jmp 0x3652
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq -0x20(%rbp), %rsi
addq $0x20, %rdi
callq 0x53b0
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x30, %rdi
callq 0x53b0
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x53e0
movq -0x58(%rbp), %rdi
callq 0x53e0
movq -0x40(%rbp), %rdi
callq 0x5400
movq -0x30(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: kingufl[P]Rmapper/src/KDTree.cpp
// Function: KDNode::KDNode(std::pair<std::vector<int, std::allocator<int>>, unsigned long> const&, std::shared_ptr<KDNode> const&, std::shared_ptr<KDNode> const&)
KDNode::KDNode(const pointIndex &pi, const KDNodePtr &left_,
               const KDNodePtr &right_) {
    x = pi.first;
    index = pi.second;
    left = left_;
    right = right_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0x5120
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x50(%rbp)
callq 0x5140
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x40(%rbp)
callq 0x5140
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5160
jmp 0x371e
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rsi
addq $0x20, %rdi
callq 0x53b0
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x30, %rdi
callq 0x53b0
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x53e0
movq -0x50(%rbp), %rdi
callq 0x53e0
movq -0x38(%rbp), %rdi
callq 0x5400
movq -0x28(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: kingufl[P]Rmapper/src/KDTree.cpp
// Function: KDTree::KDTree(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>)
KDTree::KDTree(pointVec point_array) {
    leaf = std::make_shared< KDNode >();
    // iterators
    pointIndexArr arr;
    for (size_t i = 0; i < point_array.size(); i++) {
        arr.push_back(pointIndex(point_array.at(i), i));
    }

    auto begin = arr.begin();
    auto end = arr.end();

    size_t length = arr.size();
    size_t level = 0;  // starting

    root = KDTree::make_tree(begin, end, length, level);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
callq 0x5140
movq -0xb0(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5140
leaq -0x20(%rbp), %rdi
callq 0x5610
jmp 0x3c36
movq -0xb8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x57d0
leaq -0x20(%rbp), %rdi
callq 0x53e0
leaq -0x48(%rbp), %rdi
callq 0x58a0
movq $0x0, -0x50(%rbp)
movq -0xc0(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0xc8(%rbp)
callq 0x58c0
movq %rax, %rcx
movq -0xc8(%rbp), %rax
cmpq %rcx, %rax
jae 0x3d1f
movq -0xc0(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x5920
movq %rax, -0xd0(%rbp)
jmp 0x3ca7
movq -0xd0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x55d0
jmp 0x3cbd
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x58f0
jmp 0x3ccc
leaq -0x70(%rbp), %rdi
callq 0x5960
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x3c64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3dc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3dbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5960
jmp 0x3dbd
leaq -0x48(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x5980
movq -0xd8(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x59b0
movq -0xd8(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x59e0
movq -0xb8(%rbp), %rsi
movq %rax, -0x88(%rbp)
movq $0x0, -0x90(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rdx
leaq -0x80(%rbp), %rcx
leaq -0x88(%rbp), %r8
leaq -0x90(%rbp), %r9
callq 0x3920
jmp 0x3d8c
movq -0xb8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x57d0
leaq -0xa0(%rbp), %rdi
callq 0x53e0
leaq -0x48(%rbp), %rdi
callq 0x5a00
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x5a00
movq -0xa8(%rbp), %rdi
callq 0x53e0
movq -0xb0(%rbp), %rdi
callq 0x53e0
movq -0x28(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)
// File: kingufl[P]Rmapper/src/KDTree.cpp
// Function: KDTree::nearest_(std::vector<int, std::allocator<int>> const&)
KDNodePtr KDTree::nearest_(const point_t &pt) {
    size_t level = 0;
    // KDNodePtr best = branch;
    int branch_dist = dist2(point_t(*root), pt);
    return nearest_(root,          // beginning of tree
                    pt,            // point we are querying
                    level,         // start from level 0
                    root,          // best is the root
                    branch_dist);  // best_dist = branch_dist
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x5a60
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3830
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5a90
movl %eax, -0x50(%rbp)
jmp 0x42a9
leaq -0x40(%rbp), %rdi
callq 0x5400
movl -0x50(%rbp), %eax
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %r9
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %r8
leaq -0x24(%rbp), %rax
movq %r9, %rsi
movq %r9, %rdx
movq %rax, (%rsp)
callq 0x3df0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5400
movq -0x48(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: kingufl[P]Rmapper/src/KDTree.cpp
// Function: KDTree::neighborhood_points(std::vector<int, std::allocator<int>> const&, int const&)
pointVec KDTree::neighborhood_points(  //
    const point_t &pt,                 //
    const int &rad) {
    size_t level = 0;
    pointIndexArr nbh = neighborhood_(root, pt, rad, level);
    pointVec nbhp;
    nbhp.resize(nbh.size());
    std::transform(nbh.begin(), nbh.end(), nbhp.begin(),
                   [](pointIndex x) { return x.first; });
    return nbhp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x28(%rbp), %r9
movq %rdx, %rsi
callq 0x44b0
movq -0x88(%rbp), %rdi
movb $0x0, -0x41(%rbp)
callq 0x5dc0
movq -0x90(%rbp), %rdi
callq 0x59e0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x5de0
jmp 0x4d34
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5980
movq -0xa8(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x59b0
movq -0x88(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x5e70
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x4df0
movq %rax, -0xa0(%rbp)
jmp 0x4d82
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x4dc8
jmp 0x4dbc
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x5ea0
leaq -0x40(%rbp), %rdi
callq 0x5a00
jmp 0x4de1
movq -0x88(%rbp), %rdi
callq 0x5ea0
leaq -0x40(%rbp), %rdi
callq 0x5a00
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)
// File: kingufl[P]Rmapper/src/KDTree.cpp
// Function: KDTree::neighborhood_indices(std::vector<int, std::allocator<int>> const&, int const&)
indexArr KDTree::neighborhood_indices(  //
    const point_t &pt,                  //
    const int &rad) {
    size_t level = 0;
    pointIndexArr nbh = neighborhood_(root, pt, rad, level);
    indexArr nbhi;
    nbhi.resize(nbh.size());
    std::transform(nbh.begin(), nbh.end(), nbhi.begin(),
                   [](pointIndex x) { return x.second; });
    return nbhi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x28(%rbp), %r9
movq %rdx, %rsi
callq 0x44b0
movq -0x88(%rbp), %rdi
movb $0x0, -0x41(%rbp)
callq 0x5f00
movq -0x90(%rbp), %rdi
callq 0x59e0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x5f20
jmp 0x4f44
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5980
movq -0xa8(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x59b0
movq -0x88(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x5fb0
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x5000
movq %rax, -0xa0(%rbp)
jmp 0x4f92
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x4fd8
jmp 0x4fcc
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x5fe0
leaq -0x40(%rbp), %rdi
callq 0x5a00
jmp 0x4ff1
movq -0x88(%rbp), %rdi
callq 0x5fe0
leaq -0x40(%rbp), %rdi
callq 0x5a00
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)
// File: kingufl[P]Rmapper/src/KDTree.cpp
// Function: sort_on_idx(__gnu_cxx::__normal_iterator<std::pair<std::vector<int, std::allocator<int>>, unsigned long>*, std::vector<std::pair<std::vector<int, std::allocator<int>>, unsigned long>, std::allocator<std::pair<std::vector<int, std::allocator<int>>, unsigned long>>>> const&, __gnu_cxx::__normal_iterator<std::pair<std::vector<int, std::allocator<int>>, unsigned long>*, std::vector<std::pair<std::vector<int, std::allocator<int>>, unsigned long>, std::allocator<std::pair<std::vector<int, std::allocator<int>>, unsigned long>>>> const&, unsigned long)
inline void sort_on_idx(const pointIndexArr::iterator &begin,  //
                        const pointIndexArr::iterator &end,    //
                        size_t idx) {
    comparer comp(idx);
    comp.idx = idx;

    using std::placeholders::_1;
    using std::placeholders::_2;

    std::sort(begin, end, std::bind(&comparer::compare_idx, comp, _1, _2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x3900
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq 0xd3a(%rip), %rax       # 0x6480
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x20(%rbp), %rdx
movq 0x36843(%rip), %rcx     # 0x3bfa8
movq 0x36884(%rip), %r8      # 0x3bff0
callq 0x6430
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x63d0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kingufl[P]Rmapper/src/KDTree.cpp
// Function: dist2(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
inline int dist2(const point_t &a, const point_t &b) {
    int distc = 0;
    for (size_t i = 0; i < a.size(); i++) {
        int di = a.at(i) - b.at(i);
        distc += di * di;
    }
    return distc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x56e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5b11
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5b20
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5b20
movq %rax, %rcx
movl -0x34(%rbp), %eax
subl (%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
imull -0x24(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5aaf
movl -0x14(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kingufl[P]Rmapper/src/KDTree.cpp
// Function: disth(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, int)
inline int disth(const point_t &a, const point_t &b, int rad) {
    int distc = 0;
    for (size_t i = 0; i < a.size(); i++) {
        if(abs(a[i]-b[i])>rad){
            distc++;
            break;
        }
    }

    if(distc==0)
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x56e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5c7d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8d30
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8d30
movq %rax, %rcx
movl -0x34(%rbp), %eax
subl (%rcx), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl -0x1c(%rbp), %eax
jle 0x5c6d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5c7d
jmp 0x5c6f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5c12
cmpl $0x0, -0x20(%rbp)
jne 0x5c8c
movl $0x1, -0x4(%rbp)
jmp 0x5c93
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: kingufl[P]Rmapper/src/buildgraph.cpp
// Function: kthSmallest(int*, int, int, int)
int kthSmallest(int arr[], int l, int r, int k)
{
    // If k is smaller than number of elements in array
    if (k > 0 && k <= r - l + 1) {
        // Partition the array around last element and get
        // position of pivot element in sorted array
        int pos = partition(arr, l, r);

        // If position is same as k
        if (pos - l == k - 1)
            return arr[pos];
        if (pos - l > k - 1) // If position is more, recur for left subarray
            return kthSmallest(arr, l, pos - 1, k);

        // Else recur for right subarray
        return kthSmallest(arr, pos + 1, r, k - pos + l - 1);
    }

    // If k is more than number of elements in array
    return INT_MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0xde4e
movl -0x1c(%rbp), %eax
movl -0x18(%rbp), %ecx
subl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jg 0xde4e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0xde60
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
subl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xde01
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xde55
movl -0x20(%rbp), %eax
subl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0xde2b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x20(%rbp), %edx
subl $0x1, %edx
movl -0x1c(%rbp), %ecx
callq 0xdda0
movl %eax, -0x4(%rbp)
jmp 0xde55
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
addl $0x1, %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
addl -0x14(%rbp), %ecx
subl $0x1, %ecx
callq 0xdda0
movl %eax, -0x4(%rbp)
jmp 0xde55
movl $0x7fffffff, -0x4(%rbp) # imm = 0x7FFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kingufl[P]Rmapper/src/buildgraph.cpp
// Function: partition(int*, int, int)
int partition(int arr[], int l, int r)
{
    int x = arr[r], i = l;
    for (int j = l; j <= r - 1; j++) {
        if (arr[j] <= x) {
            swap(&arr[i], &arr[j]);
            i++;
        }
    }
    swap(&arr[i], &arr[r]);
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0xdee2
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jg 0xded5
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0xdf10
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xded7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xde8c
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0xdf10
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kingufl[P]Rmapper/src/buildgraph.cpp
// Function: uncover_frags(int, int, int, std::vector<int, std::allocator<int>>&)
point_t uncover_frags(int kmer_size, int i_rmap, int q_rmap,vector<int>& rmap){

    point_t retvar((kmer_size)*2);
    int i;
    for(i=0;i<kmer_size;i++){

        retvar[i]=rmap[i_rmap++];
    }

    for(int j=q_rmap+kmer_size;j>q_rmap+kmer_size-(kmer_size);j--){
        retvar[i++]=rmap[j];
    }

    return(retvar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movl -0xc(%rbp), %eax
addl %eax, %eax
cltq
movq %rax, -0x50(%rbp)
leaq -0x22(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x6090
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x173a0
jmp 0xdf93
leaq -0x22(%rbp), %rdi
callq 0x7620
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xdffb
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movslq %eax, %rsi
callq 0x9a30
movq -0x58(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movslq -0x38(%rbp), %rsi
callq 0x9a30
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xdfa3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x7620
jmp 0xe06a
movl -0x14(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl -0x14(%rbp), %ecx
addl -0xc(%rbp), %ecx
subl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0xe04d
movq -0x20(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
callq 0x9a30
movq -0x58(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x68(%rbp)
movl -0x38(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x38(%rbp)
movslq %eax, %rsi
callq 0x9a30
movl -0x68(%rbp), %ecx
movl %ecx, (%rax)
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xe004
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xe060
movq -0x58(%rbp), %rdi
callq 0x5400
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
// File: kingufl[P]Rmapper/src/buildgraph.cpp
// Function: min(int, int)
int min(int a,int b){

    if(a<=b)
        return a;
    else
        return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xe63a
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe640
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/use-istream-iter.cc
// Function: main
int main() {
	vector<int> vec;
	istream_iterator<int> in_iter(cin);  // read ints from cin
	istream_iterator<int> eof;           // istream ``end'' iterator

	// use in_iter to read cin storing what we read in vec
	while (in_iter != eof)  // while there's valid input to read
		// postfix increment reads the stream and 
		// returns the old value of the iterator
		// we dereference that iterator to get 
		// the previous value read from the stream 
		vec.push_back(*in_iter++);  

	// use an ostream_iterator to print the contents of vec
	ostream_iterator<int> out_iter(cout, " ");
	copy(vec.begin(), vec.end(), out_iter);
	cout << endl;
	
	// alternative way to print contents of vec
	for (auto e : vec)
		*out_iter++ = e;  // the assignment writes this element to cout
	cout << endl;
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1490
movq 0x3d4e(%rip), %rsi      # 0x4fe0
leaq -0x30(%rbp), %rdi
callq 0x14b0
jmp 0x129d
leaq -0x50(%rbp), %rdi
callq 0x14e0
jmp 0x12a8
jmp 0x12aa
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1500
movb %al, -0xbd(%rbp)
jmp 0x12bf
movb -0xbd(%rbp), %al
testb $0x1, %al
jne 0x12cb
jmp 0x131c
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x15a0
jmp 0x12dc
leaq -0x60(%rbp), %rdi
callq 0x15e0
movq %rax, -0xc8(%rbp)
jmp 0x12ee
movq -0xc8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1530
jmp 0x1300
jmp 0x12aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1840
jmp 0x147a
movq 0x3cad(%rip), %rsi      # 0x4fd0
leaq 0x1cda(%rip), %rdx      # 0x3004
leaq -0x70(%rbp), %rdi
callq 0x1600
jmp 0x1335
leaq -0x20(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x16b0
movq -0xd0(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x16e0
movq %rax, -0x80(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1710
jmp 0x136b
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rcx
callq 0x1630
jmp 0x1388
movq 0x3c41(%rip), %rdi      # 0x4fd0
movq 0x3c2a(%rip), %rsi      # 0x4fc0
callq 0x10e0
jmp 0x139d
leaq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x16b0
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x16e0
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1740
testb $0x1, %al
jne 0x13e7
jmp 0x1449
leaq -0xb0(%rbp), %rdi
callq 0x1780
movl (%rax), %eax
movl %eax, -0xbc(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x17a0
movq %rax, -0xd8(%rbp)
jmp 0x140f
movq -0xd8(%rbp), %rdi
callq 0x17c0
movq %rax, -0xe0(%rbp)
jmp 0x1424
movq -0xe0(%rbp), %rdi
leaq -0xbc(%rbp), %rsi
callq 0x17d0
jmp 0x1439
jmp 0x143b
leaq -0xb0(%rbp), %rdi
callq 0x1820
jmp 0x13ce
movq 0x3b80(%rip), %rdi      # 0x4fd0
movq 0x3b69(%rip), %rsi      # 0x4fc0
callq 0x10e0
jmp 0x145e
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1840
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1120
nopw %cs:(%rax,%rax)
nopl (%rax)