LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, 0x2e75(%rip)      # 0x4070
jne 0x123a
movq $0x0, -0x20(%rbp)
cmpq $0x100, -0x20(%rbp)     # imm = 0x100
jae 0x1238
movq -0x20(%rbp), %rax
movl %eax, %edi
callq 0x1190
movl %eax, %edx
movq -0x20(%rbp), %rcx
leaq 0x2e49(%rip), %rax      # 0x4070
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1205
jmp 0x123a
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x128f
movq -0x18(%rbp), %rax
movl (%rax), %eax
movzbl %al, %eax
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movslq %eax, %rcx
leaq 0x2e03(%rip), %rax      # 0x4070
movl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
xorl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1242
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x8060, %rsp           # imm = 0x8060
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8024(%rbp)
movl -0x8024(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1465
cmpl $0x0, -0x8024(%rbp)
je 0x1307
movq -0x10(%rbp), %rax
movslq -0x8024(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xd0b(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, -0x8030(%rbp)
jmp 0x1318
movq 0x2cd2(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movq %rax, -0x8030(%rbp)
movq -0x8030(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x144f
movl $0x0, -0x8028(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x8031(%rbp)
jne 0x1366
movq -0x18(%rbp), %rdi
callq 0x1030
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x8031(%rbp)
movb -0x8031(%rbp), %al
testb $0x1, %al
jne 0x1372
jmp 0x13b2
leaq -0x8020(%rbp), %rax
movq %rax, -0x8040(%rbp)
leaq -0x8020(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x1040
movq -0x8040(%rbp), %rdi
movq %rax, %rsi
leaq -0x8028(%rbp), %rdx
callq 0x11e0
jmp 0x1337
movq -0x18(%rbp), %rdi
callq 0x1030
cmpl $0x0, %eax
jne 0x143b
movl -0x8028(%rbp), %eax
movl %eax, -0x804c(%rbp)
movl -0x8(%rbp), %edx
leaq 0xc3c(%rip), %rax       # 0x2012
leaq 0xc34(%rip), %rcx       # 0x2011
cmpl $0x2, %edx
cmovgq %rcx, %rax
movq %rax, -0x8048(%rbp)
cmpl $0x2, -0x8(%rbp)
jle 0x1409
movq -0x10(%rbp), %rax
movslq -0x8024(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8058(%rbp)
jmp 0x1419
leaq 0xc02(%rip), %rax       # 0x2012
movq %rax, -0x8058(%rbp)
jmp 0x1419
movq -0x8048(%rbp), %rdx
movl -0x804c(%rbp), %esi
movq -0x8058(%rbp), %rcx
leaq 0xbd3(%rip), %rdi       # 0x2007
movb $0x0, %al
callq 0x1060
cmpl $0x0, -0x8024(%rbp)
je 0x144d
movq -0x18(%rbp), %rdi
callq 0x1050
jmp 0x144f
jmp 0x1451
movl -0x8024(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8024(%rbp)
jmp 0x12cb
xorl %eax, %eax
addq $0x8060, %rsp           # imm = 0x8060
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x10060, %rsp          # imm = 0x10060
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10000, -0x14(%rbp)   # imm = 0x10000
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x1360
movl $0x1, %edi
callq 0x1110
cmpl $0x0, %eax
je 0x12b8
movq 0x7d5c(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x4d6f(%rip), %rsi      # 0x6004
movb $0x0, %al
callq 0x10f0
movl $0x1, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1460
movl -0x4(%rbp), %eax
addq $0x10060, %rsp          # imm = 0x10060
popq %rbp
retq
jmp 0x12ba
jmp 0x12bc
leaq -0x40(%rbp), %rdi
leaq -0x10040(%rbp), %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0x13c0
jmp 0x12d3
movl $0x1, %edi
leaq -0x10040(%rbp), %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0x1040
movq %rax, -0x10060(%rbp)
jmp 0x12f2
movq -0x10060(%rbp), %rax
movq %rax, -0x10058(%rbp)
cmpq $0x10000, -0x10058(%rbp) # imm = 0x10000
jne 0x130f
jmp 0x134b
leaq 0x4d20(%rip), %rdi      # 0x6036
leaq 0x4d2c(%rip), %rsi      # 0x6049
movl $0x1c, %edx
leaq 0x4d2f(%rip), %rcx      # 0x6058
callq 0x1080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10048(%rbp)
movl %eax, -0x1004c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1460
jmp 0x1350
jmp 0x12ba
movq -0x10048(%rbp), %rdi
callq 0x1120
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x14(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x13eb
jmp 0x13f5
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
cmpq -0x18(%rbp), %rax
jb 0x1446
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %ecx, %edx
movl 0x14(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rsi
movl 0x14(%rax), %eax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x10b0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movl 0x14(%rax), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x1070
jmp 0x1457
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1a20
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3390
movq -0x70(%rbp), %rsi
movq %rax, %rcx
addq $-0x2, %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3250
movq -0x78(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x32f0
movq -0x70(%rbp), %rdi
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
callq 0x3390
movq -0x70(%rbp), %rsi
movq %rax, %rdx
addq $-0x2, %rdx
leaq -0x58(%rbp), %rdi
movl $0x2, %ecx
callq 0x3250
jmp 0x41c2
leaq 0x4eba(%rip), %rsi      # 0x9083
leaq -0x58(%rbp), %rdi
callq 0x4380
movb %al, -0x79(%rbp)
jmp 0x41d7
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x41e0
jmp 0x423e
movss -0x34(%rbp), %xmm0
movl $0xfffffffa, %edi       # imm = 0xFFFFFFFA
callq 0x4620
movsd %xmm0, -0x88(%rbp)
jmp 0x41f9
movsd -0x88(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x4299
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x42b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3150
jmp 0x42b9
leaq 0x4e41(%rip), %rsi      # 0x9086
leaq -0x58(%rbp), %rdi
callq 0x4380
movb %al, -0x89(%rbp)
jmp 0x4256
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x4262
jmp 0x4295
movss -0x34(%rbp), %xmm0
movl $0xfffffff7, %edi       # imm = 0xFFFFFFF7
callq 0x4620
movsd %xmm0, -0x98(%rbp)
jmp 0x427b
movsd -0x98(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x4299
jmp 0x4297
ud2
leaq -0x58(%rbp), %rdi
callq 0x3150
leaq -0x30(%rbp), %rdi
callq 0x3150
movss -0x4(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3150
movq -0x60(%rbp), %rdi
callq 0x33e0
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x60(%rbp)
callq 0x6670
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
leaq 0x4267(%rip), %rsi      # 0x949d
callq 0x3350
jmp 0x523d
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
leaq 0x4251(%rip), %rsi      # 0x949d
callq 0x3350
jmp 0x5253
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6690
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movl $0x64, %esi
callq 0x66b0
jmp 0x5274
leaq -0x30(%rbp), %rdi
callq 0x4740
leaq -0x31(%rbp), %rdi
callq 0x4860
movq -0x70(%rbp), %rdi
addq $0x58, %rdi
leaq 0x4208(%rip), %rsi      # 0x949d
callq 0x3350
jmp 0x529c
movq -0x70(%rbp), %rdi
addq $0x78, %rdi
leaq 0x41f2(%rip), %rsi      # 0x949d
callq 0x3350
jmp 0x52b2
movq -0x70(%rbp), %rdi
addq $0x98, %rdi
leaq 0x41d9(%rip), %rsi      # 0x949d
callq 0x3350
jmp 0x52cb
movq -0x70(%rbp), %rax
movl $0x0, 0xb8(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x5305
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x4860
movq -0x48(%rbp), %rdi
callq 0x3150
movq -0x50(%rbp), %rdi
callq 0x3150
movq -0x58(%rbp), %rdi
callq 0x3150
movq -0x60(%rbp), %rdi
callq 0x4740
movq -0x68(%rbp), %rdi
callq 0x3150
movq -0x40(%rbp), %rdi
callq 0x3150
movq -0x10(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x14(%rbp), %rdx
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rcx
leaq -0x40(%rbp), %rdi
callq 0x3250
leaq -0x40(%rbp), %rdi
callq 0x3390
subq $0x1, %rax
movl %eax, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
cmpl $-0x1, -0x44(%rbp)
je 0x64ee
movslq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3430
movq %rax, -0x60(%rbp)
jmp 0x6483
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x64ba
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x64e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3150
jmp 0x6506
cvtsi2sdl -0x44(%rbp), %xmm0
callq 0x31f0
movaps %xmm0, %xmm1
cvtsi2sdl -0x1c(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x646a
movl -0x1c(%rbp), %eax
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3150
movl -0x64(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33e0
nop
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5370
movq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x32d0
leaq -0x30(%rbp), %rdi
callq 0x3150
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x53d0
movq -0xd0(%rbp), %rdi
addq $0x20, %rdi
leaq -0x50(%rbp), %rsi
callq 0x32d0
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x5430
movq -0xd0(%rbp), %rdi
addq $0x40, %rdi
leaq -0x68(%rbp), %rsi
callq 0x6830
leaq -0x68(%rbp), %rdi
callq 0x4740
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x5490
movq -0xd0(%rbp), %rdi
addq $0x58, %rdi
leaq -0x88(%rbp), %rsi
callq 0x32d0
leaq -0x88(%rbp), %rdi
callq 0x3150
movq -0x10(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x54f0
movq -0xd0(%rbp), %rdi
addq $0x78, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x32d0
leaq -0xa8(%rbp), %rdi
callq 0x3150
movq -0x10(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x5550
movq -0xd0(%rbp), %rdi
addq $0x98, %rdi
leaq -0xc8(%rbp), %rsi
callq 0x32d0
leaq -0xc8(%rbp), %rdi
callq 0x3150
movq -0x10(%rbp), %rdi
callq 0x55b0
movl %eax, %ecx
movq -0xd0(%rbp), %rax
movl %ecx, 0xb8(%rax)
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x74d0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x74ce
movq -0x28(%rbp), %rdi
callq 0x7ec0
movq -0x28(%rbp), %rdi
movl $0xc8, %esi
callq 0x3230
jmp 0x748b
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x21(%rbp)
movl $0xc8, %edi
callq 0x3220
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x7ee0
jmp 0x7532
movq -0x50(%rbp), %rsi
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6510
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $0x0, 0xc0(%rcx)
cmpq $0x0, (%rax)
jne 0x758d
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x21(%rbp)
jmp 0x75c1
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0xc8, %esi
callq 0x3230
jmp 0x75cc
jmp 0x758f
movq -0x18(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0x75ae
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x758f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xc0(%rax)
movb $0x1, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x49(%rbp)
je 0x7617
movb -0x19(%rbp), %al
xorb $-0x1, %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x7620
jmp 0x7666
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x5370
movq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x7f00
movb %al, -0x4a(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3150
movb -0x4a(%rbp), %al
testb $0x1, %al
jne 0x764f
jmp 0x7655
movb $0x1, -0x19(%rbp)
jmp 0x7664
movq -0x18(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7603
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x77ab
movq -0x20(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
jne 0x76f9
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x76e5
movq -0x60(%rbp), %rdi
callq 0x7ec0
movq -0x60(%rbp), %rdi
movl $0xc8, %esi
callq 0x3230
movq -0x50(%rbp), %rax
movq $0x0, (%rax)
movb $0x1, -0x21(%rbp)
jmp 0x77a9
jmp 0x76fb
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x61(%rbp)
je 0x770f
movb -0x21(%rbp), %al
xorb $-0x1, %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x771b
jmp 0x77a7
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x5370
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x7f00
movb %al, -0x62(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3150
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x774a
jmp 0x778b
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xc0(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x7785
movq -0x70(%rbp), %rdi
callq 0x7ec0
movq -0x70(%rbp), %rdi
movl $0xc8, %esi
callq 0x3230
movb $0x1, -0x21(%rbp)
jmp 0x77a2
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x76fb
jmp 0x77a9
jmp 0x77ab
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x78aa
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x5370
movq -0x70(%rbp), %rsi
movq 0x57cf(%rip), %rdi      # 0xcfd0
callq 0x31e0
movq %rax, -0x68(%rbp)
jmp 0x780c
movq -0x68(%rbp), %rdi
leaq 0x1cab(%rip), %rsi      # 0x94c2
callq 0x3210
movq %rax, -0x78(%rbp)
jmp 0x7822
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x53d0
jmp 0x7831
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x31e0
movq %rax, -0x80(%rbp)
jmp 0x7844
movq -0x80(%rbp), %rdi
leaq 0x1c4d(%rip), %rsi      # 0x949c
callq 0x3210
jmp 0x7856
leaq -0x60(%rbp), %rdi
callq 0x3150
leaq -0x30(%rbp), %rdi
callq 0x3150
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x77da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x789f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3150
leaq -0x30(%rbp), %rdi
callq 0x3150
jmp 0x78b3
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x21a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x35a1
movb $0x1, -0x85(%rbp)
movl $0x10, %edi
callq 0x20c0
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xea2(%rip), %rsi       # 0x435d
leaq -0x78(%rbp), %rdi
callq 0x39e0
jmp 0x34c6
leaq 0xe61(%rip), %rdx       # 0x432e
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3990
jmp 0x34dc
callq 0x21b0
movq %rax, %rdx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3990
jmp 0x34f3
movq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x22a0
jmp 0x3505
movq -0x98(%rbp), %rdi
movb $0x0, -0x85(%rbp)
movq 0x2ad6(%rip), %rsi      # 0x5ff0
movq 0x2aa7(%rip), %rdx      # 0x5fc8
callq 0x22c0
jmp 0x35b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3588
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x357f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3576
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20f0
leaq -0x58(%rbp), %rdi
callq 0x20f0
leaq -0x78(%rbp), %rdi
callq 0x20f0
testb $0x1, -0x85(%rbp)
jne 0x3593
jmp 0x359f
movq -0x98(%rbp), %rdi
callq 0x2140
jmp 0x35ae
movq -0x18(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x22f0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2090
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2090
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq %rax, %rdx
callq 0x2100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3970
movb $0x1, -0xcd(%rbp)
movl $0x10, %edi
callq 0x20c0
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xb57(%rip), %rsi       # 0x435d
leaq -0xc0(%rbp), %rdi
callq 0x39e0
jmp 0x3814
leaq 0xb4f(%rip), %rdx       # 0x436a
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x3990
jmp 0x3830
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3f00
jmp 0x3846
leaq 0xae1(%rip), %rdx       # 0x432e
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3990
jmp 0x385c
callq 0x21b0
movq %rax, %rdx
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3990
jmp 0x3873
movq -0xe8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x22a0
jmp 0x3885
movq -0xe8(%rbp), %rdi
movb $0x0, -0xcd(%rbp)
movq 0x2756(%rip), %rsi      # 0x5ff0
movq 0x2727(%rip), %rdx      # 0x5fc8
callq 0x22c0
jmp 0x3989
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x3957
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x394b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x393f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x3936
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
jmp 0x392d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x20f0
leaq -0x60(%rbp), %rdi
callq 0x20f0
leaq -0x80(%rbp), %rdi
callq 0x20f0
leaq -0xa0(%rbp), %rdi
callq 0x20f0
leaq -0xc0(%rbp), %rdi
callq 0x20f0
testb $0x1, -0xcd(%rbp)
jne 0x3962
jmp 0x396e
movq -0xe8(%rbp), %rdi
callq 0x2140
jmp 0x397d
movq -0x20(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x22f0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3270
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0x9993
leaq 0x4774(%rip), %rdi      # 0xe0ba
xorl %eax, %eax
movl %eax, -0x54(%rbp)
callq 0x2040
leaq -0x15(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2260
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rdx
movl %eax, %esi
callq 0x21d0
jmp 0x9971
leaq -0x15(%rbp), %rdi
callq 0x21a0
jmp 0x99ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x21a0
jmp 0x99b6
movq -0x38(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x32e0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2080
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2250
nop
// File: 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
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x3270
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x9a34
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x32e0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x9b10
testb $0x1, %al
jne 0x9a1f
jmp 0x9a27
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9a49
jmp 0x9a29
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x99e3
leaq 0x469d(%rip), %rdi      # 0xe0d8
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x2800, %rsp           # imm = 0x2800
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x27b8(%rbp)
leaq -0x1390(%rbp), %rdi
movq %rdi, -0x27b0(%rbp)
callq 0xb6e0
movq -0x27b0(%rbp), %rdi
callq 0xb780
movl %eax, -0x27a4(%rbp)
jmp 0xa491
movl -0x27a4(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x2718(%rbp), %rdi
callq 0xb7a0
jmp 0xa4a9
leaq -0x2738(%rbp), %rdi
movsd 0x3c40(%rip), %xmm0     # 0xe0f8
movsd 0x3c40(%rip), %xmm1     # 0xe100
callq 0xb7d0
jmp 0xa4c7
leaq -0x2748(%rbp), %rdi
movsd 0x3c32(%rip), %xmm0     # 0xe108
movsd 0x3c32(%rip), %xmm1     # 0xe110
callq 0xb7d0
jmp 0xa4e5
movl $0x0, -0x274c(%rbp)
cmpl $0xa, -0x274c(%rbp)
jge 0xa623
leaq -0x2748(%rbp), %rdi
leaq -0x2718(%rbp), %rsi
callq 0xb800
movsd %xmm0, -0x27c0(%rbp)
jmp 0xa519
movsd -0x27c0(%rbp), %xmm0
movsd %xmm0, -0x2798(%rbp)
fldl -0x2798(%rbp)
fstpt -0x2760(%rbp)
leaq -0x2738(%rbp), %rdi
leaq -0x2718(%rbp), %rsi
callq 0xb800
movsd %xmm0, -0x27c8(%rbp)
jmp 0xa552
movq -0x27b8(%rbp), %rax
movsd -0x27c8(%rbp), %xmm0
movsd %xmm0, -0x27a0(%rbp)
fldl -0x27a0(%rbp)
fstpt -0x2770(%rbp)
movq %rax, -0x27d8(%rbp)
movl $0x20, %edi
callq 0x2170
movq %rax, -0x27d0(%rbp)
jmp 0xa58f
movq -0x27d0(%rbp), %rdi
fldt -0x2760(%rbp)
fldt -0x2770(%rbp)
movq %rsp, %rax
fstpt 0x10(%rax)
fstpt (%rax)
callq 0xb860
jmp 0xa5b1
movq -0x27d8(%rbp), %rdi
movq -0x27d0(%rbp), %rax
movq %rax, -0x2778(%rbp)
leaq -0x2778(%rbp), %rsi
callq 0xb830
jmp 0xa5d4
jmp 0xa5d6
movl -0x274c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x274c(%rbp)
jmp 0xa4ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2720(%rbp)
movl %eax, -0x2724(%rbp)
jmp 0xa673
movq -0x27d0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2720(%rbp)
movl %eax, -0x2724(%rbp)
movl $0x20, %esi
callq 0x2180
jmp 0xa673
movq -0x27b8(%rbp), %rdi
callq 0xb890
movq -0x27b8(%rbp), %rdi
movq %rax, -0x2780(%rbp)
callq 0xb8c0
movq %rax, -0x2788(%rbp)
movq -0x2780(%rbp), %rdi
movq -0x2788(%rbp), %rsi
callq 0xa690
jmp 0xa65e
leaq -0x1390(%rbp), %rdi
callq 0xb8f0
addq $0x2800, %rsp           # imm = 0x2800
popq %rbp
retq
leaq -0x1390(%rbp), %rdi
callq 0xb8f0
movq -0x2720(%rbp), %rdi
callq 0x2250
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xb920
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jb 0xa718
leaq 0x3a49(%rip), %rdi      # 0xe150
movb $0x0, %al
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0xa72c
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xb940
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Mulan-Szechuan-Sauce[P]javelin/obj/scopes.tab.c
// Function: yystrlen(char const*)
static YYPTRDIFF_T
yystrlen (const char *yystr)
{
  YYPTRDIFF_T yylen;
  for (yylen = 0; yystr[yylen]; yylen++)
    continue;
  return yylen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x406e
jmp 0x4060
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4050
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x12b6
leaq 0x4d61(%rip), %rdi      # 0x6004
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x134e
movq $0x0, -0x60(%rbp)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movl $0xc, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3a10
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1360
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x133e
leaq -0x60(%rbp), %rdi
callq 0x4060
leaq -0x60(%rbp), %rdi
callq 0x3a70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1379
jmp 0x1398
leaq 0x4ca0(%rip), %rdi      # 0x6020
leaq 0x4c9e(%rip), %rsi      # 0x6025
movl $0x19, %edx
leaq 0x4ca8(%rip), %rcx      # 0x603b
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x13a1
jmp 0x13c0
leaq 0x4cb5(%rip), %rdi      # 0x605d
leaq 0x4c76(%rip), %rsi      # 0x6025
movl $0x1a, %edx
leaq 0x4c80(%rip), %rcx      # 0x603b
callq 0x1090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1400
testb $0x1, %al
jne 0x13d3
jmp 0x13d9
movb $0x1, -0x1(%rbp)
jmp 0x13f2
movq -0x10(%rbp), %rdi
callq 0x1530
testb $0x1, %al
jne 0x13e8
jmp 0x13ee
movb $0x1, -0x1(%rbp)
jmp 0x13f2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1419
jmp 0x1438
leaq 0x4c00(%rip), %rdi      # 0x6020
leaq 0x4bfe(%rip), %rsi      # 0x6025
movl $0x27, %edx
leaq 0x4c34(%rip), %rcx      # 0x6067
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x1441
jmp 0x1460
leaq 0x4c15(%rip), %rdi      # 0x605d
leaq 0x4bd6(%rip), %rsi      # 0x6025
movl $0x28, %edx
leaq 0x4c0c(%rip), %rcx      # 0x6067
callq 0x1090
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x3f30
cmpq $0x0, %rax
jne 0x1484
movb $0x1, -0x1(%rbp)
jmp 0x151b
movq $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x16b0
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x150e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x14cb
leaq 0x4bd3(%rip), %rdi      # 0x6091
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x151b
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17b0
testb $0x1, %al
jne 0x14de
jmp 0x14ff
movq -0x28(%rbp), %rsi
leaq 0x4bb6(%rip), %rdi      # 0x609f
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x3a70
movb $0x1, -0x1(%rbp)
jmp 0x151b
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x16b0
jmp 0x14a1
movq -0x20(%rbp), %rdi
callq 0x1130
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1545
jmp 0x1564
leaq 0x4ad4(%rip), %rdi      # 0x6020
leaq 0x4ad2(%rip), %rsi      # 0x6025
movl $0x4a, %edx
leaq 0x4b53(%rip), %rcx      # 0x60b2
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl 0x4b56(%rip), %eax      # 0x60cc
movl %eax, -0x1d(%rbp)
movb 0x4b51(%rip), %al       # 0x60d0
movb %al, -0x19(%rbp)
leaq -0x1d(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
movl $0x4, %ecx
callq 0x3ad0
movq -0x28(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
imulq $0x30, 0x18(%rcx), %rcx
addq %rcx, %rax
addq $-0x30, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq -0x28(%rbp), %rdx
movl $0x4, %ecx
callq 0x3ad0
movq -0x28(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x30, 0x18(%rax), %rax
addq %rax, %rcx
addq $-0x30, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1950
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
leaq 0x7b0a(%rip), %rcx      # 0x9150
cmpq (%rcx), %rax
jne 0x165a
movq -0x10(%rbp), %rdi
callq 0x3a70
movb $0x1, -0x1(%rbp)
jmp 0x16a1
jmp 0x165c
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x31(%rbp)
je 0x1680
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x15d4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x16c9
jmp 0x16e8
leaq 0x4a25(%rip), %rdi      # 0x60f5
leaq 0x494e(%rip), %rsi      # 0x6025
movl $0x6f, %edx
leaq 0x49ee(%rip), %rcx      # 0x60d1
callq 0x1090
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x16f4
jmp 0x1713
leaq 0x49f9(%rip), %rdi      # 0x60f4
leaq 0x4923(%rip), %rsi      # 0x6025
movl $0x70, %edx
leaq 0x49c3(%rip), %rcx      # 0x60d1
callq 0x1090
jmp 0x1715
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x11(%rbp)
je 0x1764
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x11(%rbp)
je 0x1764
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x11(%rbp)
je 0x1764
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x176d
jmp 0x179d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x178a
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1715
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x17c9
jmp 0x17e8
leaq 0x4850(%rip), %rdi      # 0x6020
leaq 0x484e(%rip), %rsi      # 0x6025
movl $0x7e, %edx
leaq 0x4917(%rip), %rcx      # 0x60fa
callq 0x1090
cmpq $0x0, -0x18(%rbp)
je 0x17f1
jmp 0x1810
leaq 0x48fd(%rip), %rdi      # 0x60f5
leaq 0x4826(%rip), %rsi      # 0x6025
movl $0x7e, %edx
leaq 0x48ef(%rip), %rcx      # 0x60fa
callq 0x1090
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x181c
jmp 0x183b
leaq 0x48d1(%rip), %rdi      # 0x60f4
leaq 0x47fb(%rip), %rsi      # 0x6025
movl $0x7e, %edx
leaq 0x48c4(%rip), %rcx      # 0x60fa
callq 0x1090
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ac0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x186e
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1942
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b90
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x189a
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1942
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c70
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x18c3
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1942
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d50
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x18ec
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1942
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ed0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1915
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1942
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2020
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x193e
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1942
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)