LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/czmccrory[P]ManchesterBaby/./assembler.h
// Function: decToBinaryString[abi:cxx11](int, int)
string decToBinaryString(int dec, int length)
{
	string bin = ""; // vector to hold binary value (in this case size 8 for rule.)
	//cout << dec << endl;

	int i;
	for ( i=length; dec>0; i--)
	{
		// take the remainder of the dec / 2 and save it to the vector
		// this value will always be 1 or 0
		int mod = (dec%2);

		if (mod == 1)
		{
			bin += "1";
		}
		else
		{
			bin += "0";
		}

		// update dec
		dec /= 2;
	}

	while (i > 0)
	{
		bin += "0";
		i--;
	}
		//cout << bin <<endl;
		return bin;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x32f3(%rip), %rsi      # 0x60e4
leaq 0xf(%rsp), %rdx
callq 0x4630
leaq 0x327e(%rip), %r15      # 0x6080
leaq 0x3279(%rip), %r12      # 0x6082
testl %r14d, %r14d
jle 0x2e28
testb $0x1, %r14b
movq %r12, %rsi
cmoveq %r15, %rsi
movq %rbx, %rdi
callq 0x2320
shrl %r14d
decl %ebp
jmp 0x2e09
leaq 0x3251(%rip), %r14      # 0x6080
testl %ebp, %ebp
jle 0x2e42
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2320
decl %ebp
jmp 0x2e2f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e54
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::assemble()
void Assembler::assemble()
{
	try
	{
		assembleFirstPass();
		assembleSecondPass();
		flushBufferToFile();
	}
	catch(AssemblerException e)
	{
		cout << "\033[1;31mAssembler Error: \033[0m" << e.what() << endl;
	}
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x2f0c
movq %rbx, %rdi
callq 0x3124
movq %rbx, %rdi
callq 0x328e
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2efb
movq %rbx, %rdi
callq 0x2240
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x48aa
movq %rbx, %rdi
callq 0x20b0
movq 0x7119(%rip), %rdi      # 0x9fd0
leaq 0x31c6(%rip), %rsi      # 0x6084
callq 0x21e0
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x48f4
callq 0x22d0
jmp 0x2e85
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x48f4
callq 0x22d0
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x48e3
nop
// File: /workspace/github_cpp_makefile_star2_O2/czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::assembleFirstPass()
void Assembler::assembleFirstPass()
{
	ifstream ifs(filePath);
	int counter = 0;
	int* lineCounter = &counter;
	string line = "";

	if (! ifs)
	{
		throw AssemblerException("Invalid filename");
	}

	cout << "FIRST PASS:" << endl;

	try
	{
		while (getline(ifs, line)) //while nextLine exists
		{
			string lineCopy = line;
			string* linePtr = &lineCopy;
			cout << "assembling line: " << line << endl;
		 	assembleLineFirstPass(linePtr, lineCounter);
		}
	}
	catch (AssemblerException &e)
	{
		cout << "\033[1;31mAssembler Error: \033[0m" << e.what() << endl;
		exit (0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rdi, %rbx
leaq 0x50(%rdi), %rsi
leaq 0x70(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x22c0
andl $0x0, 0xc(%rsp)
leaq 0x31a7(%rip), %rsi      # 0x60e4
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x4630
movq 0x70(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x90(%rsp,%rax)
jne 0x301d
movq 0x7066(%rip), %rdi      # 0x9fd0
leaq 0x3141(%rip), %rsi      # 0x60b2
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x70(%rsp), %r14
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x312a(%rip), %rbp      # 0x60be
leaq 0xc(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2ff7
movq %r12, %rdi
movq %r15, %rsi
callq 0x2250
movq 0x700c(%rip), %rdi      # 0x9fd0
movq %rbp, %rsi
callq 0x21e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3368
movq %r12, %rdi
callq 0x20e0
jmp 0x2f99
leaq 0x30(%rsp), %rdi
callq 0x20e0
leaq 0x70(%rsp), %rdi
callq 0x2060
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x2100
movq %rax, %r14
leaq 0x3072(%rip), %rsi      # 0x60a1
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x4630
movb $0x1, %bpl
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x4914
xorl %ebp, %ebp
leaq 0x6d19(%rip), %rsi      # 0x9d70
leaq 0x1896(%rip), %rdx      # 0x48f4
movq %r14, %rdi
callq 0x22e0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x20e0
testb %bpl, %bpl
jne 0x3080
jmp 0x3100
movq %rax, %rbx
movq %r14, %rdi
callq 0x2180
jmp 0x3100
movq %rax, %rbx
jmp 0x310a
movq %rax, %rbx
jmp 0x3100
jmp 0x3096
movq %rdx, %r14
movq %rax, %rbx
jmp 0x30ae
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20e0
cmpl $0x1, %r14d
jne 0x3100
movq %rbx, %rdi
callq 0x20b0
movq %rax, %rbx
movq 0x6f0a(%rip), %rdi      # 0x9fd0
leaq 0x2fb7(%rip), %rsi      # 0x6084
callq 0x21e0
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x2220
movq %rax, %rbx
callq 0x22d0
leaq 0x30(%rsp), %rdi
callq 0x20e0
leaq 0x70(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x48e3
// File: /workspace/github_cpp_makefile_star2_O2/czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::assembleSecondPass()
void Assembler::assembleSecondPass()
{
	// prints complete symbol table for reference
	sTable.printTable();

	cout << "\nSECOND PASS:" << endl;

	ifstream ifs(filePath);
	int counter = 0;
	int* lineCounter = &counter;
	string line = "";
	list<string>::iterator it = buffer.begin();

	if (! ifs)
	{
		cerr << "error: invalid filename" << endl;
		return;
	}

	while (getline(ifs, line))
	{
		string lineCopy = line;
		string* linePtr = &lineCopy;

		cout << "assembling line: " << line << endl;
	 	assembleLineSecondPass(linePtr, lineCounter, it);
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x2a54
movq 0x6e88(%rip), %rdi      # 0x9fd0
leaq 0x2fdc(%rip), %rsi      # 0x612b
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x50(%rbx), %rsi
leaq 0x50(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x22c0
andl $0x0, 0xc(%rsp)
leaq 0x2f6b(%rip), %rsi      # 0x60e4
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x4630
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x70(%rsp,%rax)
je 0x31d9
movq 0x6e51(%rip), %rdi      # 0x9ff0
leaq 0x2f93(%rip), %rsi      # 0x6139
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x10(%rsp), %rdi
callq 0x20e0
leaq 0x50(%rsp), %rdi
callq 0x2060
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rbx), %r14
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %r13
leaq 0x2ed0(%rip), %rbp      # 0x60be
leaq 0xc(%rsp), %r15
leaq 0x50(%rsp), %rdi
movq %r12, %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x31b3
movq %r13, %rdi
movq %r12, %rsi
callq 0x2250
movq 0x6db0(%rip), %rdi      # 0x9fd0
movq %rbp, %rsi
callq 0x21e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3d76
movq %r13, %rdi
callq 0x20e0
jmp 0x31f3
movq %rax, %rbx
jmp 0x327b
jmp 0x325f
jmp 0x325f
movq %rax, %rbx
jmp 0x3271
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20e0
leaq 0x10(%rsp), %rdi
callq 0x20e0
leaq 0x50(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::flushBufferToFile()
void Assembler::flushBufferToFile()
{
	ofstream ofs("a." + filePath);

	if (!ofs)
	{
		cerr << "Error opening file for output" << endl;
	}

	list<string>::iterator it;

	for(it = buffer.begin(); it != buffer.end(); ++it)
	{
		ofs << (*it) << endl;
	}

	ofs.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
leaq 0x50(%rdi), %rdx
leaq 0x2f0b(%rip), %rsi      # 0x61b3
movq %rsp, %r14
movq %r14, %rdi
callq 0x49b6
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x2340
movq %rsp, %rdi
callq 0x20e0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x32f6
movq 0x6d0e(%rip), %rdi      # 0x9ff0
leaq 0x2ecd(%rip), %rsi      # 0x61b6
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
addq $0x20, %rbx
leaq 0x20(%rsp), %r14
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x3320
leaq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
jmp 0x3302
leaq 0x20(%rsp), %rdi
callq 0x2260
leaq 0x20(%rsp), %rdi
callq 0x2280
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3352
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20e0
jmp 0x335f
jmp 0x3352
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2280
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::addVariableToSymbolTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Assembler::addVariableToSymbolTable(string label, int address)
{
	// add label (if not already defined)
	sTable.addLabel(label);

	// convert address to binary and add to symboltable
	
	string strAddress = decToBinaryString(address, 6);
	sTable.addAddress(label, strAddress);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rbx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x2250
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2b3e
leaq 0x68(%rsp), %rdi
callq 0x20e0
leaq 0x48(%rsp), %rdi
pushq $0x6
popq %rdx
movl %ebp, %esi
callq 0x2dd6
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x2250
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2250
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2bf4
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
callq 0x20e0
leaq 0x48(%rsp), %rdi
callq 0x20e0
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e0
jmp 0x3bfe
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e0
jmp 0x3c0d
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x3c1c
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::encodeInstructionAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Assembler::encodeInstructionAddress(string mne, string label)
{
	//get opcode (make it a binary string)
	string opcode = getOpcode(mne);

	//get memory address of operand
	string operand = sTable.getAddress(label);

	//initialises templine to be 32 0s
	string tempLine = "";
	for (int i = 0; i < 32; i++)
	{
		tempLine += "0";
	}

	// 6 for 64x32 store
	// 4 for 4 bit opcode (0-15)
	tempLine.replace(0, 6, operand);

	tempLine.replace(13, 4, opcode);

	return tempLine;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0x68(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x2250
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4506
leaq 0x68(%rsp), %rdi
callq 0x20e0
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2250
addq $0x38, %r15
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
callq 0x2cd6
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x2429(%rip), %rsi      # 0x60e4
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x4630
pushq $0x20
popq %rbp
leaq 0x23ae(%rip), %r15      # 0x6080
subl $0x1, %ebp
jb 0x3ce4
movq %r14, %rdi
movq %r15, %rsi
callq 0x2320
jmp 0x3cd2
pushq $0x6
popq %rdx
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
xorl %esi, %esi
callq 0x20a0
pushq $0xd
popq %rsi
pushq $0x4
popq %rdx
leaq 0x48(%rsp), %rcx
movq %r14, %rdi
callq 0x20a0
leaq 0x28(%rsp), %rdi
callq 0x20e0
leaq 0x48(%rsp), %rdi
callq 0x20e0
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x3d5b
movq %rax, %r15
leaq 0x8(%rsp), %rdi
jmp 0x3d60
movq %rax, %r15
jmp 0x3d65
movq %rax, %r15
movq %r13, %rbx
jmp 0x3d65
jmp 0x3d50
movq %rax, %r15
movq %r14, %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::encodeInstructionValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
string Assembler::encodeInstructionValue(string mne, int value)
{
	//get opcode (make it a binary string)
	string opcode = getOpcode(mne);
	cout << "mne: " << mne << " -> opcode: " << opcode << endl;
	//get memory address of operand
	string operand = decToBinaryString(value, 6);
	cout << "operand: " << operand << endl;
	//initialises templine to be 32 0s
	string tempLine = "";
	for (int i = 0; i < 32; i++)
	{
		tempLine += "0";
	}
	// 6 for 64x32 store
	// 4 for 4 bit opcode (0-15)
	tempLine.replace(0, 6, operand);
	tempLine.replace(13, 4, opcode);
	tempLine.replace(31,1, "1");
	return tempLine;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x2250
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4506
leaq 0x48(%rsp), %rdi
callq 0x20e0
movq 0x5c13(%rip), %rdi      # 0x9fd0
leaq 0x1d8d(%rip), %rsi      # 0x6151
callq 0x21e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21d0
leaq 0x1d7c(%rip), %rsi      # 0x6157
movq %rax, %rdi
callq 0x21e0
leaq 0x28(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
pushq $0x6
popq %rdx
movl %ebp, %esi
callq 0x2dd6
movq 0x5bbf(%rip), %rdi      # 0x9fd0
leaq 0x1d4c(%rip), %rsi      # 0x6164
callq 0x21e0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20f0
leaq 0x1cab(%rip), %rsi      # 0x60e4
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x4630
pushq $0x20
popq %rbp
leaq 0x1c30(%rip), %r15      # 0x6080
subl $0x1, %ebp
jb 0x4462
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2320
jmp 0x4450
pushq $0x6
popq %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20a0
pushq $0xd
popq %rsi
pushq $0x4
popq %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
callq 0x20a0
leaq 0x1bf4(%rip), %rcx      # 0x6082
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x2140
leaq 0x8(%rsp), %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44d3
movq %rax, %r12
jmp 0x44f2
movq %rax, %r12
movq %r13, %r15
jmp 0x44f5
jmp 0x44dd
movq %rax, %r12
jmp 0x44e8
movq %rax, %r12
jmp 0x44f5
movq %rax, %r12
movq %rbx, %rdi
callq 0x20e0
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %r14, %r15
movq %r15, %rdi
callq 0x20e0
movq %r12, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/czmccrory[P]ManchesterBaby/assembler.cpp
// Function: main
int main(int argc, char** argv)
{
	if (argc != 2)
	{
		cerr << "error please (only) enter a filename as parameter" << endl;
		return -1;
	}

	// initialises assembler with given filename and runs it
	 Assembler assembler(argv[1]);
	 assembler.assemble();

	 return 0;
	
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
cmpl $0x2, %edi
jne 0x45be
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4630
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x249c
leaq 0x10(%rsp), %rdi
callq 0x20e0
leaq 0x30(%rsp), %rdi
callq 0x2e68
leaq 0x30(%rsp), %rdi
callq 0x498e
xorl %eax, %eax
jmp 0x45dc
movq 0x5a2b(%rip), %rdi      # 0x9ff0
leaq 0x1bb5(%rip), %rsi      # 0x6181
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
pushq $-0x1
popq %rax
addq $0xa0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x498e
jmp 0x4606
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20e0
jmp 0x4606
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/test-1.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	google::sparse_hash_map<uint32_t, uint32_t, Hash32> h;
	h.set_deleted_key(0xfffffffeu);
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		z += ++h[get_key(n, x)];
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %r14d
movl %edi, %ebp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0xf(%rsp), %rcx
leaq 0xe(%rsp), %r8
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x161a
movl $0xfffffffe, (%r12)     # imm = 0xFFFFFFFE
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x1e64
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movl %ebp, %r13d
subl $0x1, %r13d
jb 0x15bb
movl %r14d, %edi
callq 0x12bc
movl %eax, %r14d
movl %ebp, %edi
movl %eax, %esi
callq 0x12e7
movl %eax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x29a4
movl 0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x4(%rax)
addl %ecx, %ebx
incl %ebx
jmp 0x1583
movq 0x8a16(%rip), %rax      # 0x9fd8
movq (%rax), %rdi
leaq 0x40(%rsp), %r14
movq 0x20(%r14), %rdx
subq -0x8(%r14), %rdx
leaq 0x2ab0(%rip), %rsi      # 0x4089
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1110
movl 0x20(%r14), %ebx
subl -0x8(%r14), %ebx
movq %r14, %rdi
callq 0x1636
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1605
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1636
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::set_deleted_key(unsigned int const&)
void set_deleted_key(const key_type &key) {
    // It's only safe to change what "deleted" means if we purge deleted guys
    squash_deleted();
    settings.set_use_deleted(true);
    key_info.delkey = key;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1e86
movb $0x1, 0x1a(%r14)
movl (%rbx), %eax
movl %eax, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::squash_deleted()
void squash_deleted() {           // gets rid of any deleted entries we have
    if ( num_deleted ) {            // get rid of deleted before writing
      sparse_hashtable tmp(MoveDontGrow, *this);
      swap(tmp);                    // now we are tmp
    }
    assert(num_deleted == 0);
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x1ec7
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x1
popq %rsi
pushq $0x20
popq %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1f04
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f84
leaq 0x30(%rsp), %rdi
callq 0x1636
cmpq $0x0, 0x28(%rbx)
jne 0x1ecf
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x2c8c(%rip), %rdi      # 0x4b62
leaq 0x222c(%rip), %rsi      # 0x4109
leaq 0x224d(%rip), %rcx      # 0x4131
movl $0x1d3, %edx            # imm = 0x1D3
callq 0x10a0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1636
movq %rbx, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::swap(google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>&)
void swap(sparse_hashtable& ht) {
    std::swap(settings, ht.settings);
    std::swap(key_info, ht.key_info);
    std::swap(num_deleted, ht.num_deleted);
    table.swap(ht.table);
    settings.reset_thresholds(bucket_count());  // also resets consider_shrink
    ht.settings.reset_thresholds(ht.bucket_count());
    // we purposefully don't swap the allocator, which may not be swap-able
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movl 0x20(%rdi), %eax
movl 0x20(%rsi), %ecx
movl %ecx, 0x20(%rdi)
movl %eax, 0x20(%rsi)
movq 0x28(%rdi), %rax
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x28(%rsi)
addq $0x30, %rdi
addq $0x30, %rsi
callq 0x294e
movq 0x48(%r14), %rsi
movq %r14, %rdi
callq 0x1860
movq 0x48(%rbx), %rsi
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x1860
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::clear()
void clear() {
    if (!empty() || (num_deleted != 0)) {
      table.clear();
    }
    settings.reset_thresholds(bucket_count());
    num_deleted = 0;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
orq 0x50(%rdi), %rax
je 0x216d
leaq 0x30(%rbx), %rdi
callq 0x2454
movq 0x48(%rbx), %rsi
movq %rbx, %rdi
callq 0x1860
andq $0x0, 0x28(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: std::pair<unsigned int const, unsigned int>& google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::find_or_insert<google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::DefaultValue>(unsigned int const&)
value_type& find_or_insert(const key_type& key) {
    // First, double-check we're not inserting delkey
    assert((!settings.use_deleted() || !equals(key, key_info.delkey))
           && "Inserting the deleted key");
    const std::pair<size_type,size_type> pos = find_position(key);
    DefaultValue default_value;
    if ( pos.first != ILLEGAL_BUCKET) {  // object was already there
      return *table.get_iter(pos.first);
    } else if (resize_delta(1)) {        // needed to rehash to make room
      // Since we resized, we can't use pos, so recalculate where to insert.
      return *insert_noresize(default_value(key)).first;
    } else {                             // no need to rehash, insert right here
      return *insert_at(default_value(key), pos.second);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x1a(%rdi)
jne 0x29c5
movl (%r14), %eax
cmpl 0x20(%rbx), %eax
je 0x2a4e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a6e
cmpq $-0x1, %rax
je 0x29f3
addq $0x30, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2b2a
movq 0x18(%r14), %rax
jmp 0x2a44
movq %rdx, %r15
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2bca
testb %al, %al
je 0x2a22
movl (%r14), %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d38
jmp 0x2a40
movl (%r14), %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2e2e
movq 0x20(%r14), %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2f7c(%rip), %rdi      # 0x59d1
leaq 0x16ad(%rip), %rsi      # 0x4109
leaq 0x2fc8(%rip), %rcx      # 0x5a2b
movl $0x3e4, %edx            # imm = 0x3E4
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::insert_noresize(std::pair<unsigned int const, unsigned int> const&)
std::pair<iterator, bool> insert_noresize(const_reference obj) {
    // First, double-check we're not inserting delkey
    assert((!settings.use_deleted() || !equals(get_key(obj), key_info.delkey))
           && "Inserting the deleted key");
    const std::pair<size_type,size_type> pos = find_position(get_key(obj));
    if ( pos.first != ILLEGAL_BUCKET) {      // object was already there
      return std::pair<iterator,bool>(iterator(this, table.get_iter(pos.first),
                                               table.nonempty_end()),
                                      false);     // false: we didn't insert
    } else {                                 // pos.second says where to put it
      return std::pair<iterator,bool>(insert_at(obj, pos.second), true);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x1a(%rsi)
jne 0x2d64
movl (%r15), %eax
cmpl 0x20(%r14), %eax
je 0x2e0f
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a6e
cmpq $-0x1, %rax
je 0x2de5
leaq 0x30(%r14), %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2b2a
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3204
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
leaq 0x48(%rsp), %r15
movups %xmm1, 0x38(%r15)
movups %xmm0, 0x28(%r15)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, 0x8(%r15)
movups %xmm1, 0x18(%r15)
movq %r14, (%r15)
movq %r15, %rdi
callq 0x3242
pushq $0x9
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
xorl %eax, %eax
jmp 0x2df8
movq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2e2e
movb $0x1, %al
movb %al, 0x48(%rbx)
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3c41(%rip), %rdi      # 0x6a57
leaq 0x12ec(%rip), %rsi      # 0x4109
leaq 0x3c96(%rip), %rcx      # 0x6aba
movl $0x3af, %edx            # imm = 0x3AF
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::insert_at(std::pair<unsigned int const, unsigned int> const&, unsigned long)
iterator insert_at(const_reference obj, size_type pos) {
    if (size() >= max_size()) {
      throw std::length_error("insert overflow");
    }
    if ( test_deleted(pos) ) {      // just replace if it's been deleted
      // The set() below will undelete this object.  We just worry about stats
      assert(num_deleted > 0);
      --num_deleted;                // used to be, now it isn't
    }
    table.set(pos, obj);
    return iterator(this, table.get_iter(pos), table.nonempty_end());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq 0x50(%rsi), %rax
subq 0x28(%rsi), %rax
movabsq $0x1fffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jae 0x2ef8
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x2f5a
testb %al, %al
je 0x2e85
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x2f28
decq %rax
movq %rax, 0x28(%r14)
leaq 0x30(%r14), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x238e
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x2b2a
movq %rsp, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x3204
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, 0x8(%rbx)
movups %xmm1, 0x18(%rbx)
movq %r14, (%rbx)
movq %rbx, %rdi
callq 0x3242
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x1070
movq %rax, %rbx
leaq 0x44cd(%rip), %rsi      # 0x73d7
movq %rax, %rdi
callq 0x10c0
movq 0x70c7(%rip), %rsi      # 0x9fe0
movq 0x70b0(%rip), %rdx      # 0x9fd0
movq %rbx, %rdi
callq 0x1160
leaq 0x1f54(%rip), %rdi      # 0x4e83
leaq 0x11d3(%rip), %rsi      # 0x4109
leaq 0x44aa(%rip), %rcx      # 0x73e7
movl $0x3a4, %edx            # imm = 0x3A4
callq 0x10a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x10b0
movq %r14, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::test_deleted(unsigned long) const
bool test_deleted(size_type bucknum) const {
    // Invariant: !use_deleted() implies num_deleted is 0.
    assert(settings.use_deleted() || num_deleted == 0);
    return num_deleted > 0 && table.test(bucknum) &&
        test_deleted_key(get_key(table.unsafe_get(bucknum)));
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
sete %cl
orb 0x1a(%rdi), %cl
je 0x2fac
testq %rax, %rax
je 0x2fa4
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x2342
testb %al, %al
je 0x2fa4
movq %r15, %rdi
movq %r14, %rsi
callq 0x2fcc
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2864
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b95(%rip), %rdi      # 0x4b48
leaq 0x114f(%rip), %rsi      # 0x4109
leaq 0x30eb(%rip), %rcx      # 0x60ac
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x10a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Reputeless[P]PerlinNoise/./PerlinNoise.hpp
// Function: void siv::perlin_detail::Shuffle<unsigned char*, std::random_device>(unsigned char*, unsigned char*, std::random_device&&)
inline void Shuffle(RandomIt first, RandomIt last, URBG&& urbg)
		{
			if (first == last)
			{
				return;
			}

			using difference_type = typename std::iterator_traits<RandomIt>::difference_type;

			for (RandomIt it = first + 1; it < last; ++it)
			{
				const std::uint64_t n = static_cast<std::uint64_t>(it - first);
				std::iter_swap(it, first + static_cast<difference_type>(Random(n, std::forward<URBG>(urbg))));
			}
		}

// Assembly:
cmpq %rsi, %rdi
je 0x32a0
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %r12
leaq (%r15,%r12), %rax
cmpq %r14, %rax
jae 0x3298
movq %r12, %rdi
movq %rbx, %rsi
callq 0x32a1
movb (%r15,%r12), %cl
movb (%r15,%rax), %dl
movb %dl, (%r15,%r12)
movb %cl, (%r15,%rax)
incq %r12
jmp 0x326f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Reputeless[P]PerlinNoise/./PerlinNoise.hpp
// Function: auto siv::perlin_detail::Octave3D<siv::BasicPerlinNoise<double>, double>(siv::BasicPerlinNoise<double> const&, double, double, double, int, double)
[[nodiscard]]
		inline auto Octave3D(const Noise& noise, Float x, Float y, Float z, const std::int32_t octaves, const Float persistence) noexcept
		{
			using value_type = Float;
			value_type result = 0;
			value_type amplitude = 1;

			for (std::int32_t i = 0; i < octaves; ++i)
			{
				result += (noise.noise3D(x, y, z) * amplitude);
				x *= 2;
				y *= 2;
				z *= 2;
				amplitude *= persistence;
			}

			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm3, -0x30(%rbp)
movq %rdi, %rbx
xorl %r14d, %r14d
testl %esi, %esi
cmovgl %esi, %r14d
movsd 0xd4e(%rip), %xmm4      # 0x4038
xorpd %xmm3, %xmm3
subl $0x1, %r14d
jb 0x3358
movq %rbx, %rdi
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm1, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd %xmm2, -0x28(%rbp)
movsd -0x28(%rbp), %xmm2
movsd %xmm3, -0x40(%rbp)
movsd %xmm4, -0x38(%rbp)
callq 0x3366
movsd -0x38(%rbp), %xmm4
movsd -0x40(%rbp), %xmm3
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
mulsd %xmm4, %xmm0
addsd %xmm0, %xmm3
movsd -0x18(%rbp), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm1
addsd %xmm2, %xmm2
mulsd -0x30(%rbp), %xmm4
jmp 0x32ee
movapd %xmm3, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Reputeless[P]PerlinNoise/./PerlinNoise.hpp
// Function: double siv::perlin_detail::Grad<double>(unsigned char, double, double, double)
[[nodiscard]]
		inline constexpr Float Grad(const std::uint8_t hash, const Float x, const Float y, const Float z) noexcept
		{
			const std::uint8_t h = hash & 15;
			const Float u = h < 8 ? x : y;
			const Float v = h < 4 ? y : h == 12 || h == 14 ? x : z;
			return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
andb $0xf, %al
movapd %xmm1, %xmm3
cmpb $0x4, %al
jb 0x36b2
andb $0xd, %dil
movapd %xmm0, %xmm3
cmpb $0xc, %dil
je 0x36b2
movapd %xmm2, %xmm3
cmpb $0x8, %al
jb 0x36ba
movapd %xmm1, %xmm0
movapd 0x9ae(%rip), %xmm1      # 0x4070
testb $0x1, %al
je 0x36ca
xorpd %xmm1, %xmm0
testb $0x2, %al
je 0x36d2
xorpd %xmm1, %xmm3
addsd %xmm3, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Reputeless[P]PerlinNoise/./PerlinNoise.hpp
// Function: auto siv::perlin_detail::Octave2D<siv::BasicPerlinNoise<double>, double>(siv::BasicPerlinNoise<double> const&, double, double, int, double)
[[nodiscard]]
		inline auto Octave2D(const Noise& noise, Float x, Float y, const std::int32_t octaves, const Float persistence) noexcept
		{
			using value_type = Float;
			value_type result = 0;
			value_type amplitude = 1;

			for (std::int32_t i = 0; i < octaves; ++i)
			{
				result += (noise.noise2D(x, y) * amplitude);
				x *= 2;
				y *= 2;
				amplitude *= persistence;
			}

			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm2, -0x28(%rbp)
movq %rdi, %rbx
xorl %r14d, %r14d
testl %esi, %esi
cmovgl %esi, %r14d
movsd 0x728(%rip), %xmm3      # 0x4038
xorpd %xmm2, %xmm2
subl $0x1, %r14d
jb 0x396b
movq %rbx, %rdi
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm1, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd %xmm2, -0x38(%rbp)
movsd %xmm3, -0x30(%rbp)
callq 0x3978
movsd -0x30(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm3, %xmm0
addsd %xmm0, %xmm2
movsd -0x18(%rbp), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm1
mulsd -0x28(%rbp), %xmm3
jmp 0x3914
movapd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/biconnectivity.cpp
// Function: GraphAlgo::biconnectivity::new_bicomponent(int const&, int const&)
void biconnectivity::
new_bicomponent( const vertex& v, const vertex& w )
{
	int f, s ;
	graph gr;

	do {
		f = m_edge_stack.top().first;
		s = m_edge_stack.top().second;
		gr.add_edge(m_edge_stack.top());
		m_edge_stack.pop();
	} while ( ! ( f == v && s == w) );

	graphs_out.push_back(gr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x769a
leaq 0x8(%rbx), %r13
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x3113
leaq -0x8(%rsi), %rax
leaq -0x4(%rsi), %rcx
jmp 0x3130
movq 0x50(%rbx), %rax
movq -0x8(%rax), %rsi
leaq 0x1f8(%rsi), %rax
leaq 0x1fc(%rsi), %rcx
addq $0x200, %rsi            # imm = 0x200
movl (%rax), %r14d
movl (%rcx), %ebp
addq $-0x8, %rsi
movq %r12, %rdi
callq 0x7460
movq %r13, %rdi
callq 0x3a5a
cmpl (%r15), %r14d
jne 0x30ff
movq (%rsp), %rax
cmpl (%rax), %ebp
jne 0x30ff
addq $0x148, %rbx            # imm = 0x148
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x372e
leaq 0x8(%rsp), %rdi
callq 0x76c4
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3185
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x76c4
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/biconnectivity.cpp
// Function: GraphAlgo::biconnectivity::bicomponents()
void biconnectivity::
bicomponents()
{
	time =  0;

	vertices::const_iterator it = m_vertices.begin();
	for ( ; it != m_vertices.end(); ++it)
	{
		m_parent.insert(parent::value_type( *it, -1 ));
		m_discovery_time.insert(discovery_time::value_type( *it, time ));
		m_back.insert(back::value_type( *it,  m_vertices.size()  + 1 ));
	}
	
	vertices::const_iterator it2 = m_vertices.begin();
	for ( ; it2 != m_vertices.end(); ++it2)
	{
		if( m_discovery_time[*it2] == 0) {
			biDFS(*it2);     // for each connected graph
		}
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, (%rdi)
movq 0x160(%rdi), %rbp
leaq 0x58(%rdi), %r15
leaq 0x88(%rdi), %r14
leaq 0xb8(%rdi), %r12
movq %rsp, %r13
cmpq 0x168(%rbx), %rbp
je 0x3458
movl (%rbp), %eax
movl %eax, (%rsp)
orl $-0x1, 0x4(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x4614
movl (%rbp), %eax
movl %eax, (%rsp)
movl (%rbx), %eax
movl %eax, 0x4(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x4614
movq 0x168(%rbx), %rax
subq 0x160(%rbx), %rax
shrq $0x2, %rax
movl (%rbp), %ecx
movl %ecx, (%rsp)
incl %eax
movl %eax, 0x4(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x4614
addq $0x4, %rbp
jmp 0x33f3
movq 0x160(%rbx), %r15
cmpq %rbp, %r15
je 0x348c
movq %r14, %rdi
movq %r15, %rsi
callq 0x375a
cmpl $0x0, (%rax)
jne 0x347f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x319a
addq $0x4, %r15
movq 0x168(%rbx), %rbp
jmp 0x345f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/biconnectivity.cpp
// Function: GraphAlgo::biconnectivity::biconnectivity(GraphAlgo::graph const&)
biconnectivity::
biconnectivity( const graph& g )
{
	g_in = g;

	m_vertices = g_in.get_vertices();
	m_neighborhood = g_in.get_neighborhood();
		
	bicomponents();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbp
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x37f6
leaq 0x60(%r14), %rax
andl $0x0, 0x60(%r14)
andq $0x0, 0x68(%r14)
movq %rax, 0x70(%r14)
movq %rax, 0x78(%r14)
andq $0x0, 0x80(%r14)
leaq 0x90(%r14), %rax
andl $0x0, 0x90(%r14)
andq $0x0, 0x98(%r14)
movq %rax, 0xa0(%r14)
movq %rax, 0xa8(%r14)
andq $0x0, 0xb0(%r14)
andl $0x0, 0xc0(%r14)
andq $0x0, 0xc8(%r14)
leaq 0xc0(%r14), %rax
movq %rax, 0xd0(%r14)
movq %rax, 0xd8(%r14)
andq $0x0, 0xe0(%r14)
leaq 0xe8(%r14), %r15
movq %r15, %rdi
callq 0x769a
andl $0x0, 0x180(%r14)
andq $0x0, 0x188(%r14)
leaq 0x160(%r14), %r12
leaq 0x180(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%r14)
movups %xmm0, 0x158(%r14)
movups %xmm0, 0x168(%r14)
movq %rax, 0x190(%r14)
movq %rax, 0x198(%r14)
andq $0x0, 0x1a0(%r14)
leaq 0x1a8(%r14), %r13
leaq 0x1b0(%r14), %rax
andl $0x0, 0x1b0(%r14)
andq $0x0, 0x1b8(%r14)
movq %rax, 0x1c0(%r14)
movq %rax, 0x1c8(%r14)
andq $0x0, 0x1d0(%r14)
movq %r15, %rdi
movq %rbp, %rsi
callq 0x76e4
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x70ac
leaq 0x18(%rsp), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4886
movq %rbp, %rdi
callq 0x4852
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x706c
leaq 0x18(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x383e
movq %rbp, %rdi
callq 0x393e
movq %r14, %rdi
callq 0x33c6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x363d
jmp 0x363d
movq %rax, 0x8(%rsp)
jmp 0x367f
movq %rax, 0x8(%rsp)
leaq 0x148(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0x178(%r14), %rbp
movq %r13, %rdi
callq 0x393e
movq %rbp, %rdi
callq 0x3952
movq %r12, %rdi
callq 0x4852
movq 0x10(%rsp), %rdi
callq 0x3812
movq %r15, %rdi
callq 0x76c4
leaq 0xb8(%r14), %rdi
leaq 0x88(%r14), %r15
addq $0x58, %r14
callq 0x39aa
movq %r15, %rdi
callq 0x39aa
movq %r14, %rdi
callq 0x39aa
movq %rbx, %rdi
callq 0x3a02
movq 0x8(%rsp), %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/connectivity.cpp
// Function: GraphAlgo::connectivity::connected_parts(GraphAlgo::graph&)
void connectivity::
connected_parts( graph& g_in ) 
{
	while( !g_in.get_vertices().empty() )
	{
		initialize();	

		graph g_copy = g_in;
		visit::iterator it = m_visit.begin();
		for ( ; it != m_visit.end(); ++it )
		{
			if ( it->second == false ) {
				g_copy.remove_vertex(it->first);
			}
			if ( it->second == true ) {
				g_in.remove_vertex(it->first);	
			}
		}
		graphs_out.push_back( g_copy );

		connected_parts( g_in );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x80(%rdi), %rbp
leaq 0x60(%rdi), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x70ac
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %r15
movq %r12, %rdi
callq 0x4852
cmpq %r15, %r13
je 0x4998
movq %r14, %rdi
callq 0x49be
movq %r12, %rdi
movq %rbx, %rsi
callq 0x75e0
movq 0x90(%r14), %r13
cmpq %rbp, %r13
je 0x4974
cmpb $0x0, 0x24(%r13)
jne 0x495b
movl 0x20(%r13), %esi
movq %r12, %rdi
callq 0x6d5c
testb $0x1, 0x24(%r13)
je 0x4967
movl 0x20(%r13), %esi
movq %rbx, %rdi
callq 0x6d5c
movq %r13, %rdi
callq 0x2100
movq %rax, %r13
jmp 0x493c
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x372e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x48d8
movq %r12, %rdi
callq 0x76c4
jmp 0x4900
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49a9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x76c4
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/connectivity.cpp
// Function: GraphAlgo::connectivity::initialize()
void connectivity::
initialize()
{	
	vertex first = g_in.get_vertices().front();
	
	dfs tree(g_in, first);
	
	m_visit.clear();
	m_visit = tree.get_visit();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70ac
movq (%r14), %rax
movl (%rax), %ebp
movq %r14, %rdi
callq 0x4852
leaq 0x4(%rsp), %rdx
movl %ebp, (%rdx)
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4cc4
addq $0x78, %rbx
movq %rbx, %rdi
callq 0x4b94
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4c22
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b46
movq %r14, %rdi
callq 0x4c06
leaq 0x38(%rsp), %rdi
callq 0x4e5e
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4e5e
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/connectivity.cpp
// Function: GraphAlgo::connectivity::is_connected()
bool connectivity::
is_connected()
{
	initialize();	

	visit::iterator it = m_visit.begin();
	for( ; it != m_visit.end(); ++it )
	{
		if ( it->second == false ) {
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x49be
movq 0x90(%rbx), %rax
subq $-0x80, %rbx
cmpq %rbx, %rax
je 0x4a85
cmpb $0x0, 0x24(%rax)
je 0x4a85
movq %rax, %rdi
callq 0x2100
jmp 0x4a70
cmpq %rbx, %rax
sete %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AraKhachatryan[P]GraphAlgo/dfs.cpp
// Function: GraphAlgo::dfs::dfs_traversal(int const&)
void dfs::
dfs_traversal( const vertex& v )
{
	vertices::const_iterator it = m_neighborhood[v].begin();
	for ( ; it != m_neighborhood[v].end(); ++it ) 
	{
		if ( ! m_visit[*it] ) 
		{
			m_visit[*it] = true ;
			g_out.add_edge(v, *it);
			dfs_traversal(*it);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x108(%rdi), %r15
movq %r15, %rdi
callq 0x37a8
movq (%rax), %r12
leaq 0xc0(%r14), %r13
leaq 0x60(%r14), %rbp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37a8
cmpq 0x8(%rax), %r12
je 0x4cb4
movq %r13, %rdi
movq %r12, %rsi
callq 0x4e98
cmpb $0x0, (%rax)
jne 0x4cae
movq %r13, %rdi
movq %r12, %rsi
callq 0x4e98
movb $0x1, (%rax)
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7114
movq %r14, %rdi
movq %r12, %rsi
callq 0x4c38
addq $0x4, %r12
jmp 0x4c66
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop