LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x10038, %rsp          # imm = 0x10038
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x80, %esi
movl $0x1, %edx
movl $0x20, %ecx
callq 0x1464
leaq 0x5af4(%rip), %rax      # 0x6d60
movq %rax, (%r14)
movq $0x0, 0x20(%r14)
movl $0x1, %edi
callq 0x1110
testl %eax, %eax
je 0x12ba
movq 0x5d54(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x3d6b(%rip), %rsi      # 0x5004
xorl %eax, %eax
callq 0x10f0
leaq 0x8(%rsp), %rdi
callq 0x1494
movl $0x1, %eax
addq $0x10038, %rsp          # imm = 0x10038
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rbx
leaq 0x30(%rsp), %r14
movl $0x10000, %edx          # imm = 0x10000
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1324
movl $0x10000, %edx          # imm = 0x10000
movl $0x1, %edi
movq %r14, %rsi
callq 0x1040
cmpq $0x10000, %rax          # imm = 0x10000
je 0x12c4
leaq 0x3d41(%rip), %rdi      # 0x5036
leaq 0x3d4d(%rip), %rsi      # 0x5049
leaq 0x3d55(%rip), %rcx      # 0x5058
movl $0x1c, %edx
callq 0x1080
jmp 0x130f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1494
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1377
movl %r12d, %eax
cmpq %rbx, %rax
jb 0x1386
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 0x133e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14a8
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2190
movq (%r14), %rdi
callq 0x21f0
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rbx), %rdx
addq $-0x2, %rdx
leaq -0x38(%rbp), %rdi
movl $0x2, %ecx
movq %rbx, %rsi
callq 0x2190
xorps %xmm0, %xmm0
cvtsd2ss -0x18(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
leaq 0x3108(%rip), %rsi      # 0x60c7
leaq -0x38(%rbp), %rdi
callq 0x2060
testl %eax, %eax
je 0x2fe6
leaq 0x30f7(%rip), %rsi      # 0x60ca
leaq -0x38(%rbp), %rdi
callq 0x2060
movsd 0x305c(%rip), %xmm1     # 0x6040
jmp 0x2fee
movsd 0x304a(%rip), %xmm1     # 0x6038
xorps %xmm0, %xmm0
cvtss2sd -0x18(%rbp), %xmm0
callq 0x22a0
movsd %xmm0, -0x18(%rbp)
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3019
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2170
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3032
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2170
xorps %xmm0, %xmm0
cvtsd2ss -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x305f
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x60(%rbp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, -0x58(%rbp)
leaq 0x68(%rdi), %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x78(%rdi), %r12
leaq 0x88(%rdi), %r14
movq %r14, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb %al, 0x88(%rdi)
leaq 0x98(%rdi), %r13
leaq 0xa8(%rdi), %r15
movq %r15, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
movb %al, 0xa8(%rdi)
leaq 0x2d5b(%rip), %rcx      # 0x6465
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2260
movq 0x28(%rbx), %rdx
leaq 0x2d44(%rip), %rcx      # 0x6465
movq -0x60(%rbp), %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2260
leaq -0x78(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movl $0x64, %esi
callq 0x4558
leaq -0x78(%rbp), %rdi
callq 0x33c2
movq 0x60(%rbx), %rdx
leaq 0x2d10(%rip), %rcx      # 0x6465
movq -0x58(%rbp), %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2260
movq 0x80(%rbx), %rdx
leaq 0x2cf4(%rip), %rcx      # 0x6465
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2260
movq 0xa0(%rbx), %rdx
leaq 0x2cd9(%rip), %rcx      # 0x6465
movq %r13, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2260
movl $0x0, 0xb8(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37b4
movq %rax, -0x38(%rbp)
movq (%r13), %rdi
cmpq %r15, %rdi
je 0x37cc
movq (%r15), %rsi
incq %rsi
callq 0x2170
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x37e0
movq (%r14), %rsi
incq %rsi
callq 0x2170
leaq 0x40(%rbx), %r12
movq -0x58(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0x3800
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2170
movq %r12, %rdi
callq 0x33c2
movq -0x60(%rbp), %rax
movq (%rax), %rdi
cmpq -0x48(%rbp), %rdi
je 0x3824
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2170
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0x383c
movq -0x50(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2170
movq -0x38(%rbp), %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x2a81(%rip), %rdx      # 0x6465
movq %rdx, %rsi
callq 0x35be
cmpq $0x0, 0x8(%r14)
je 0x3a31
xorl %r12d, %r12d
movl $0x7e03ff, %r13d        # imm = 0x7E03FF
leaq 0x2749(%rip), %r15      # 0x614c
movq (%r14), %rax
movb (%rax,%r12), %al
addb $-0x30, %al
cmpb $0x17, %al
jae 0x3a28
movzbl %al, %eax
btl %eax, %r13d
jae 0x3a28
movslq (%r15,%rax,4), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x22e0
incq %r12
cmpq %r12, 0x8(%r14)
ja 0x3a03
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
cmpq -0x30(%rbp), %rdi
je 0x3a5e
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2170
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x28, %rsp
movslq %edx, %rdx
subl %edx, %ecx
movslq %ecx, %rcx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x2190
movl 0x8(%rbx), %r14d
testl %r14d, %r14d
je 0x4377
decl %r14d
xorl %r15d, %r15d
xorl %ebx, %ebx
movq -0x38(%rbp), %rax
cmpb $0x30, (%rax,%r15)
je 0x436c
movsd 0x1e63(%rip), %xmm0     # 0x61b8
movl %r14d, %edi
callq 0x2240
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %ebx
incq %r15
addl $-0x1, %r14d
jb 0x4342
jmp 0x4379
xorl %ebx, %ebx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4392
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2170
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x3520
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x43f4
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq %r13, (%r15)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3520
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x442a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
leaq 0x40(%r14), %rsi
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x332e
movups 0x40(%rbx), %xmm0
movq 0x50(%rbx), %rax
movq (%r15), %rcx
movq %rcx, 0x40(%rbx)
movq 0x8(%r15), %rcx
movq %rcx, 0x48(%rbx)
movq 0x10(%r15), %rcx
movq %rcx, 0x50(%rbx)
leaq -0x48(%rbp), %r12
movups %xmm0, (%r12)
movq %rax, 0x10(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq %r12, %rdi
callq 0x33c2
movq %r15, %rdi
callq 0x33c2
movq %r13, (%r12)
movq 0x58(%r14), %rsi
movq 0x60(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x3520
leaq 0x58(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x44c1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq %r13, (%r15)
movq 0x78(%r14), %rsi
movq 0x80(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3520
leaq 0x78(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x44fa
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq %r13, (%r15)
movq 0x98(%r14), %rsi
movq 0xa0(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3520
leaq 0x98(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4539
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movl 0xb8(%r14), %eax
movl %eax, 0xb8(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x487f
movq 0xc0(%r14), %r15
movq %r14, %rdi
callq 0x328e
movl $0xc8, %esi
movq %r14, %rdi
callq 0x2170
movq %r15, %r14
testq %r15, %r15
jne 0x485b
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2160
movq %rax, %rbx
movq %rax, %rdi
callq 0x365c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43a0
movq $0x0, 0xc0(%rbx)
cmpq $0x0, (%r14)
je 0x48ee
movq %r12, %r14
movq 0xc0(%r12), %r12
testq %r12, %r12
jne 0x48d7
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 0x2170
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r14
testq %r14, %r14
je 0x49a4
movq %rsi, %rbx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3850
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4965
movq -0x48(%rbp), %r13
testq %rdx, %rdx
je 0x496e
movq (%rbx), %rsi
movq %r13, %rdi
callq 0x2180
testl %eax, %eax
sete %r12b
jmp 0x4971
movq -0x48(%rbp), %r13
xorl %r12d, %r12d
jmp 0x4971
movb $0x1, %r12b
leaq -0x38(%rbp), %rax
cmpq %rax, %r13
je 0x4989
movq -0x38(%rbp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x2170
testb %r12b, %r12b
jne 0x49a7
movq 0xc0(%r14), %r14
testq %r14, %r14
sete %al
orb %r12b, %al
testb $0x1, %al
je 0x4934
jmp 0x49a7
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rdi), %r13
testq %r13, %r13
je 0x4a4f
cmpq $0x0, 0xc0(%r13)
je 0x4a54
movq %rsi, %rbx
movq %r13, %r15
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x3850
movq -0x40(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4a15
movq -0x48(%rbp), %r13
testq %rdx, %rdx
je 0x4a1e
movq (%rbx), %rsi
movq %r13, %rdi
callq 0x2180
testl %eax, %eax
sete %r12b
jmp 0x4a21
movq -0x48(%rbp), %r13
xorl %r12d, %r12d
jmp 0x4a21
movb $0x1, %r12b
leaq -0x38(%rbp), %rax
cmpq %rax, %r13
je 0x4a39
movq -0x38(%rbp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x2170
movq 0xc0(%r15), %r13
testb %r12b, %r12b
jne 0x4a78
movq %r15, %r14
testq %r13, %r13
jne 0x49e0
jmp 0x4a94
xorl %r12d, %r12d
jmp 0x4a94
movq %rdi, %r14
movq %r13, %rdi
callq 0x328e
movl $0xc8, %esi
movq %r13, %rdi
callq 0x2170
movq $0x0, (%r14)
movb $0x1, %r12b
jmp 0x4a94
movq %r13, 0xc0(%r14)
movq %r15, %rdi
callq 0x328e
movl $0xc8, %esi
movq %r15, %rdi
callq 0x2170
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
testq %rbx, %rbx
je 0x4b75
leaq 0x19c0(%rip), %r12      # 0x648a
leaq -0x48(%rbp), %r13
leaq 0x198f(%rip), %r14      # 0x6464
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x3850
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x44e0(%rip), %rdi      # 0x8fd0
callq 0x21c0
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21c0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x388a
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x21c0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4b4c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4b65
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2170
movq 0xc0(%rbx), %rbx
testq %rbx, %rbx
jne 0x4ad5
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4b86
movq %rax, %rbx
jmp 0x4ba7
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4ba7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4bc0
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x2130
testq %rax, %rax
je 0x2fd2
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x1377(%rip), %rsi      # 0x435d
movq %rsp, %rdi
movq %r14, %rdx
callq 0x3586
leaq 0x1336(%rip), %rsi      # 0x432e
movq %rsp, %rdi
callq 0x2240
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3021
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x302e
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x2140
movq %r14, %rdi
movq %rax, %rsi
callq 0x2240
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x307d
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x308a
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x21e0
xorl %ebp, %ebp
movq 0x2f36(%rip), %rsi      # 0x5ff0
movq 0x2eff(%rip), %rdx      # 0x5fc0
movq %rbx, %rdi
callq 0x2200
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x30eb
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x30eb
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x3102
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2160
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x311d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
testb %bpl, %bpl
jne 0x3147
jmp 0x314f
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3147
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x3147
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
movslq %edx, %rax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
leaq 0x10(%rdi), %r14
cmpq %rax, %rdx
jbe 0x41d7
shlq $0x5, %rax
movq %r14, (%rbx)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x32e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1f06(%rip), %rdi      # 0x60e4
callq 0x21b0
movq %r14, (%rbx)
leaq 0x1e4b(%rip), %rdi      # 0x6038
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r12
movq 0x8(%rdi), %r13
subq %r12, %r13
je 0x4251
movq %rsi, %rbx
sarq $0x5, %r13
movq 0x8(%rsi), %r15
cmpq $0x1, %r13
adcq $0x0, %r13
addq $0x8, %r12
xorl %r14d, %r14d
cmpq %r15, (%r12)
jne 0x4245
testq %r15, %r15
je 0x4263
movq (%rbx), %rsi
movq -0x8(%r12), %rdi
movq %r15, %rdx
callq 0x2160
testl %eax, %eax
je 0x4263
incq %r14
addq $0x20, %r12
cmpq %r14, %r13
jne 0x4226
leaq 0x1ea9(%rip), %rdi      # 0x6101
callq 0x21b0
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x2740, %rsp           # imm = 0x2740
movq %rdi, %rbx
leaq -0x2760(%rbp), %r14
movq %r14, %rdi
callq 0x4a5c
movq %r14, %rdi
callq 0x2180
movl %eax, %eax
movq %rax, -0x13d8(%rbp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, -0x13d8(%rbp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x457e
leaq -0x13d8(%rbp), %r14
movq $0x270, 0x1380(%r14) # imm = 0x270
movl $0xa, %r12d
leaq -0x40(%rbp), %r15
movq %r14, %rdi
callq 0x4b78
mulsd 0x1b51(%rip), %xmm0     # 0x6120
addsd 0x1b51(%rip), %xmm0     # 0x6128
movsd %xmm0, -0x38(%rbp)
fldl -0x38(%rbp)
fstpt -0x4c(%rbp)
movq %r14, %rdi
callq 0x4b78
movsd %xmm0, -0x28(%rbp)
movl $0x20, %edi
callq 0x2140
movsd -0x28(%rbp), %xmm0
mulsd 0x1b2a(%rip), %xmm0     # 0x6130
addsd 0x1b2a(%rip), %xmm0     # 0x6138
movsd %xmm0, -0x30(%rbp)
fldl -0x30(%rbp)
fldt -0x4c(%rbp)
fstpt (%rax)
fstpt 0x10(%rax)
movq %rax, -0x40(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4636
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4641
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4de4
decl %r12d
jne 0x45bf
movq (%rbx), %r15
movq 0x8(%rbx), %rbx
cmpq %rbx, %r15
je 0x46de
movq %rbx, %r14
subq %r15, %r14
movq %r14, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4751
cmpq $0x81, %r14
jl 0x46d3
leaq 0x80(%r15), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x49c5
cmpq %rbx, %r14
je 0x46de
movq -0x8(%r14), %rcx
movq (%r14), %rax
fldt 0x10(%rax)
fldt 0x10(%rcx)
fucompi %st(1), %st
movq %r14, %rdx
jbe 0x46c8
movq %r14, %rdx
movq %rcx, (%rdx)
movq -0x10(%rdx), %rcx
fldt 0x10(%rcx)
addq $-0x8, %rdx
fucompi %st(1), %st
ja 0x46b6
fstp %st(0)
movq %rax, (%rdx)
addq $0x8, %r14
jmp 0x469a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49c5
leaq -0x2760(%rbp), %rdi
callq 0x2120
addq $0x2740, %rsp           # imm = 0x2740
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4719
jmp 0x4702
jmp 0x4702
jmp 0x4702
movq %rax, %rbx
leaq -0x2760(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x32d1
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x473d
movq (%rcx,%rax,8), %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1a40(%rip), %rdi      # 0x6188
callq 0x21b0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x130e
movq %rsi, %rbx
leaq -0x60(%rbp), %r14
movq $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 0x2870
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1319
testb %al, %al
jne 0x1305
leaq -0x60(%rbp), %rdi
callq 0x2d1b
leaq -0x60(%rbp), %rdi
callq 0x28ad
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x145a
testq %rsi, %rsi
je 0x1479
movq %rdi, %rbx
leaq -0x30(%rbp), %rdi
movq $0x0, (%rdi)
callq 0x2c2c
testq %rax, %rax
je 0x144d
leaq -0x28(%rbp), %rsi
movq $0x1, (%rsi)
movq -0x30(%rbp), %rax
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movq %r14, %rdi
callq 0x15d1
movq (%r14), %rax
cmpb $0x0, (%rax)
je 0x1418
leaq -0x28(%rbp), %r15
cmpl $0x0, 0x30(%rbx)
jne 0x1425
movq %rbx, %rdi
movq %r14, %rsi
callq 0x164c
testb %al, %al
jne 0x1433
movq %r14, %rdi
movq %r15, %rsi
callq 0x15d1
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x13ef
movq -0x30(%rbp), %rdi
callq 0x1110
xorl %eax, %eax
jmp 0x144f
leaq 0x2fc0(%rip), %rdi      # 0x43ec
callq 0x1160
jmp 0x144d
movq -0x28(%rbp), %rsi
leaq 0x2c37(%rip), %rdi      # 0x4075
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x28ad
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ba3(%rip), %rdi      # 0x4004
leaq 0x2ba1(%rip), %rsi      # 0x4009
leaq 0x2bdc(%rip), %rcx      # 0x404b
movl $0x27, %edx
callq 0x1090
leaq 0x2bc1(%rip), %rdi      # 0x4041
leaq 0x2b82(%rip), %rsi      # 0x4009
leaq 0x2bbd(%rip), %rcx      # 0x404b
movl $0x28, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15b2
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)
movl $0x4, %ecx
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x28f1
movq -0x30(%rbp), %rdx
addq $-0x4, (%rbx)
movq 0x10(%rdx), %rax
movq 0x18(%rdx), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %r13
addq %rcx, %rax
addq $-0x30, %rax
movq %rax, (%rdx)
movl $0x4, %ecx
movq %rdx, %rbx
movq %rdx, %rdi
movl $0x1, %esi
leaq -0x38(%rbp), %rdx
callq 0x28f1
addq $-0x4, -0x38(%rbp)
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %rax
leaq (%rax,%rax,2), %rbx
shlq $0x4, %rbx
leaq (%r15,%rbx), %r14
addq $-0x30, %r14
movq %r14, -0x20(%r13)
leaq -0x40(%rbp), %rdi
callq 0x1703
movq %rax, %r12
movq %rax, 0x8(%r14)
leaq 0x5bfd(%rip), %rax      # 0x7160
movq (%rax), %r14
cmpq %r14, %r12
je 0x1594
movq -0x40(%rbp), %rax
cmpl $0x1, (%rax)
movq -0x30(%rbp), %rdx
je 0x1588
addq %rbx, %r15
movq 0x18(%rdx), %rax
movq %r15, %r13
cmpq 0x20(%rdx), %rax
jb 0x1512
movq (%rdx), %rax
movq 0x10(%rax), %rax
movq %rax, (%rdx)
jmp 0x159d
movq -0x30(%rbp), %rdi
callq 0x28ad
cmpq %r14, %r12
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a4b(%rip), %rdi      # 0x4004
leaq 0x2a49(%rip), %rsi      # 0x4009
leaq 0x2ac1(%rip), %rcx      # 0x4088
movl $0x4a, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x160e
movq (%rdi), %rax
testq %rax, %rax
je 0x162d
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0xc, %ecx
jg 0x15fd
cmpl $0x9, %ecx
je 0x1607
cmpl $0xa, %ecx
jne 0x160c
incq (%rsi)
jmp 0x1607
cmpl $0xd, %ecx
je 0x1607
cmpl $0x20, %ecx
jne 0x160c
movq %rax, (%rdi)
jmp 0x15e2
popq %rbp
retq
leaq 0x2ab6(%rip), %rdi      # 0x40cb
leaq 0x29ed(%rip), %rsi      # 0x4009
leaq 0x2a84(%rip), %rcx      # 0x40a7
movl $0x6f, %edx
callq 0x1090
leaq 0x2a96(%rip), %rdi      # 0x40ca
leaq 0x29ce(%rip), %rsi      # 0x4009
leaq 0x2a65(%rip), %rcx      # 0x40a7
movl $0x70, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16d2
movq %rsi, %rbx
testq %rsi, %rsi
je 0x16db
cmpq $0x0, (%rbx)
je 0x16e4
movq %rdi, %r14
movq %rbx, %rsi
callq 0x17e6
testl %eax, %eax
jne 0x16a2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x184d
testl %eax, %eax
jne 0x16a2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18d5
testl %eax, %eax
jne 0x16a2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x195b
testl %eax, %eax
je 0x16a9
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a04
testl %eax, %eax
je 0x16c0
cmpl $0x1, %eax
setne %al
jmp 0x16a4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1aa3
testl %eax, %eax
sete %al
jmp 0x16a4
leaq 0x292b(%rip), %rdi      # 0x4004
jmp 0x16eb
leaq 0x29e9(%rip), %rdi      # 0x40cb
jmp 0x16eb
leaq 0x29df(%rip), %rdi      # 0x40ca
leaq 0x2917(%rip), %rsi      # 0x4009
leaq 0x29d7(%rip), %rcx      # 0x40d0
movl $0x7e, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17be
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x17c7
cmpl $0x9, (%r14)
jne 0x177a
cmpq $0x0, 0x18(%r14)
je 0x177a
leaq 0x30(%r14), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x1b84
movq %rax, %rcx
movq %rax, 0x8(%r14)
leaq 0x5a11(%rip), %r15      # 0x7160
movq (%r15), %rax
cmpq %rax, %rcx
je 0x17b3
movq %rbx, %rdi
callq 0x1c9f
movq %rax, %rcx
movq %rax, 0x10(%r14)
movq (%r15), %rax
cmpq %rax, %rcx
je 0x17b3
movl $0x2, (%r14)
movq %r14, %rax
jmp 0x17b3
leaq 0x2a93(%rip), %rdi      # 0x4214
leaq 0x2a67(%rip), %rsi      # 0x41ef
movl $0x118, %edx            # imm = 0x118
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x2a99(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x59b0(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a48(%rip), %rdi      # 0x420d
jmp 0x17ce
leaq 0x2a3e(%rip), %rdi      # 0x420c
leaq 0x2834(%rip), %rsi      # 0x4009
leaq 0x2a13(%rip), %rcx      # 0x41ef
movl $0x116, %edx            # imm = 0x116
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x181c
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1825
movq (%rdx), %rcx
testq %rcx, %rcx
je 0x182e
xorl %eax, %eax
cmpb $0x24, (%rcx)
jne 0x181a
movl $0x1, %ecx
movl $0x3, %esi
callq 0x28f1
movl $0x1, %eax
popq %rbp
retq
leaq 0x27e1(%rip), %rdi      # 0x4004
jmp 0x1835
leaq 0x289f(%rip), %rdi      # 0x40cb
jmp 0x1835
leaq 0x2895(%rip), %rdi      # 0x40ca
leaq 0x27cd(%rip), %rsi      # 0x4009
leaq 0x28ca(%rip), %rcx      # 0x410d
movl $0x9b, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckBody(Tree*, char**)
LexResult CheckBody  (Tree* tree, char** code)
{
    anal_ass;

    if (strncmp ("AAAAH", *code, 5) == 0)
    {
        ElementConstructor (tree, BODY, code, 5);
        return SUCCESS;
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18a4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x18ad
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x18b6
movq %rdi, %r14
leaq 0x28e2(%rip), %rdi      # 0x4155
movl $0x5, %edx
callq 0x1070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x189f
movl $0x5, %ecx
movq %r14, %rdi
movl $0x5, %esi
movq %rbx, %rdx
callq 0x28f1
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2759(%rip), %rdi      # 0x4004
jmp 0x18bd
leaq 0x2817(%rip), %rdi      # 0x40cb
jmp 0x18bd
leaq 0x280d(%rip), %rdi      # 0x40ca
leaq 0x2745(%rip), %rsi      # 0x4009
leaq 0x2865(%rip), %rcx      # 0x4130
movl $0xa8, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckParam(Tree*, char**)
LexResult CheckParam (Tree* tree, char** code)
{
    anal_ass;

    if (strncmp ("ass", *code, 3) == 0)
    {
        ElementConstructor (tree, PARAM, code, 3);
        return SUCCESS;
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x192a
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1933
movq (%rdx), %rax
testq %rax, %rax
je 0x193c
movzbl (%rax), %ecx
subl $0x61, %ecx
jne 0x190c
movzbl 0x1(%rax), %ecx
subl $0x73, %ecx
jne 0x190c
movzbl 0x2(%rax), %eax
movl $0x73, %ecx
subl %eax, %ecx
jmp 0x190e
negl %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x1928
movl $0x3, %ecx
movl $0x4, %esi
callq 0x28f1
movl $0x1, %eax
popq %rbp
retq
leaq 0x26d3(%rip), %rdi      # 0x4004
jmp 0x1943
leaq 0x2791(%rip), %rdi      # 0x40cb
jmp 0x1943
leaq 0x2787(%rip), %rdi      # 0x40ca
leaq 0x26bf(%rip), %rsi      # 0x4009
leaq 0x280a(%rip), %rcx      # 0x415b
movl $0xb5, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckArith(Tree*, char**)
LexResult CheckArith (Tree* tree, char** code)
{
    anal_ass;

    switch (**code)
    {
        case '+':
        case '-':
        case '*':
        case '/':
        case '^':
        case '(':
        case ')':
            ElementConstructor (tree, ARITH, code, 1);
            return SUCCESS;

        case '=':
        case '>':
        case '<':
        {
            size_t strong = 1;
            if (*(*code + 1) == '=')
                strong = 2;
            ElementConstructor (tree, ARITH, code, strong);
            return SUCCESS;
        }
        case '!':
            if (*(*code + 1) == '=')
            {
                ElementConstructor (tree, ARITH, code, 2);
                return SUCCESS;
            }
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x19d3
movq %rsi, %rdx
testq %rsi, %rsi
je 0x19dc
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x19e5
movzbl (%rsi), %r8d
xorl %eax, %eax
addl $-0x21, %r8d
cmpl $0x3d, %r8d
ja 0x19bf
movl $0x1, %ecx
movabsq $0x2000000000005780, %r9 # imm = 0x2000000000005780
btq %r8, %r9
jb 0x19b0
movl $0x38000000, %ecx       # imm = 0x38000000
btq %r8, %rcx
jae 0x19c1
xorl %ecx, %ecx
cmpb $0x3d, 0x1(%rsi)
sete %cl
incq %rcx
movl $0x6, %esi
callq 0x28f1
movl $0x1, %eax
popq %rbp
retq
testq %r8, %r8
jne 0x19bf
movl $0x2, %ecx
cmpb $0x3d, 0x1(%rsi)
je 0x19b0
jmp 0x19bf
leaq 0x262a(%rip), %rdi      # 0x4004
jmp 0x19ec
leaq 0x26e8(%rip), %rdi      # 0x40cb
jmp 0x19ec
leaq 0x26de(%rip), %rdi      # 0x40ca
leaq 0x2616(%rip), %rsi      # 0x4009
leaq 0x2787(%rip), %rcx      # 0x4181
movl $0xc2, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckInd(Tree*, char**)
LexResult CheckInd   (Tree* tree, char** code)
{
    anal_ass;

    if (IsMale (*code))
    {
        size_t len = 3;

        while ((*code)[len] != '\0' && !IsMale (*code + len))
            len++;

        if ((*code)[len] == '\0')
            return ERROR;

        len += 3;
        ElementConstructor (tree, IND, code, len);
        return SUCCESS;
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1a72
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1a7b
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x1a84
xorl %eax, %eax
cmpb $-0x1e, (%rsi)
jne 0x1a70
cmpb $-0x67, 0x1(%rsi)
jne 0x1a70
cmpb $-0x7e, 0x2(%rsi)
jne 0x1a70
movl $0x6, %ecx
movzbl -0x3(%rsi,%rcx), %eax
cmpl $0xe2, %eax
je 0x1a47
testl %eax, %eax
jne 0x1a55
jmp 0x1a5a
cmpb $-0x67, -0x2(%rsi,%rcx)
jne 0x1a55
cmpb $-0x7e, -0x1(%rsi,%rcx)
je 0x1a61
incq %rcx
jmp 0x1a35
movl $0x2, %eax
jmp 0x1a70
movl $0x9, %esi
callq 0x28f1
movl $0x1, %eax
popq %rbp
retq
leaq 0x258b(%rip), %rdi      # 0x4004
jmp 0x1a8b
leaq 0x2649(%rip), %rdi      # 0x40cb
jmp 0x1a8b
leaq 0x263f(%rip), %rdi      # 0x40ca
leaq 0x2577(%rip), %rsi      # 0x4009
leaq 0x270e(%rip), %rcx      # 0x41a7
movl $0xe7, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: CheckNum(Tree*, char**)
LexResult CheckNum   (Tree* tree, char** code)
{
    anal_ass;

    size_t num_len = 0;

    while ('0' <= (*code)[num_len] && (*code)[num_len] <= '9')
        num_len++;

    if ((*code)[num_len] == '.' && num_len != 0)
    {
        num_len++;
        while ('0' <= (*code)[num_len] && (*code)[num_len] <= '9')
            num_len++;
    }

    if (num_len > 0)
    {
        ElementConstructor (tree, NUM, code, num_len);
        return SUCCESS;
    }

    return NOT_THIS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1b15
movq %rsi, %rdx
testq %rsi, %rsi
je 0x1b1e
movq (%rdx), %rax
testq %rax, %rax
je 0x1b27
movq $-0x1, %rcx
movb 0x1(%rax,%rcx), %sil
leal -0x30(%rsi), %r8d
incq %rcx
cmpb $0xa, %r8b
jb 0x1ac3
cmpb $0x2e, %sil
setne %sil
testq %rcx, %rcx
sete %r8b
orb %sil, %r8b
jne 0x1afb
movb 0x1(%rax,%rcx), %sil
incq %rcx
addb $-0x30, %sil
cmpb $0xa, %sil
jb 0x1ae9
testq %rcx, %rcx
je 0x1b11
movl $0x7, %esi
callq 0x28f1
movl $0x1, %eax
jmp 0x1b13
xorl %eax, %eax
popq %rbp
retq
leaq 0x24e8(%rip), %rdi      # 0x4004
jmp 0x1b2e
leaq 0x25a6(%rip), %rdi      # 0x40cb
jmp 0x1b2e
leaq 0x259c(%rip), %rdi      # 0x40ca
leaq 0x24d4(%rip), %rsi      # 0x4009
leaq 0x268f(%rip), %rcx      # 0x41cb
movl $0xfd, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GetFuncParam(element**)
element* GetFuncParam (element** el_now)
{
    parse_ass;

    require (PARAM);
    next;

    if ((*el_now)->type == PARAM)
    {
        next;
        return nullptr;
    }

    require_ind;
    element* el_result = *el_now;
    el_result->type    = PARAM;
    next;

    while ((*el_now)->type != PARAM)
    {
        require_ind;
        (*el_now)->type = PARAM;
        ((*el_now) - 1)->left = *el_now;
        next;
    }
    
    next;
    return el_result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c77
movq %rdi, %rbx
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x1c80
cmpl $0x4, (%rcx)
jne 0x1bc9
leaq 0x30(%rcx), %rax
movq %rax, (%rbx)
movl 0x30(%rcx), %edx
cmpl $0x9, %edx
je 0x1bde
cmpl $0x4, %edx
jne 0x1c14
addq $0x60, %rcx
movq %rcx, (%rbx)
xorl %eax, %eax
jmp 0x1c70
leaq 0x2644(%rip), %rdi      # 0x4214
leaq 0x267a(%rip), %rsi      # 0x4251
movl $0x12b, %edx            # imm = 0x12B
jmp 0x1c4a
cmpq $0x0, 0x48(%rcx)
je 0x1c14
movl $0x4, (%rax)
movq %rax, %rcx
leaq 0x30(%rcx), %rdx
movq %rdx, (%rbx)
movl 0x30(%rcx), %esi
cmpl $0x9, %esi
jne 0x1c29
cmpq $0x0, 0x48(%rcx)
je 0x1c37
movl $0x4, 0x30(%rcx)
movq %rdx, 0x8(%rcx)
movq (%rbx), %rcx
jmp 0x1bee
leaq 0x25f9(%rip), %rdi      # 0x4214
leaq 0x262f(%rip), %rsi      # 0x4251
movl $0x134, %edx            # imm = 0x134
jmp 0x1c4a
cmpl $0x4, %esi
jne 0x1c37
addq $0x60, %rcx
movq %rcx, (%rbx)
jmp 0x1c70
leaq 0x25d6(%rip), %rdi      # 0x4214
leaq 0x260c(%rip), %rsi      # 0x4251
movl $0x13b, %edx            # imm = 0x13B
xorl %eax, %eax
callq 0x1040
movq (%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x25dc(%rip), %rdi      # 0x423b
xorl %eax, %eax
callq 0x1040
leaq 0x54f3(%rip), %rax      # 0x7160
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x258f(%rip), %rdi      # 0x420d
jmp 0x1c87
leaq 0x2585(%rip), %rdi      # 0x420c
leaq 0x237b(%rip), %rsi      # 0x4009
leaq 0x25bc(%rip), %rcx      # 0x4251
movl $0x129, %edx            # imm = 0x129
callq 0x1090