LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ljc2154[P]Rummy/rummy.cpp
// Function: removeWorstCard(State&)
int removeWorstCard(State &state)
{
	State testState = state;

	/* Empty agent hand of testState */
	while (testState.agentHand.empty() == false)
		testState.agentHand.pop_back();

	int maxEval = 0;
	int maxEvalIndex = 0;
	int eval = 0;

	/* Find the card that when removed produces the highest score */
	for (int i = 0; i < state.agentHand.size(); i++)
	{
		for (int j = 0; j < state.agentHand.size(); j++)
		{
			if (i != j)
				testState.agentHand.push_back(state.agentHand[j]);
		}

		eval = evaluate(testState);
		if (eval > maxEval)
		{
			maxEval = eval;
			maxEvalIndex = i;
		}

		/* Empty agent hand of testState */
		while (testState.agentHand.empty() == false)
			testState.agentHand.pop_back();
	}

	int returnVal = state.agentHand[maxEvalIndex];

	/* Remove worst card */
	state.agentHand.erase(state.agentHand.begin() + maxEvalIndex);

	return returnVal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x2a20
leaq 0x30(%rsp), %r14
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
je 0x2903
addq $-0x4, %rcx
movq %rcx, 0x38(%rsp)
jmp 0x28f3
leaq 0x18(%rbx), %rax
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
xorl %edx, %edx
xorl %r12d, %r12d
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rax
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0x29c3
movl %edx, 0xc(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x2968
cmpq %r13, %r15
je 0x295f
addq %rbp, %rsi
movq %r14, %rdi
callq 0x2ac8
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rax
incq %r13
addq $0x4, %rbp
jmp 0x2938
leaq 0x80(%rsp), %r13
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2a20
movq %r13, %rdi
callq 0x23ae
movl %eax, %ebp
movq %r13, %rdi
callq 0x2aa0
cmpl %r12d, %ebp
movl 0xc(%rsp), %edx
cmovgl %r15d, %edx
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq %rax, %rcx
je 0x29b4
addq $-0x4, %rcx
movq %rcx, 0x38(%rsp)
jmp 0x29a4
cmpl %r12d, %ebp
cmovgl %ebp, %r12d
incq %r15
jmp 0x2914
movslq %edx, %rax
leaq (%rsi,%rax,4), %rsi
movl (%rsi), %ebx
movq 0x10(%rsp), %rdi
callq 0x2b9c
leaq 0x18(%rsp), %rdi
callq 0x2aa0
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a0a
jmp 0x2a0a
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x2aa0
jmp 0x2a0d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2aa0
movq %rbx, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/crc32.c
// Function: crc32
void crc32(const void *data, size_t n_bytes, uint32_t* crc)
{
	static uint32_t table[0x100];

	if(!*table)
	{
		for(size_t i = 0; i < 0x100; ++i)
		{
			table[i] = crc32_for_byte(i);
		}
	}

	for(size_t i = 0; i < n_bytes; ++i)
	{
		*crc = table[(uint8_t)*crc ^ ((uint8_t*)data)[i]] ^ *crc >> 8;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x2e9e(%rip)      # 0x4070
je 0x120a
xorl %eax, %eax
leaq 0x2e93(%rip), %rdi      # 0x4070
cmpq %rax, %r14
je 0x11fb
movl (%rbx), %ecx
movzbl %cl, %edx
movzbl (%r15,%rax), %esi
xorl %edx, %esi
shrl $0x8, %ecx
xorl (%rdi,%rsi,4), %ecx
movl %ecx, (%rbx)
incq %rax
jmp 0x11dd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
leaq 0x2e5c(%rip), %r13      # 0x4070
cmpq $0x100, %r12            # imm = 0x100
je 0x11d4
movl %r12d, %edi
callq 0x118c
movl %eax, (%r13)
incq %r12
addq $0x4, %r13
jmp 0x1214
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/crc32.c
// Function: main
int main(int argc, char** argv)
{
	FILE *fp;
	char buf[1L << 15];

	for(int i = argc > 1; i < argc; ++i)
	{
		if((fp = i ? fopen(argv[i], "rb"): stdin))
		{ 
			uint32_t crc = 0;
			while(!feof(fp) && !ferror(fp))
			{
				crc32(buf, fread(buf, 1, sizeof(buf), fp), &crc);
			}
			if(!ferror(fp))
			{
				printf("%08X%s%s\n", crc, argc > 2? "\t": "", argc > 2? argv[i]: "");
			}
			if(i)
			{
				fclose(fp);
			}
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8028, %rsp           # imm = 0x8028
movq %rsi, -0x38(%rbp)
xorl %ebx, %ebx
cmpl $0x2, %edi
leaq 0xdbb(%rip), %rax       # 0x2011
leaq 0xdb5(%rip), %rcx       # 0x2012
cmovleq %rcx, %rax
movq %rax, -0x40(%rbp)
setge %bl
movl %edi, -0x30(%rbp)
movslq %edi, %rax
movq %rax, -0x48(%rbp)
leaq -0x8050(%rbp), %r12
pushq $0x1
popq %r13
leaq -0x2c(%rbp), %r14
cmpq -0x48(%rbp), %rbx
jge 0x1346
testq %rbx, %rbx
je 0x12a9
movq -0x38(%rbp), %rax
movq (%rax,%rbx,8), %rdi
leaq 0xd65(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, %r15
jmp 0x12b3
movq 0x2d30(%rip), %rax      # 0x3fe0
movq (%rax), %r15
testq %r15, %r15
je 0x133e
andl $0x0, -0x2c(%rbp)
movq %r15, %rdi
callq 0x1070
testl %eax, %eax
jne 0x12fb
movq %r15, %rdi
callq 0x1030
testl %eax, %eax
jne 0x12fb
movl $0x8000, %edx           # imm = 0x8000
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq 0x1040
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x11b4
jmp 0x12c0
movq %r15, %rdi
callq 0x1030
testl %eax, %eax
jne 0x1331
leaq 0xd04(%rip), %rcx       # 0x2012
cmpl $0x3, -0x30(%rbp)
jl 0x131c
movq -0x38(%rbp), %rax
movq (%rax,%rbx,8), %rcx
movl -0x2c(%rbp), %esi
leaq 0xce1(%rip), %rdi       # 0x2007
movq -0x40(%rbp), %rdx
xorl %eax, %eax
callq 0x1060
testq %rbx, %rbx
je 0x133e
movq %r15, %rdi
callq 0x1050
incq %rbx
jmp 0x1281
xorl %eax, %eax
addq $0x8028, %rsp           # imm = 0x8028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bitwiseshiftleft[P]crandom/raw_random.cpp
// Function: main
int main(int argc, char **argv) {
  (void) argc; (void) argv;
  
  const int buffer_size = 65536;

  // auto-seeded?
  prg_generator<chacha> gen(true);

  unsigned char buffer[buffer_size];

  if (isatty(1)) {
    fprintf(stderr, "%s: refusing to write random data to a terminal.\n", argv[0]);
    return 1;
  }

  while(true) {
    gen.randomize(buffer, buffer_size);
    long long int ret = write(1, buffer, buffer_size);
    assert(ret == buffer_size);
  }

  return 2;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10030, %rsp          # imm = 0x10030
movq %rsi, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x1310
movl %ebp, %edi
callq 0x1120
testl %eax, %eax
je 0x12a8
movq 0x4d65(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x1d7c(%rip), %rsi      # 0x3004
xorl %eax, %eax
callq 0x10f0
leaq 0x8(%rsp), %rdi
callq 0x14a0
pushq $0x1
popq %rax
addq $0x10030, %rsp          # imm = 0x10030
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8(%rsp), %rbx
leaq 0x30(%rsp), %r14
pushq $0x1
popq %rbp
movl $0x10000, %edx          # imm = 0x10000
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1334
movl $0x10000, %edx          # imm = 0x10000
movl %ebp, %edi
movq %r14, %rsi
callq 0x1040
cmpq $0x10000, %rax          # imm = 0x10000
je 0x12b5
leaq 0x1d53(%rip), %rdi      # 0x3036
leaq 0x1d5f(%rip), %rsi      # 0x3049
leaq 0x1d67(%rip), %rcx      # 0x3058
pushq $0x1c
popq %rdx
callq 0x1080
jmp 0x12fb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x14a0
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O2/bitwiseshiftleft[P]crandom/./crandom.hpp
// Function: crandom::generator_base::randomize(unsigned char*, unsigned long)
void randomize(unsigned char *__restrict__ output, size_t n) {
    if (unlikely(!fill)) refill();
    if (likely(fill >= n)) {
      fill -= (u_int32_t)n;
      
      // the compiler will optimize this if n is known and small (eg 4)
      memcpy(output, buffer+fill, n);
      bzero(buffer+fill, n);
    } else {
      randomize_slow_case(output, n);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x14(%rdi), %r12d
testl %r12d, %r12d
je 0x1387
movl %r12d, %eax
cmpq %rbx, %rax
jb 0x1396
subl %ebx, %r12d
movl %r12d, 0x14(%r15)
addq 0x18(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x10b0
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1070
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movl 0x14(%r15), %r12d
jmp 0x134e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14b4
nop
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/log_parser.cpp
// Function: dataCollection(CmdRecord*, std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void dataCollection(CmdRecord* curr_record, ifstream& log_file, std::string temp_data) {
	// find the length in words of the command data
	int length = (curr_record->HexToDec(temp_data) / 4);
	int field_counter = 0;
	int indexer = 0;
	std::string curr_field;

	for (int i = 0; i < (length*NUM_FIELDS); i++)  {
		log_file >> curr_field;
		field_counter++;

		if (field_counter == DATA) {
			// we have the Data field value (this is special if it's in the address of
			// a command we want, so set it aside for later)
			//curr_node->curr_record.Set_Data(i, curr_field.substr(0,4);
			//curr_node->curr_record.Set_Data(i+1, curr_field.substr(4,4));
			curr_record->Set_Data(indexer, curr_field.substr(0,4));
			curr_record->Set_Data(indexer+1, curr_field.substr(4,4));
			indexer += 2;

		} else if (field_counter == ENDLINE) {
			field_counter = 0;
			line_count++;
		}
	}

	curr_record->Set_Total_Words(length);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x2230
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3386
pushq $0x4
popq %rcx
cltd
idivl %ecx
movl %eax, %ebx
leaq -0xb8(%rbp), %rdi
callq 0x20e0
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl %ebx, -0x34(%rbp)
imull $0xe, %ebx, %r13d
xorl %ebx, %ebx
testl %r13d, %r13d
cmovlel %ebx, %r13d
leaq -0x58(%rbp), %r12
xorl %r15d, %r15d
subl $0x1, %r13d
jb 0x2b0c
movq %r14, %rdi
movq %r12, %rsi
callq 0x2200
cmpl $0xd, %ebx
je 0x2af8
cmpl $0x7, %ebx
jne 0x2b05
leaq -0x98(%rbp), %rdi
movq %r12, %rsi
xorl %edx, %edx
pushq $0x4
popq %rcx
callq 0x21b0
movq -0x30(%rbp), %rdi
movl %r15d, %esi
leaq -0x98(%rbp), %rbx
movq %rbx, %rdx
callq 0x3230
movq %rbx, %rdi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r12, %rsi
pushq $0x4
popq %rcx
movq %rcx, %rdx
callq 0x21b0
leal 0x1(%r15), %esi
movq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rbx
movq %rbx, %rdx
callq 0x3230
movq %rbx, %rdi
callq 0x20e0
addl $0x2, %r15d
pushq $0x8
popq %rax
movl %eax, %ebx
jmp 0x2a6b
incl 0x569a(%rip)            # 0x8198
xorl %ebx, %ebx
jmp 0x2a6b
incl %ebx
jmp 0x2a6b
movq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x32e4
leaq -0x58(%rbp), %rdi
callq 0x20e0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b5b
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
jmp 0x2b62
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
jmp 0x2b54
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x20e0
jmp 0x2b5e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/log_parser.cpp
// Function: timeConverter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
float timeConverter(string timeString) {
	string str = timeString.substr(0, timeString.length() - 2);
	float result = atof(str.c_str());
	string time = timeString.substr(timeString.length() - 2, 2);
	if(time == "us")
		return pow(result, -6);
	else if (time == "ns")
		return pow(result, -9);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
addq $-0x2, %rcx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21b0
movq (%r14), %rdi
callq 0x21f0
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rbx), %rdx
addq $-0x2, %rdx
leaq -0x38(%rbp), %rdi
pushq $0x2
popq %rcx
movq %rbx, %rsi
callq 0x21b0
leaq 0x2506(%rip), %rsi      # 0x50c7
leaq -0x38(%rbp), %rdi
callq 0x2c77
testb %al, %al
je 0x2bd8
movsd 0x2462(%rip), %xmm1     # 0x5038
jmp 0x2bf0
leaq 0x24eb(%rip), %rsi      # 0x50ca
leaq -0x38(%rbp), %rdi
callq 0x2c77
movsd 0x2450(%rip), %xmm1     # 0x5040
cvtsd2ss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x22b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20e0
leaq -0x58(%rbp), %rdi
callq 0x20e0
movss -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/CmdRecord.cpp
// Function: CmdRecord::CmdRecord()
CmdRecord::CmdRecord()
{
	line_number = "";
	address = "";
	//data [100];
	std::vector<std::string>(100);
	size = "";
	cycle = "";
	reltime = "";
	wordsLength = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r14
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
leaq 0x58(%rdi), %r15
movb %al, 0x68(%rdi)
leaq 0x78(%rdi), %r12
leaq 0x88(%rdi), %rcx
movq %rcx, 0x78(%rdi)
andq $0x0, 0x80(%rdi)
movb %al, 0x88(%rdi)
leaq 0x98(%rdi), %r13
leaq 0xa8(%rdi), %rcx
movq %rcx, 0x98(%rdi)
andq $0x0, 0xa0(%rdi)
movb %al, 0xa8(%rdi)
leaq 0x2339(%rip), %rsi      # 0x5465
callq 0x22f0
leaq 0x232d(%rip), %rsi      # 0x5465
movq %r14, %rdi
callq 0x22f0
leaq -0x58(%rbp), %rdi
pushq $0x64
popq %rsi
leaq -0x29(%rbp), %rdx
callq 0x3a08
leaq -0x58(%rbp), %rdi
callq 0x2e6e
leaq 0x2305(%rip), %rsi      # 0x5465
movq %r15, %rdi
callq 0x22f0
leaq 0x22f6(%rip), %rsi      # 0x5465
movq %r12, %rdi
callq 0x22f0
leaq 0x22e7(%rip), %rsi      # 0x5465
movq %r13, %rdi
callq 0x22f0
andl $0x0, 0xb8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x319e
movq %rax, -0x38(%rbp)
leaq 0x40(%rbx), %rax
movq %rax, -0x40(%rbp)
movq %r13, %rdi
callq 0x20e0
movq %r12, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x20e0
movq -0x40(%rbp), %rdi
callq 0x2e6e
movq %r14, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
movq -0x38(%rbp), %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/CmdRecord.cpp
// Function: CmdRecord::HexToBit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string CmdRecord::HexToBit(std::string hex_string)
{
	std::string bit_string = "";
	for (int i=0; i < hex_string.length(); ++i)
	{
		switch (hex_string [i])
		{
			case '0': bit_string.append ("0000"); break;
			case '1': bit_string.append ("0001"); break;
			case '2': bit_string.append ("0010"); break;
			case '3': bit_string.append ("0011"); break;
			case '4': bit_string.append ("0100"); break;
			case '5': bit_string.append ("0101"); break;
			case '6': bit_string.append ("0110"); break;
			case '7': bit_string.append ("0111"); break;
			case '8': bit_string.append ("1000"); break;
			case '9': bit_string.append ("1001"); break;
			case 'A': bit_string.append ("1010"); break;
			case 'B': bit_string.append ("1011"); break;
			case 'C': bit_string.append ("1100"); break;
			case 'D': bit_string.append ("1101"); break;
			case 'E': bit_string.append ("1110"); break;
			case 'F': bit_string.append ("1111"); break;
		}
	}
	return bit_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x214e(%rip), %rsi      # 0x5465
leaq -0x29(%rbp), %rdx
callq 0x2c3c
xorl %r15d, %r15d
movl $0x7e03ff, %r12d        # imm = 0x7E03FF
leaq 0x1e1c(%rip), %r13      # 0x514c
cmpq %r15, 0x8(%r14)
jbe 0x3361
movq (%r14), %rax
movb (%rax,%r15), %al
addb $-0x30, %al
cmpb $0x17, %al
jae 0x335c
movzbl %al, %eax
btl %eax, %r12d
jae 0x335c
movslq (%r13,%rax,4), %rsi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x22e0
incq %r15
jmp 0x3330
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/CmdRecord.cpp
// Function: CmdRecord::lookAndAdd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
int CmdRecord::lookAndAdd(std::string bitString, int startRange, int endRange) {
	int result = 0;
	std::string str = bitString.substr(startRange, endRange-startRange);
	int powerCounter = str.length() - 1;
	int indexCounter = 0;
	while(powerCounter != -1){
			if(str[indexCounter] == '0') {
				indexCounter++;
				powerCounter--;			
			}
			else {
				result += exp2(powerCounter);
				indexCounter++;
				powerCounter--;
			}
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movslq %edx, %rdx
subl %edx, %ecx
movslq %ecx, %rcx
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x21b0
movl 0x8(%rbx), %ebx
movl %ebx, %r15d
negl %r15d
decl %ebx
xorl %r12d, %r12d
xorl %r14d, %r14d
movl %r15d, %eax
addl %r12d, %eax
je 0x38f1
movq -0x40(%rbp), %rax
cmpb $0x30, (%rax,%r12)
je 0x38ea
movsd 0x18e3(%rip), %xmm0     # 0x51b8
movl %ebx, %edi
callq 0x2260
cvtsi2sd %r14d, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %r14d
incq %r12
decl %ebx
jmp 0x38ba
leaq -0x40(%rbp), %rdi
callq 0x20e0
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/CmdRecord.cpp
// Function: CmdRecord::operator=(CmdRecord const&)
CmdRecord& CmdRecord::operator=(const CmdRecord &other)
{
	line_number = other.Get_Line_Number();
	address = other.Get_Address();
	data = other.Get_Data();
	size = other.Get_Size();
	cycle = other.Get_Cycle();
	reltime = other.Get_RelTime();
	wordsLength = other.Get_Total_Words();
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x2230
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20e0
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x2230
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20e0
leaq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x2e1a
leaq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x3cfe
movq %r15, %rdi
callq 0x2e6e
leaq 0x58(%r14), %rsi
movq %r15, %rdi
callq 0x2230
leaq 0x58(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20e0
leaq 0x78(%r14), %rsi
movq %r15, %rdi
callq 0x2230
leaq 0x78(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20e0
movl $0x98, %r15d
leaq (%r14,%r15), %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x2230
addq %rbx, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x21e0
movq %r12, %rdi
callq 0x20e0
movl 0xb8(%r14), %eax
movl %eax, 0xb8(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::~CmdList()
CmdList::~CmdList()
{
	CmdNode *temp;
	CmdNode *current = head;

	while(current != NULL)
	{
		temp = current;
		current = current->next;
		delete temp;
	}
	
	head = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x3dac
movq 0xc0(%r14), %r15
movq %r14, %rdi
callq 0x2dd2
movl $0xc8, %esi
movq %r14, %rdi
callq 0x21a0
movq %r15, %r14
jmp 0x3d86
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::AddRecord(CmdRecord)
bool CmdList::AddRecord(CmdRecord record)
{
	// declare and initialize necessary variables
	CmdNode *current = head;
	CmdNode *temp_node;
	bool success = false;

	// initialize new Cmd_Node
	temp_node = new CmdNode;
	temp_node->info = record;
	temp_node->next = NULL;

	// check if list is empty
	if(head == NULL)
	{
		head = temp_node;
		success = true;
	}
	else // otherwise, loop till end and add new node
	{
		while(current->next != NULL)
		{
			current = current->next;
		}
		current->next = temp_node;
		success = true;
	}
	
	return success;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %r12
movl $0xc8, %edi
callq 0x2190
movq %rax, %rbx
movq %rax, %rdi
callq 0x308c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x390a
andq $0x0, 0xc0(%rbx)
cmpq $0x0, (%r14)
je 0x3e15
movq %r12, %r14
movq 0xc0(%r12), %r12
testq %r12, %r12
jne 0x3dfe
addq $0xc0, %r14
movq %rbx, (%r14)
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0xc8, %esi
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::FindRecord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool CmdList::FindRecord(std::string line) const
{
	CmdNode *temp = head;
	bool	found = false;

	while(temp != NULL && !found)
	{
		if(temp->info.Get_Line_Number() == line)
		{
			found = true;
		}
		else
		{
			temp = temp->next;
		}
	}

	return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq -0x40(%rbp), %r15
movq (%r14), %r14
testq %r14, %r14
je 0x3e95
testb $0x1, %r12b
jne 0x3e95
movq %r15, %rdi
movq %r14, %rsi
callq 0x31ee
movq %r15, %rdi
movq %rbx, %rsi
callq 0x43ba
movl %eax, %r12d
movq %r15, %rdi
callq 0x20e0
testb %r12b, %r12b
jne 0x3e5b
addq $0xc0, %r14
jmp 0x3e58
andb $0x1, %r12b
movl %r12d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::RemoveRecord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool CmdList::RemoveRecord(std::string line)
{
	CmdNode *previous;
	CmdNode *current = head;
	bool	success = false;

	// check if list is not empty
	if(current != NULL)
	{
		if(current->next == NULL)
		{
			delete current;
			head = NULL;
			success = true;
		}
		else
		{
			while(current != NULL && !success)
			{	
				if(current->info.Get_Line_Number() == line)
				{
					previous->next = current->next;
					delete current;
					success = true;
				}
				else
				{
					previous = current;
					current = current->next;
				}
			}
		}
	}

	return success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x30(%rbp)
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x3f3e
cmpq $0x0, 0xc0(%rbx)
je 0x3f43
xorl %r15d, %r15d
leaq -0x50(%rbp), %r12
testq %rbx, %rbx
je 0x3f62
testb $0x1, %r15b
jne 0x3f62
movq %r12, %rdi
movq %rbx, %rsi
callq 0x31ee
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x43ba
movl %eax, %r13d
movq %r12, %rdi
callq 0x20e0
movq 0xc0(%rbx), %rax
testb %r13b, %r13b
je 0x3f36
movq %rax, 0xc0(%r14)
movq %rbx, %rdi
callq 0x2dd2
movl $0xc8, %esi
movq %rbx, %rdi
callq 0x21a0
movb $0x1, %r15b
jmp 0x3ed8
movq %rbx, %r14
movq %rax, %rbx
jmp 0x3ed8
xorl %r15d, %r15d
jmp 0x3f62
movq %rdi, %r15
movq %rbx, %rdi
callq 0x2dd2
movl $0xc8, %esi
movq %rbx, %rdi
callq 0x21a0
andq $0x0, (%r15)
movb $0x1, %r15b
andb $0x1, %r15b
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::PrintList() const
void CmdList::PrintList() const
{
	CmdNode *current = head;

	while(current != NULL)
	{
		std::cout << current->info.Get_Line_Number() << ": " << current->info.Get_Address() << "\n";
		current = current->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x68(%rbp), %r14
leaq -0x48(%rbp), %r13
leaq 0x14c9(%rip), %r15      # 0x5464
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x4009
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31ee
movq 0x401b(%rip), %rdi      # 0x7fd0
movq %r14, %rsi
callq 0x2170
movq %rax, %rdi
leaq 0x14c3(%rip), %rsi      # 0x548a
callq 0x2180
movq %rax, %r12
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3214
movq %r12, %rdi
movq %r13, %rsi
callq 0x2170
movq %rax, %rdi
movq %r15, %rsi
callq 0x2180
movq %r13, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x20e0
addq $0xc0, %rbx
jmp 0x3f9b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4028
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
jmp 0x402b
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/andyn[P]libdlmm/./dlmm.hh
// Function: int& Dl::symbol<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
T &symbol(std::string const &symbol_name) const {
        // Convert a void pointer to a function pointer without warnings.
        // Since we're type punning, make sure that pointer sizes do not differ.
        assert(sizeof(void *) == sizeof(void (*)()));
        union {
            void *m_void;
            T *m_real;
        } ptr;

        ptr.m_void = dlsym(m_library, symbol_name.c_str());
        if (ptr.m_void == nullptr)
            throw std::runtime_error(
                std::string("Dl::symbol(\"" + symbol_name + "\"): ") +
                dlerror());

        return *ptr.m_real;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x2130
testq %rax, %rax
je 0x2b62
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20b0
movq %rax, %rbx
leaq 0x7e9(%rip), %rsi       # 0x335d
movq %rsp, %rdi
movq %r14, %rdx
callq 0x2e6b
leaq 0x7a8(%rip), %rdx       # 0x332e
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x2e4c
callq 0x2140
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0x2e4c
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x21c0
xorl %ebp, %ebp
movq 0x242d(%rip), %rsi      # 0x4ff0
movq 0x23fe(%rip), %rdx      # 0x4fc8
movq %rbx, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x2090
jmp 0x2be7
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x2090
jmp 0x2bf9
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x2090
testb %bpl, %bpl
jne 0x2c0b
jmp 0x2c13
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/andyn[P]libdlmm/./dlmm.hh
// Function: int& Dl::symbol<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
T &symbol(std::string const &symbol_name,
              std::string const &version) const {
        // Convert a void pointer to a function pointer without warnings.
        // Since we're type punning, make sure that pointer sizes do not differ.
        assert(sizeof(void *) == sizeof(void (*)()));
        union {
            void *m_void;
            T *m_real;
        } ptr;

        ptr.m_void = dlvsym(m_library, symbol_name.c_str(), version.c_str());
        if (ptr.m_void == nullptr)
            throw std::runtime_error(std::string("Dl::symbol(\"" + symbol_name +
                                                 "\", \"" + version + "\"): ") +
                                     dlerror());

        return *ptr.m_real;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq (%rdi), %rdi
movq (%rsi), %rsi
movq (%rdx), %rdx
callq 0x20c0
testq %rax, %rax
je 0x2d38
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20b0
movq %rax, %rbx
leaq 0x613(%rip), %rsi       # 0x335d
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x2e6b
leaq 0x60c(%rip), %rdx       # 0x336a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2e4c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x2fb6
leaq 0x5a8(%rip), %rdx       # 0x332e
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2e4c
callq 0x2140
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
movq %rax, %rdx
callq 0x2e4c
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x21c0
xorl %ebp, %ebp
movq 0x2225(%rip), %rsi      # 0x4ff0
movq 0x21f6(%rip), %rdx      # 0x4fc8
movq %rbx, %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x2090
jmp 0x2df2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rdi
callq 0x2090
jmp 0x2e04
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x2090
jmp 0x2e16
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x2090
jmp 0x2e28
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x2090
testb %bpl, %bpl
jne 0x2e3c
jmp 0x2e44
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/cmirnov[P]triangular-arbitrage/convert.cpp
// Function: Converter::intToName[abi:cxx11](int)
std::string Converter::intToName(int num) {
	if (num >= currencies.size()) {
		printf("out of range currency number\n");
		return NULL;
	} else {
		return currencies[num];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movslq %edx, %rcx
movq (%rsi), %rsi
movq 0x8(%rax), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rcx, %rax
jbe 0x3f55
shlq $0x5, %rcx
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x2180
jmp 0x3f6f
leaq 0x115e(%rip), %rdi      # 0x50ba
callq 0x21c0
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2050
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cmirnov[P]triangular-arbitrage/convert.cpp
// Function: Converter::nameToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Converter::nameToInt(std::string name) {
	for (int i = 0; i < currencies.size(); ++i) {
		if (currencies[i] == name) {
			return i;
		}
	}
	printf("no such currency in the list\n");
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %rbx, %rax
jbe 0x3fbb
addq %r12, %rdi
movq %r14, %rsi
callq 0x401b
testb %al, %al
jne 0x3fca
incq %rbx
addq $0x20, %r12
jmp 0x3f90
leaq 0x1115(%rip), %rdi      # 0x50d7
callq 0x21c0
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/cmirnov[P]triangular-arbitrage/orderbook.cpp
// Function: Orderbook::update()
void Orderbook::update() { 
	std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> disPrice(0.03, 30.0);
    std::uniform_real_distribution<> disAmount(100.0, 3000.0);
	for (int i = 0; i < 10; ++i) {
		long double amount = disAmount(gen);
		long double price = disPrice(gen);
		table.push_back(new Column(amount, price));	
	}
	sort(table.begin(), table.end(), [](Column *a, Column *b) {return a->price < b->price;});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2768, %rsp           # imm = 0x2768
movq %rdi, %rbx
leaq -0x1400(%rbp), %r14
movq %r14, %rdi
callq 0x46e0
movq %r14, %rdi
callq 0x2190
movl %eax, %esi
leaq -0x2788(%rbp), %rdi
callq 0x4796
movabsq $0x3f9eb851eb851eb8, %rax # imm = 0x3F9EB851EB851EB8
leaq -0x78(%rbp), %rcx
movq %rax, (%rcx)
movabsq $0x403e000000000000, %rax # imm = 0x403E000000000000
movq %rax, 0x8(%rcx)
movabsq $0x4059000000000000, %rax # imm = 0x4059000000000000
leaq -0x68(%rbp), %rcx
movq %rax, (%rcx)
movabsq $0x40a7700000000000, %rax # imm = 0x40A7700000000000
movq %rax, 0x8(%rcx)
pushq $0xa
popq %r15
leaq -0x2788(%rbp), %r12
pushq $0x20
popq %r13
leaq -0x48(%rbp), %r14
subl $0x1, %r15d
jb 0x434d
leaq -0x68(%rbp), %rdi
movq %r12, %rsi
callq 0x4736
movsd %xmm0, -0x40(%rbp)
fldl -0x40(%rbp)
fstpt -0x54(%rbp)
leaq -0x78(%rbp), %rdi
movq %r12, %rsi
callq 0x4736
movsd %xmm0, -0x30(%rbp)
movq %r13, %rdi
callq 0x2150
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
fldl -0x38(%rbp)
fldt -0x54(%rbp)
fstpt (%rax)
fstpt 0x10(%rax)
movq %rax, -0x48(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a82
jmp 0x42f1
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x43b7
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4421
cmpq $0x81, %r15
jl 0x43ac
leaq 0x80(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4649
cmpq %rbx, %r15
je 0x43b7
movq %r15, %rdi
callq 0x46ba
addq $0x8, %r15
jmp 0x4399
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4649
leaq -0x1400(%rbp), %rdi
callq 0x4744
addq $0x2768, %rsp           # imm = 0x2768
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43db
jmp 0x43db
jmp 0x43db
movq %rax, %rbx
leaq -0x1400(%rbp), %rdi
callq 0x4744
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/cmirnov[P]triangular-arbitrage/orderbook.cpp
// Function: Orderbook::get(int)
Column* Orderbook::get(int idx) {
	if (idx >= table.size()) {
		printf("out of range of orderbook\n");
		return NULL;
	}
	return table[idx];
}

// Assembly:
movslq %esi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x440d
movq (%rcx,%rax,8), %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xd20(%rip), %rdi       # 0x5138
callq 0x21c0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/cmirnov[P]triangular-arbitrage/main.cpp
// Function: main
int main() {
	std::string url = "https://www.forex.com/en/";
	std::vector<std::string> currency = {"RUB", "USD", "EUR", "GBD", "JPY", "CNY"};
	Exchange *myExchange = new Exchange(url, currency);
	myExchange->runArbitrage();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
leaq 0x535(%rip), %rsi       # 0x5152
leaq -0x98(%rbp), %rdi
leaq -0x158(%rbp), %rdx
callq 0x2050
leaq 0x535(%rip), %rsi       # 0x516c
leaq -0x158(%rbp), %rbx
leaq -0x27(%rbp), %rdx
movq %rbx, %rdi
callq 0x2050
leaq -0x138(%rbp), %r14
leaq 0x518(%rip), %rsi       # 0x5170
leaq -0x26(%rbp), %rdx
movq %r14, %rdi
callq 0x2050
leaq -0x118(%rbp), %r14
leaq 0x502(%rip), %rsi       # 0x5174
leaq -0x25(%rbp), %rdx
movq %r14, %rdi
callq 0x2050
leaq -0xf8(%rbp), %r14
leaq 0x4ec(%rip), %rsi       # 0x5178
leaq -0x24(%rbp), %rdx
movq %r14, %rdi
callq 0x2050
leaq -0xd8(%rbp), %r14
leaq 0x4d6(%rip), %rsi       # 0x517c
leaq -0x23(%rbp), %rdx
movq %r14, %rdi
callq 0x2050
leaq -0xb8(%rbp), %r14
leaq 0x4c0(%rip), %rsi       # 0x5180
leaq -0x22(%rbp), %rdx
movq %r14, %rdi
callq 0x2050
leaq -0x58(%rbp), %rdi
leaq -0x158(%rbp), %rsi
pushq $0x6
popq %rdx
leaq -0x21(%rbp), %rcx
callq 0x4e22
movl $0xa0, %ebx
leaq (%rbx,%rbp), %rdi
addq $-0x158, %rdi           # imm = 0xFEA8
callq 0x2080
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x4ce8
pushq $0x50
popq %rdi
callq 0x2150
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2180
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2b2e
leaq -0x78(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x23ec
leaq -0x40(%rbp), %rdi
callq 0x2b82
leaq -0x78(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2ab2
leaq -0x58(%rbp), %rdi
callq 0x2b82
leaq -0x98(%rbp), %rdi
callq 0x2080
xorl %eax, %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq -0x40(%rbp), %rdi
callq 0x2b82
jmp 0x4d8c
movq %rax, %r15
leaq -0x78(%rbp), %rdi
callq 0x2080
jmp 0x4d9a
movq %rax, %r15
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x2160
jmp 0x4e04
movq %rax, %r15
movl $0xa0, %r12d
leaq (%r12,%rbp), %rdi
addq $-0x158, %rdi           # imm = 0xFEA8
callq 0x2080
addq $-0x20, %r12
cmpq $-0x20, %r12
jne 0x4db0
movb $0x1, %al
jmp 0x4ddb
jmp 0x4dd6
jmp 0x4dd6
jmp 0x4dd6
jmp 0x4dd6
movq %rax, %r15
xorl %eax, %eax
cmpq %r14, %rbx
sete %cl
testb %al, %al
jne 0x4e0d
testb %cl, %cl
jne 0x4e0d
addq $-0x20, %r14
movq %r14, %rdi
callq 0x2080
cmpq %rbx, %r14
jne 0x4de9
jmp 0x4e0d
movq %rax, %r15
jmp 0x4e0d
movq %rax, %r15
leaq -0x58(%rbp), %rdi
callq 0x2b82
leaq -0x98(%rbp), %rdi
callq 0x2080
movq %r15, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: main
int main (int argc, const char** argv)
{
    if (argc < 2)
    {
        printf ("Error: No file name input.\n");
        return 0;
    }

    Tree code = {};
    TreeConstructor (&code);

    if (GoTree (&code, argv[1]) == 0)
        SaveTree (&code);

    TreeDestructor (&code);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpl $0x1, %edi
jg 0x12aa
leaq 0x312e(%rip), %rdi      # 0x43d1
callq 0x1160
jmp 0x130b
movq %rsi, %rbx
leaq -0x60(%rbp), %r14
andq $0x0, (%r14)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
movl $0xc, 0x30(%r14)
movups %xmm0, 0x38(%r14)
movq %rax, 0x48(%r14)
movq %r14, %rdi
callq 0x2808
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1316
testb %al, %al
jne 0x1302
leaq -0x60(%rbp), %rdi
callq 0x2c78
leaq -0x60(%rbp), %rdi
callq 0x2840
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GoTree(Tree*, char const*)
bool GoTree (Tree* tree, const char* file_path)
{
    assert (tree);
    assert (file_path);
    
    if (LexicalAnalyze (tree, file_path))
        return 1;

    if (LexicalParse (tree))
        return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1349
testq %rsi, %rsi
je 0x1362
movq %rdi, %rbx
callq 0x137f
testb %al, %al
je 0x133b
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1477
leaq 0x2cb4(%rip), %rdi      # 0x4004
leaq 0x2cb2(%rip), %rsi      # 0x4009
leaq 0x2cc1(%rip), %rcx      # 0x401f
pushq $0x19
jmp 0x1379
leaq 0x2cd8(%rip), %rdi      # 0x4041
leaq 0x2c99(%rip), %rsi      # 0x4009
leaq 0x2ca8(%rip), %rcx      # 0x401f
pushq $0x1a
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: LexicalAnalyze(Tree*, char const*)
bool LexicalAnalyze (Tree* tree, const char* file_path)
{
    assert (tree);
    assert (file_path);

    char* code = nullptr;
    if (!ReadTxt (&code, file_path))
        return 1;

    size_t line_now = 1;
    char* code_now = code;
    SkipSpaces (&code_now, &line_now);

    while (*code_now != '\0')
    {
        if (tree->stk.status_error != STK_GOOD)
        {
            printf ("Stack error!\n");
            return 1;
        }

        if (CheckElement (tree, &code_now))
        {
            printf ("Error in line %lu\n", line_now);
            TreeDestructor (tree);
            return 1;
        }

        SkipSpaces (&code_now, &line_now);
    }

    free (code);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x1441
testq %rsi, %rsi
je 0x145a
movq %rdi, %rbx
leaq -0x28(%rbp), %rdi
andq $0x0, (%rdi)
callq 0x2b8d
testq %rax, %rax
je 0x1415
leaq -0x38(%rbp), %r15
movq $0x1, (%r15)
movq -0x28(%rbp), %rax
leaq -0x30(%rbp), %r12
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1598
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
setne %r14b
je 0x141a
cmpl $0x0, 0x30(%rbx)
jne 0x1425
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1602
testb %al, %al
je 0x13cc
movq -0x38(%rbp), %rsi
leaq 0x2c71(%rip), %rdi      # 0x4075
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x2840
jmp 0x1431
movb $0x1, %r14b
jmp 0x1431
movq -0x28(%rbp), %rdi
callq 0x1110
jmp 0x1431
leaq 0x2fc0(%rip), %rdi      # 0x43ec
callq 0x1160
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bbc(%rip), %rdi      # 0x4004
leaq 0x2bba(%rip), %rsi      # 0x4009
leaq 0x2bf5(%rip), %rcx      # 0x404b
pushq $0x27
jmp 0x1471
leaq 0x2be0(%rip), %rdi      # 0x4041
leaq 0x2ba1(%rip), %rsi      # 0x4009
leaq 0x2bdc(%rip), %rcx      # 0x404b
pushq $0x28
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: LexicalParse(Tree*)
bool LexicalParse (Tree* tree)
{
    assert (tree);

    element* el_now  = tree->stk.buffer;
    const char dec_str[] = "DICK";
    char* fix_constructor = (char*) dec_str;

    ElementConstructor (tree, DEC, (char**) &fix_constructor, 4);
    fix_constructor -= 4;

    element* dec_now = tree->stk.buffer + tree->stk.size - 1;
    tree->head = dec_now;

    // ToDo: Think about going out of bounds.

    do
    {
        ElementConstructor (tree, DEC, &fix_constructor, 4);
        fix_constructor -= 4;

        dec_now->right = tree->stk.buffer + tree->stk.size - 1;
        dec_now = dec_now->right;

        dec_now->left = GetFunc (&el_now);
        if (dec_now->left == PARSE_ERR)
        {
            TreeDestructor (tree);
            return 1;
        }
    }
    while (el_now->type != DEC && tree->stk.size < tree->stk.capacity);
    
    tree->head = tree->head->right;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x157b
movq 0x10(%rdi), %rax
leaq -0x40(%rbp), %rcx
movq %rax, (%rcx)
leaq -0x48(%rbp), %rax
movb $0x0, 0x4(%rax)
movl $0x4b434944, (%rax)     # imm = 0x4B434944
leaq -0x38(%rbp), %rbx
movq %rax, (%rbx)
pushq $0x1
popq %rsi
pushq $0x4
popq %rcx
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rbx, %rdx
callq 0x287f
movq -0x30(%rbp), %rdx
addq $-0x4, (%rbx)
movq 0x10(%rdx), %rax
imulq $0x30, 0x18(%rdx), %rcx
leaq (%rax,%rcx), %r15
addq %rcx, %rax
addq $-0x30, %rax
movq %rax, (%rdx)
movq %rdx, %rbx
movq %rdx, %rdi
pushq $0x1
popq %rsi
leaq -0x38(%rbp), %rdx
pushq $0x4
popq %rcx
callq 0x287f
addq $-0x4, -0x38(%rbp)
movq 0x10(%rbx), %r12
imulq $0x30, 0x18(%rbx), %rbx
leaq (%r12,%rbx), %r13
addq $-0x30, %r13
movq %r13, -0x20(%r15)
leaq -0x40(%rbp), %rdi
callq 0x16b7
movq %rax, %r14
movq %rax, 0x8(%r13)
leaq 0x5c34(%rip), %rax      # 0x7160
movq (%rax), %r13
cmpq %r13, %r14
je 0x155d
movq -0x40(%rbp), %rax
cmpl $0x1, (%rax)
movq -0x30(%rbp), %rdx
je 0x1551
addq %rbx, %r12
movq 0x18(%rdx), %rax
movq %r12, %r15
cmpq 0x20(%rdx), %rax
jb 0x14e6
movq (%rdx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rdx)
jmp 0x1566
movq -0x30(%rbp), %rdi
callq 0x2840
cmpq %r13, %r14
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a82(%rip), %rdi      # 0x4004
leaq 0x2a80(%rip), %rsi      # 0x4009
leaq 0x2af8(%rip), %rcx      # 0x4088
pushq $0x4a
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: SkipSpaces(char**, unsigned long*)
void  SkipSpaces (char** code, size_t* line_now)
{
    assert (code);
    assert (*code);

    while (**code == ' ' || **code == '\t' || **code == '\r' || **code == '\n')
    {
        if (**code == '\n')
            *line_now += 1;
        *code += 1;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x15e5
movq (%rdi), %rax
testq %rax, %rax
jne 0x15c8
leaq 0x2b1a(%rip), %rdi      # 0x40ca
leaq 0x2a52(%rip), %rsi      # 0x4009
leaq 0x2ae9(%rip), %rcx      # 0x40a7
pushq $0x70
jmp 0x15fc
incq (%rsi)
movq %rax, (%rdi)
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x9, %ecx
je 0x15c5
cmpl $0x20, %ecx
je 0x15c5
cmpl $0xd, %ecx
je 0x15c5
cmpl $0xa, %ecx
je 0x15c2
popq %rbp
retq
leaq 0x2adf(%rip), %rdi      # 0x40cb
leaq 0x2a16(%rip), %rsi      # 0x4009
leaq 0x2aad(%rip), %rcx      # 0x40a7
pushq $0x6f
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckElement(Tree*, char**)
bool CheckElement (Tree* tree, char** code)
{
    anal_ass;

    int lex_check = 0;

    #define TryCheck(func) lex_check = func (tree, code); \
                           if (lex_check)                 \
                              return lex_check - 1;

    TryCheck (CheckLR);
    TryCheck (CheckBody);
    TryCheck (CheckParam);
    TryCheck (CheckArith);
    TryCheck (CheckInd);
    TryCheck (CheckNum);

    #undef TryCheck
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1688
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1691
cmpq $0x0, (%rbx)
je 0x169a
movq %rdi, %r14
movq %rbx, %rsi
callq 0x179a
testl %eax, %eax
jne 0x1658
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17fb
testl %eax, %eax
jne 0x1658
movq %r14, %rdi
movq %rbx, %rsi
callq 0x187b
testl %eax, %eax
jne 0x1658
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18f9
testl %eax, %eax
je 0x165f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1999
testl %eax, %eax
je 0x1676
cmpl $0x1, %eax
setne %al
jmp 0x165a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a4b
testl %eax, %eax
sete %al
jmp 0x165a
leaq 0x2975(%rip), %rdi      # 0x4004
jmp 0x16a1
leaq 0x2a33(%rip), %rdi      # 0x40cb
jmp 0x16a1
leaq 0x2a29(%rip), %rdi      # 0x40ca
leaq 0x2961(%rip), %rsi      # 0x4009
leaq 0x2a21(%rip), %rcx      # 0x40d0
pushq $0x7e
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetFunc(element**)
element* GetFunc      (element** el_now)
{
    parse_ass;

    require_ind;

    element* el_result = *el_now;
    next;

    el_result->left = GetFuncParam (el_now);
    check_parse (el_result->left);

    el_result->right = GetBody (el_now);
    check_parse (el_result->right);

    el_result->type = FUNC;
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1772
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x177b
cmpl $0x9, (%r14)
jne 0x172e
cmpq $0x0, 0x18(%r14)
je 0x172e
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x1b24
movq %rax, %rcx
movq %rax, 0x8(%r14)
leaq 0x5a5d(%rip), %r15      # 0x7160
movq (%r15), %rax
cmpq %rax, %rcx
je 0x1767
movq %rbx, %rdi
callq 0x1c3f
movq %rax, %rcx
movq %rax, 0x10(%r14)
movq (%r15), %rax
cmpq %rax, %rcx
je 0x1767
movl $0x2, (%r14)
movq %r14, %rax
jmp 0x1767
leaq 0x2adf(%rip), %rdi      # 0x4214
leaq 0x2ab3(%rip), %rsi      # 0x41ef
movl $0x118, %edx            # imm = 0x118
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2ae5(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x59fc(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a94(%rip), %rdi      # 0x420d
jmp 0x1782
leaq 0x2a8a(%rip), %rdi      # 0x420c
leaq 0x2880(%rip), %rsi      # 0x4009
leaq 0x2a5f(%rip), %rcx      # 0x41ef
movl $0x116, %edx            # imm = 0x116
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckLR(Tree*, char**)
LexResult CheckLR    (Tree* tree, char** code)
{
    anal_ass;

    if (**code == '$')
    {
        ElementConstructor (tree, LR, code, 1);
        return SUCCESS;
    }
    
    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x17ca
movq %rsi, %rdx
testq %rsi, %rsi
je 0x17d3
movq (%rdx), %rcx
testq %rcx, %rcx
je 0x17dc
xorl %eax, %eax
cmpb $0x24, (%rcx)
jne 0x17c8
pushq $0x3
popq %rsi
pushq $0x1
popq %rcx
callq 0x287f
pushq $0x1
popq %rax
popq %rbp
retq
leaq 0x2833(%rip), %rdi      # 0x4004
jmp 0x17e3
leaq 0x28f1(%rip), %rdi      # 0x40cb
jmp 0x17e3
leaq 0x28e7(%rip), %rdi      # 0x40ca
leaq 0x281f(%rip), %rsi      # 0x4009
leaq 0x291c(%rip), %rcx      # 0x410d
movl $0x9b, %edx
callq 0x1090