LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/cpu.cpp
// Function: void CPU::subtract<unsigned char>(unsigned char)
void CPU::subtract(t n) {
  reg.f = 0;
  if (reg.a < n) {
    bitSet(reg.f, FLAG_CARRY);
  }
  if ((reg.a & 0xF) < (n & 0xF)) {
    bitSet(reg.f, FLAG_HALF_CARRY);
  }
  bitSet(reg.f, FLAG_SUBTRACT);
  reg.a -= n;
  if (reg.a == 0) {
    bitSet(reg.f, FLAG_ZERO);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x1(%rdi), %cl
cmpb %sil, %cl
setb %al
shlb $0x4, %al
movl %ecx, %edx
andb $0xf, %dl
movl %esi, %r8d
andb $0xf, %r8b
leal 0x20(%rax), %r9d
cmpb %dl, %r8b
movzbl %al, %edx
movzbl %r9b, %eax
cmovbel %edx, %eax
leal 0x40(%rax), %edx
movb %dl, (%rdi)
subb %sil, %cl
movb %cl, 0x1(%rdi)
jne 0x3449a
orb $-0x40, %al
movb %al, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/cpu.cpp
// Function: void CPU::subtractCarry<unsigned char>(unsigned char)
void CPU::subtractCarry(t n) {
  u8 prevCarry = bitTest(reg.f, FLAG_CARRY);
  if (reg.a < n + prevCarry) {
    bitSet(reg.f, FLAG_CARRY);
  }
  if ((reg.a & 0x0F) < ((n + prevCarry) & 0x0F)) {
    bitSet(reg.f, FLAG_HALF_CARRY);
  }
  bitSet(reg.f, FLAG_SUBTRACT);
  reg.a -= (n + prevCarry);
  if (reg.a == 0) {
    bitSet(reg.f, FLAG_ZERO);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
btl $0x4, %eax
adcl $0x0, %esi
movzbl 0x1(%rdi), %ecx
movl %eax, %edx
orb $0x10, %dl
cmpl %ecx, %esi
movzbl %dl, %edx
cmovbel %eax, %edx
movl %ecx, %eax
andl $0xf, %eax
movl %esi, %r8d
andl $0xf, %r8d
movl %edx, %r9d
orb $0x20, %r9b
cmpl %eax, %r8d
movzbl %r9b, %eax
cmovbel %edx, %eax
movl %eax, %edx
orb $0x40, %dl
movb %dl, (%rdi)
subb %sil, %cl
movb %cl, 0x1(%rdi)
jne 0x344ea
orb $-0x40, %al
movb %al, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/cpu.cpp
// Function: void CPU::compare<unsigned char>(unsigned char)
void CPU::compare(t num) {
  reg.f = 0;
  if (reg.a < num) {
    bitSet(reg.f, FLAG_CARRY);
  }
  if ((reg.a & 0xF) < (num & 0xF)) {
    bitSet(reg.f, FLAG_HALF_CARRY);
  }
  bitSet(reg.f, FLAG_SUBTRACT);
  if (reg.a - num == 0) {
    bitSet(reg.f, FLAG_ZERO);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x1(%rdi), %al
cmpb %sil, %al
setb %cl
setne %dl
shlb $0x4, %cl
andb $0xf, %al
andb $0xf, %sil
leal 0x20(%rcx), %r8d
cmpb %al, %sil
movzbl %cl, %eax
movzbl %r8b, %ecx
cmovbel %eax, %ecx
shlb $0x7, %dl
orb %cl, %dl
addb $-0x40, %dl
movb %dl, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/cpu.cpp
// Function: void CPU::sla<unsigned char>(unsigned char&)
void CPU::sla(t &reg1) {
  reg.f = 0;
  if (bitTest(reg1, 7)) {
    bitSet(reg.f, FLAG_CARRY);
  }
  reg1 <<= 1;
  if (reg1 == 0) {
    bitSet(reg.f, FLAG_ZERO);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, (%rdi)
movb (%rsi), %al
shrb $0x3, %al
andb $0x10, %al
movb %al, (%rdi)
movb (%rsi), %al
addb %al, %al
movb %al, (%rsi)
jne 0x346eb
orb $-0x80, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/cpu.cpp
// Function: void CPU::sra<unsigned char>(unsigned char&)
void CPU::sra(t &reg1) {
  reg.f = 0;
  u8 msb = bitTest(reg1, 7);
  if (bitTest(reg1, 0)) {
    bitSet(reg.f, FLAG_CARRY);
  }
  reg1 >>= 1;
  reg1 += (msb << 7);
  if (reg1 == 0) {
    bitSet(reg.f, FLAG_ZERO);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, (%rdi)
movb (%rsi), %al
movl %eax, %ecx
shlb $0x4, %cl
andb $0x10, %cl
movb %cl, (%rdi)
movb (%rsi), %cl
shrb %cl
andb $-0x80, %al
orb %cl, %al
movb %al, (%rsi)
jne 0x34710
orb $-0x80, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/cpu.cpp
// Function: void CPU::srl<unsigned char>(unsigned char&)
void CPU::srl(t &reg1) {
  reg.f = 0;
  if (bitTest(reg1, 0)) {
    bitSet(reg.f, FLAG_CARRY);
  }
  reg1 >>= 1;
  if (reg1 == 0) {
    bitSet(reg.f, FLAG_ZERO);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, (%rdi)
movb (%rsi), %al
testb $0x1, %al
je 0x34724
movb $0x10, (%rdi)
movb (%rsi), %al
movl %eax, %ecx
shrb %cl
movb %cl, (%rsi)
cmpb $0x1, %al
ja 0x34731
orb $-0x80, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/main.cpp
// Function: handleSdlEvents()
void handleSdlEvents() {
  // Handle keydown, window close, etc
  SDL_Event event;
  while (SDL_PollEvent(&event)) {
    ImGui_ImplSdl_ProcessEvent(&event);
    switch (event.type) {
      case SDL_KEYDOWN:
        handleKeyPress(event.key.keysym.sym);
      case SDL_CONTROLLERBUTTONDOWN:
      case SDL_KEYUP:
      case SDL_CONTROLLERBUTTONUP:
        g_joypad.handleEvent(event);
        break;

      case SDL_CONTROLLERDEVICEADDED:
        // todo
        break;

      case SDL_CONTROLLERDEVICEREMOVED:
        // todo
        break;

      case SDL_QUIT:
        g_quit = true;
        break;

      default:
        break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
leaq -0x48(%rbp), %rbx
leaq 0x3954a(%rip), %r14     # 0x6dec0
movq %rbx, %rdi
callq 0x77f0
testl %eax, %eax
je 0x349eb
movq %rbx, %rdi
callq 0x30cbc
movl -0x48(%rbp), %eax
leal -0x651(%rax), %ecx
cmpl $0x2, %ecx
jb 0x349b5
cmpl $0x100, %eax            # imm = 0x100
je 0x349e2
cmpl $0x301, %eax            # imm = 0x301
je 0x349b5
cmpl $0x300, %eax            # imm = 0x300
jne 0x34976
movl -0x34(%rbp), %edi
callq 0x355d1
movq -0x18(%rbp), %rax
movq %rax, 0x30(%rsp)
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x3134c
jmp 0x34976
movb $0x1, 0x39567(%rip)     # 0x6df50
jmp 0x34976
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/main.cpp
// Function: imguiRegisters()
void imguiRegisters() {
  // Position to the right of disassembly window
  ImGui::SetNextWindowPos(ImVec2(DISASM_WINDOW_WIDTH, 0.0f));
  ImGui::SetNextWindowSize(ImVec2(REG_WINDOW_WIDTH, REG_WINDOW_HEIGHT));
  ImGui::Begin("reg", nullptr,
               ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize);
  ImGui::Text(
      "af = %04X\nbc = %04X\nde = %04X\nhl = %04X\nsp = %04X\npc = %04X",
      g_cpu.reg.af, g_cpu.reg.bc, g_cpu.reg.de, g_cpu.reg.hl, g_cpu.reg.sp,
      g_cpu.reg.pc);
  ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x10(%rbp), %rbx
movq $0x43960000, (%rbx)     # imm = 0x43960000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11aa5
movabsq $0x42f0000042c80000, %rax # imm = 0x42F0000042C80000
movq %rax, (%rbx)
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xb0b1
leaq 0xe2e4(%rip), %rdi      # 0x42ee4
pushq $0x6
popq %rdx
xorl %esi, %esi
callq 0xb0d4
movzwl 0x261e7(%rip), %esi     # 0x5adf8
movzwl 0x261e2(%rip), %edx     # 0x5adfa
movzwl 0x261dd(%rip), %ecx     # 0x5adfc
movzwl 0x261d7(%rip), %r8d     # 0x5adfe
movzwl 0x261d3(%rip), %r9d     # 0x5ae02
movzwl 0x261ca(%rip), %eax     # 0x5ae00
movl %eax, (%rsp)
leaq 0xe2a8(%rip), %rdi      # 0x42ee8
xorl %eax, %eax
callq 0x1227e
callq 0xb516
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/main.cpp
// Function: imguiLcdStatus()
void imguiLcdStatus() {
  // Position to the right of disassembly window, below register window
  ImGui::SetNextWindowPos(ImVec2(DISASM_WINDOW_WIDTH, REG_WINDOW_HEIGHT));
  ImGui::SetNextWindowSize(ImVec2(REG_WINDOW_WIDTH, LCD_STATUS_WINDOW_HEIGHT));
  ImGui::Begin("lcd stat", nullptr,
               ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize);
  ImGui::Text(
      "%02X FF40 LCDC\n"
      "%02X FF41 STAT\n"
      "%02X FF42 SCY\n"
      "%02X FF43 SCX\n"
      "%02X FF44 LY\n"
      "%02X FF45 LYC\n"
      "%02X FF46 DMA\n"
      "%02X FF47 BGP\n"
      "%02X FF48 OBP0\n"
      "%02X FF49 OBP1\n"
      "%02X FF4A WY\n"
      "%02X FF4B WX\n",
      g_cpu.mmu.memory[0xFF40], g_cpu.mmu.memory[0xFF41],
      g_cpu.mmu.memory[0xFF42], g_cpu.mmu.memory[0xFF43],
      g_cpu.mmu.memory[0xFF44], g_cpu.mmu.memory[0xFF45],
      g_cpu.mmu.memory[0xFF46], g_cpu.mmu.memory[0xFF47],
      g_cpu.mmu.memory[0xFF48], g_cpu.mmu.memory[0xFF49],
      g_cpu.mmu.memory[0xFF4A], g_cpu.mmu.memory[0xFF4B]);
  ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $0x42f0000043960000, %rax # imm = 0x42F0000043960000
leaq -0x30(%rbp), %rbx
movq %rax, (%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11aa5
movabsq $0x4348000042c80000, %rax # imm = 0x4348000042C80000
movq %rax, (%rbx)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xb0b1
leaq 0xe289(%rip), %rdi      # 0x42f24
pushq $0x6
popq %rdx
xorl %esi, %esi
callq 0xb0d4
movq 0x2616c(%rip), %rax     # 0x5ae18
movzbl 0xff40(%rax), %esi
movzbl 0xff41(%rax), %edx
movzbl 0xff42(%rax), %ecx
movzbl 0xff43(%rax), %r8d
movzbl 0xff44(%rax), %r9d
movzbl 0xff45(%rax), %r10d
movzbl 0xff46(%rax), %r11d
movzbl 0xff47(%rax), %ebx
movzbl 0xff48(%rax), %r14d
movzbl 0xff49(%rax), %r15d
movzbl 0xff4a(%rax), %r12d
movzbl 0xff4b(%rax), %r13d
subq $0x8, %rsp
leaq 0xe21a(%rip), %rdi      # 0x42f2d
xorl %eax, %eax
pushq %r13
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
callq 0x1227e
addq $0x40, %rsp
callq 0xb516
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/donfreiday[P]gb/main.cpp
// Function: imguiHelp()
void imguiHelp() {
  ImGui::SetNextWindowPos(ImVec2(DISASM_WINDOW_WIDTH+REG_WINDOW_WIDTH, 0.0f));
  ImGui::Begin("controls", nullptr,
               ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize);
  ImGui::Text(
      "A: z\n"
      "B: x\n"
      "Select: space\n"
      "Start: enter\n"
      "Directions: arrows\n"
      "Fullscreen: f\n");
  ImGui::End();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdi
movq $0x43c80000, (%rdi)     # imm = 0x43C80000
xorl %esi, %esi
callq 0x11aa5
leaq 0xdf0b(%rip), %rdi      # 0x43051
pushq $0x6
popq %rdx
xorl %esi, %esi
callq 0xb0d4
leaq 0xdf03(%rip), %rdi      # 0x4305a
xorl %eax, %eax
callq 0x1227e
callq 0xb516
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/codebrainz[P]libutfxx/utf/string-demo.cxx
// Function: main
int main()
{
	utf::u8string s = "Hello World";

	s += ", How are you?";
	s += " Not too shabby";
	s += ", if I must say!";

	std::cout << s << std::endl;

	utf::u32string s1 = "Hello World";
	utf::u16string s2 = "Hello World";
	utf::u8string s3 = "Hi";

	std::cout <<s3<<std::endl;

	bool eq = (s1 == s2);
	bool neq = (s1 != s2);

	std::cout << "EQ: " << eq << std::endl;
	std::cout << "NEQ: " << neq << std::endl;

	//std::cout << "to_string(): " << std::to_string(s2) << std::endl;

	s2 += "Foo";

	std::cout << s1 << std::endl;
	std::cout << s2 << std::endl;

	//for (auto ch : s) {
	//	std::cout << ch << ", ";
	//}
	//std::cout << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xc8, %rsp
leaq 0xd08(%rip), %rsi       # 0x3004
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x2530
leaq 0xd00(%rip), %rsi       # 0x3010
movq %rbx, %rdi
callq 0x2a8c
leaq 0xd00(%rip), %rsi       # 0x301f
leaq 0x48(%rsp), %rdi
callq 0x2a8c
leaq 0xcff(%rip), %rsi       # 0x302f
leaq 0x48(%rsp), %rdi
callq 0x2a8c
movq 0x2c97(%rip), %rdi      # 0x4fd8
leaq 0x48(%rsp), %rsi
callq 0x259a
movq %rax, %rdi
callq 0x2080
leaq 0xcaa(%rip), %rsi       # 0x3004
leaq 0x28(%rsp), %rdi
callq 0x25f2
leaq 0xc99(%rip), %rsi       # 0x3004
leaq 0x8(%rsp), %rdi
callq 0x265c
leaq 0xcc4(%rip), %rsi       # 0x3040
leaq 0xa8(%rsp), %rdi
callq 0x2530
movq 0x2c48(%rip), %rdi      # 0x4fd8
leaq 0xa8(%rsp), %rsi
callq 0x259a
movq %rax, %rdi
callq 0x2080
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2814
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x26c8
movl %eax, %ebp
leaq 0x88(%rsp), %rdi
callq 0x2976
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2814
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2716
movl %eax, %ebx
leaq 0x68(%rsp), %rdi
callq 0x2976
movq 0x2bcf(%rip), %rdi      # 0x4fd8
leaq 0xc34(%rip), %rsi       # 0x3044
callq 0x20e0
movzbl %bpl, %esi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x2080
movq 0x2ba8(%rip), %rdi      # 0x4fd8
leaq 0xc0c(%rip), %rsi       # 0x3043
callq 0x20e0
movzbl %bl, %esi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x2080
leaq 0xbf3(%rip), %rsi       # 0x3049
leaq 0x8(%rsp), %rdi
callq 0x2d6e
movq 0x2b71(%rip), %rdi      # 0x4fd8
leaq 0x28(%rsp), %rsi
callq 0x2766
movq %rax, %rdi
callq 0x2080
movq 0x2b58(%rip), %rdi      # 0x4fd8
leaq 0x8(%rsp), %rsi
callq 0x27bd
movq %rax, %rdi
callq 0x2080
leaq 0xa8(%rsp), %rdi
callq 0x2070
leaq 0x8(%rsp), %rdi
callq 0x2976
leaq 0x28(%rsp), %rdi
callq 0x2986
leaq 0x48(%rsp), %rdi
callq 0x2070
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x24de
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x2976
jmp 0x24fd
jmp 0x24fa
movq %rax, %rbx
jmp 0x250a
movq %rax, %rbx
jmp 0x2514
jmp 0x24f5
jmp 0x24fa
movq %rax, %rbx
jmp 0x251e
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x2070
leaq 0x8(%rsp), %rdi
callq 0x2976
leaq 0x28(%rsp), %rdi
callq 0x2986
leaq 0x48(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/codebrainz[P]libutfxx/utf/./utfstring.h
// Function: utf::operator<<(std::ostream&, utf::string<char> const&)
inline friend std::ostream& operator<<(std::ostream& out, const string<char_type>& str)
	{
		std::basic_string<std::ostream::char_type> out_str;
		utf::convert(str.str(), out_str);
		out << out_str.c_str();
		return out;
	}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2130
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x20e0
movq %rsp, %rdi
callq 0x2070
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/codebrainz[P]libutfxx/utf/./utfstring.h
// Function: utf::string<char>& utf::string<char>::append<char const*>(char const*)
string& append(T str) {
		string_type tmp;
		utf::convert(str, tmp);
		s += tmp;
		return *this;
	}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x29ba
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2130
leaq 0x30(%rsp), %rdi
callq 0x2070
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x21b0
leaq 0x10(%rsp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x2afe
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2070
jmp 0x2b01
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/img2pd/img2pd.cpp
// Function: AddImageToPixelDatabase(gaps::R2PixelDatabase&, char const*)
static int
AddImageToPixelDatabase(R2PixelDatabase& pd, const char *image_filename)
{
  // Add image to pixel database
  R2Image image;
  if (!image.ReadFile(image_filename)) return 0;
  pd.InsertImage(image_filename, image);

  // Increment image counter
  image_count++;

  // Print message
  if (print_debug) {
    printf("  %s\n", image_filename);
    fflush(stdout);
  }
  
  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x8600
movq %r15, %rdi
movq %rbx, %rsi
callq 0x861c
testl %eax, %eax
je 0x641f
movq (%r14), %rax
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x30(%rax)
incl 0x6a127(%rip)           # 0x70518
pushq $0x1
popq %rbp
cmpb $0x1, 0x6a121(%rip)     # 0x7051c
jne 0x6421
leaq 0x46d1b(%rip), %rdi     # 0x4d11f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5060
movq 0x69b9b(%rip), %rax     # 0x6ffb0
movq (%rax), %rdi
callq 0x53c0
jmp 0x6421
xorl %ebp, %ebp
movq %rsp, %rdi
callq 0x8b4c
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8b4c
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O2/EDDRSoftware[P]libdefsEval/main.cpp
// Function: fullPath(char const*, boost::filesystem::path const&, boost::filesystem::path*)
int fullPath(const char *pathIn, const path &base, path *outPath)
{
    int retVal = 0;


    try {

        *outPath = canonical(pathIn, base);

    } catch(const filesystem_error &error) {
        if(is_symlink(error.path1())) {
            cerr << "ERROR: Path " << error.path1() << " contains a broken symlink." <<
                 endl;
        } else {
            cerr << "ERROR: " << error.code().message() << " " << error.path1() << endl;
        }

        retVal = error.code().value();
    }

    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq -0x50(%rbp), %rdi
callq 0x5f52
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %r14, %rdx
callq 0x5f38
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4360
movq %r14, %rdi
callq 0x4150
leaq -0x50(%rbp), %rdi
callq 0x4150
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4150
jmp 0x477e
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x4877
movq %rbx, %rdi
callq 0x4110
movq %rax, %rbx
movq %rax, %rdi
callq 0x5f8e
movq %rax, %rdi
callq 0x5f69
testb %al, %al
je 0x47e9
movq 0x9842(%rip), %rdi      # 0xdff0
leaq 0x484f(%rip), %rsi      # 0x9004
callq 0x42d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5f8e
movq %r14, %rdi
movq %rax, %rsi
callq 0x5fac
leaq 0x483a(%rip), %rsi      # 0x9011
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
callq 0x4170
jmp 0x4852
movq 0x9800(%rip), %rdi      # 0xdff0
leaq 0x4836(%rip), %rsi      # 0x902d
callq 0x42d0
movq %rax, %r14
movl 0x10(%rbx), %edx
movq 0x18(%rbx), %rsi
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x20(%rax)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x42a0
leaq 0x48c0(%rip), %rsi      # 0x90e3
movq %rax, %rdi
callq 0x42d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5f8e
movq %r14, %rdi
movq %rax, %rsi
callq 0x5fac
movq %rax, %rdi
callq 0x4170
leaq -0x30(%rbp), %rdi
callq 0x4150
movl 0x10(%rbx), %ebx
callq 0x4460
jmp 0x475c
jmp 0x486f
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4150
jmp 0x4872
movq %rax, %rbx
callq 0x4460
movq %rbx, %rdi
callq 0x44c0
movq %rax, %rdi
callq 0x5ee8
// File: /workspace/github_cpp_makefile_star2_O2/EDDRSoftware[P]libdefsEval/main.cpp
// Function: readUntilEOL(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void readUntilEOL(stringstream *stream, string *outVar)
{
    string buffer;

    getline(*stream, buffer);
    // getline does not trim the beginning of line.  There is usually whitespace.
    buffer.erase(buffer.begin(), find_if(buffer.begin(), buffer.end(),
                                         not1(ptr_fun<int, int>(isspace))));
    *outVar = buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x30(%rbp), %rsi
callq 0x4050
movq -0x30(%rbp), %r14
movq -0x28(%rbp), %rsi
addq %r14, %rsi
movq 0x94c9(%rip), %rdx      # 0xdf98
movq %r14, %rdi
callq 0x6cd4
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4060
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x41b0
leaq -0x30(%rbp), %rdi
callq 0x4150
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4b06
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O2/EDDRSoftware[P]libdefsEval/main.cpp
// Function: isRecursiveInclude(boost::filesystem::path const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
bool
isRecursiveInclude(const path &fp, std::vector<string> *pLibDefFiles)
{
    for (int i = 0; i < pLibDefFiles->size(); ++i)
    {
        if (fp.string().c_str() == (*pLibDefFiles)[i])
        {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %r15
xorl %r12d, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %r13
subq %rsi, %r13
sarq $0x5, %r13
incq %r15
cmpq %r15, %r13
jbe 0x5199
movq (%r14), %rdi
addq %r12, %rsi
addq $0x20, %r12
callq 0x60ea
testb %al, %al
je 0x5170
cmpq %r15, %r13
seta %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/examples/user-types-ex02.cxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, B*, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(B*&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(B*& t, II& i, II e, Cx& cx) {
                    if (!cio::consume<Y>(i, e, cx)) // consume any white-spaces
                        return false;
                    if (cio::peek(i, e) == *Y::id::nil) // check/read null
                        return read_value<Y>(t, i, e, cx);
                    B_union p; // the union type that represents a B*
                        if (read_value<Y>(p, i, e, cx)) { // try reading it
                            if (p.d1) // let d1 != 0 indicates D1
                                return (t = alc::make_in_context<D1>(cx, p.d1)); // create and assign D1
                            // create and assign D2
                            return (t = alc::make_in_context<D2>(cx, std::move(p.d2)));
                        }
                        return false;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %r13, %rdi
movq %r12, %rsi
callq 0x2b4b
movq (%r13), %rax
cmpq %r12, %rax
je 0x2c47
cmpb $0x6e, (%rax)
je 0x2c2e
leaq 0x8(%rsp), %rbx
andl $0x0, -0x8(%rbx)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2ce8
testb %al, %al
je 0x2c89
cmpl $0x0, (%rsp)
je 0x2c8d
movq %rsp, %rsi
movq %r15, %rdi
callq 0x2cce
jmp 0x2c98
xorl %ebp, %ebp
jmp 0x2ca2
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2cdb
movq %rax, (%r14)
testq %rax, %rax
setne %bpl
movq %rbx, %rdi
callq 0x20c0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/examples/user-types-ex02.cxx
// Function: bool cxon::write<cxon::JSON<cxon::json::format_traits>, B*, void>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, B const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(O& o, const B* t, Cx& cx) {
                    if (!t) // check/write null
                            return write_value<Y>(o, nullptr, cx);
                    // cast and write the runtime type
                    switch (t->type) {
                        case B::D1:
                            return write_value<Y>(o, static_cast<const D1*>(t), cx);
                        case B::D2:
                            return write_value<Y>(o, static_cast<const D2*>(t), cx);
                    }
                    return false;
                }

// Assembly:
testq %rsi, %rsi
je 0x3ec0
movl 0x8(%rsi), %eax
cmpl $0x1, %eax
je 0x40dc
testl %eax, %eax
je 0x3ed8
xorl %eax, %eax
retq
pushq %rax
leaq 0x1501(%rip), %rsi      # 0x53c9
pushq $0x4
popq %rdx
callq 0x2040
movb $0x1, %al
addq $0x8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/lambda.cc
// Function: fcn3()
void fcn3()
{
    size_t v1 = 42;  // local variable
    // error: cannot assign to a variable captured by copy in a non-mutable lambda
    // auto f = [v1] () { return ++v1; };
    // f can change the value of the variables it captures
    auto f = [v1] () mutable { return ++v1; };
    v1 = 0;
    auto j = f(); // j is 43
    auto k = f(); // k is 44
    cout << v1 << endl;
    cout << j << endl;
    cout << k << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x2dd8(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1040
movq %rax, %rdi
callq 0x1030
pushq $0x2b
popq %rsi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1030
pushq $0x2c
popq %rsi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/lambda.cc
// Function: fcn5()
void fcn5()
{
    size_t v1 = 42;
    // p is a const pointer to v1
    size_t* const p = &v1;
    // increments v1, the objet to which p points
    auto f = [p]() { return ++*p; };
    auto j = f();  // returns incremented value of *p
    cout << v1 << " " << j << endl; // prints 43 43
    v1 = 0;
    j = f();       // returns incremented value of *p
    cout << v1 << " " << j << endl; // prints 1 1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2d6d(%rip), %rbx      # 0x3fd8
pushq $0x2b
popq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1040
leaq 0xd83(%rip), %r15       # 0x2004
movq %rax, %rdi
movq %r15, %rsi
callq 0x1060
movq %rax, %rdi
movq %r14, %rsi
callq 0x1040
movq %rax, %rdi
callq 0x1030
pushq $0x1
popq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1040
movq %rax, %rdi
movq %r15, %rsi
callq 0x1060
movq %rax, %rdi
movq %r14, %rsi
callq 0x1040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/lambda.cc
// Function: main
int main()
{
    fcn1();
    fcn2();
    fcn3();
    fcn4();
    fcn5();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x11bc
callq 0x11d8
callq 0x11f3
callq 0x123e
callq 0x125a
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/PrzemekWirkus[P]functional-workshop/src/examples.cpp
// Function: void bubble_sort<int, absoluteLess>(int*, int, absoluteLess const&)
void bubble_sort(T* _array, int Count, const CompareType& Compare) {
	for(int i = 0; i < Count; ++i) {
		for(int j = i + 1; j < Count; ++j) {
            // functor call
            if (Compare(_array[i], _array[j])) {
                // exchange of two elements
                const T temp = _array[i];
                _array[i] = _array[j];
                _array[j] = temp;
            }
        }
	}
}

// Assembly:
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
movabsq $0x1, %rdx
cmpq %rcx, %rax
je 0x1cc9
movq %rdx, %r8
cmpl %esi, %r8d
jge 0x1cc1
movl (%rdi,%rax,4), %r9d
movl (%rdi,%r8,4), %r10d
movl %r9d, %r11d
negl %r11d
cmovsl %r9d, %r11d
movl %r10d, %ebx
negl %ebx
cmovsl %r10d, %ebx
cmpl %ebx, %r11d
jae 0x1cbc
movl %r10d, (%rdi,%rax,4)
movl %r9d, (%rdi,%r8,4)
incq %r8
jmp 0x1c8f
incq %rax
incq %rdx
jmp 0x1c87
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/aes_dec.cpp
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 3)
	{
		printf("Usage:\taes_dec 256bit_key 128bit_iv plaintext\r\n");
		printf("Example:\taes_dec 01234567890123456789012345678901 0123456789012345 file.enc\r\n");
		return -1;
	}

	/* A 256 bit key */
	unsigned char *key = (unsigned char *)argv[1];

	/* A 128 bit IV */
	unsigned char *iv = (unsigned char *)argv[2];

	/* Message to be encrypted */
	char *filename = (char *)argv[3];
	unsigned int size = 0;
	unsigned char *ciphertext = (unsigned char *)get_file(filename, &size);

	/* Buffer for the decrypted text */
	unsigned char *decryptedtext = (unsigned char *)malloc(size);
	if (decryptedtext == NULL)
	{
		perror("malloc failed");
		return -1;
	}

	int decryptedtext_len, ciphertext_len = size;

	printf("Ciphertext is:\n");
	BIO_dump_fp (stdout, (const char *)ciphertext, ciphertext_len);

	/* Decrypt the ciphertext */
	decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv, decryptedtext);

	/* Add a NULL terminator. We are expecting printable text */
	decryptedtext[decryptedtext_len] = '\0';

	/* Show the decrypted text */
	printf("Decrypted text is:\n");
	printf("%s\n", decryptedtext);
	
	write_file((char *)"file.txt", (char *)decryptedtext, decryptedtext_len);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jg 0x13f6
leaq 0xca2(%rip), %rdi       # 0x207f
callq 0x1170
leaq 0xcc5(%rip), %rdi       # 0x20ae
callq 0x1170
pushq $-0x1
popq %rax
jmp 0x148c
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rdi
leaq -0x2c(%rbp), %rbx
andl $0x0, (%rbx)
movq %rbx, %rsi
callq 0x129c
movq %rax, %r12
movl (%rbx), %r13d
movq %r13, %rdi
callq 0x1150
testq %rax, %rax
je 0x149b
movq %rax, %rbx
leaq 0xc2f(%rip), %rdi       # 0x205d
callq 0x1170
movq 0x2b8e(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0x10b0
movq %r12, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x14ac
movslq %eax, %r14
movb $0x0, (%rbx,%r14)
leaq 0xc01(%rip), %rdi       # 0x206c
callq 0x1170
movq %rbx, %rdi
callq 0x1170
leaq 0xbb9(%rip), %rdi       # 0x2038
movq %rbx, %rsi
movl %r14d, %edx
callq 0x134a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb88(%rip), %rdi       # 0x202a
callq 0x10f0
jmp 0x13ee
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/aes_dec.cpp
// Function: decrypt(unsigned char*, int, unsigned char*, unsigned char*, unsigned char*)
int decrypt(unsigned char *ciphertext, int ciphertext_len, unsigned char *key,
			unsigned char *iv, unsigned char *plaintext)
{
	EVP_CIPHER_CTX *ctx;

	int len;

	int plaintext_len;

	/* Create and initialise the context */
	if(!(ctx = EVP_CIPHER_CTX_new()))
		handleErrors();

	/*
	 * Initialise the decryption operation. IMPORTANT - ensure you use a key
	 * and IV size appropriate for your cipher
	 * In this example we are using 256 bit AES (i.e. a 256 bit key). The
	 * IV size for *most* modes is the same as the block size. For AES this
	 * is 128 bits
	 */
	if(1 != EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
		handleErrors();

	/*
	 * Provide the message to be decrypted, and obtain the plaintext output.
	 * EVP_DecryptUpdate can be called multiple times if necessary.
	 */
	if(1 != EVP_DecryptUpdate(ctx, plaintext, &len, ciphertext, ciphertext_len))
		handleErrors();
	plaintext_len = len;

	/*
	 * Finalise the decryption. Further plaintext bytes may be written at
	 * this stage.
	 */
	if(1 != EVP_DecryptFinal_ex(ctx, plaintext + len, &len))
		handleErrors();
	plaintext_len += len;

	/* Clean up */
	EVP_CIPHER_CTX_free(ctx);

	return plaintext_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movl %esi, -0x30(%rbp)
movq %rdi, %r12
callq 0x10e0
testq %rax, %rax
je 0x1546
movq %rax, %rbx
callq 0x10d0
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r15, %rcx
movq %r13, %r8
callq 0x1060
cmpl $0x1, %eax
jne 0x1546
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
movl -0x30(%rbp), %r8d
callq 0x10c0
cmpl $0x1, %eax
jne 0x1546
leaq -0x2c(%rbp), %rdx
movslq (%rdx), %r15
addq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1070
cmpl $0x1, %eax
jne 0x1546
addl -0x2c(%rbp), %r15d
movq %rbx, %rdi
callq 0x1110
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x154b
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/aes_dec.cpp
// Function: encrypt(unsigned char*, int, unsigned char*, unsigned char*, unsigned char*)
int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
			unsigned char *iv, unsigned char *ciphertext)
{
	EVP_CIPHER_CTX *ctx;

	int len;

	int ciphertext_len;

	/* Create and initialise the context */
	if(!(ctx = EVP_CIPHER_CTX_new()))
		handleErrors();

	/*
	 * Initialise the encryption operation. IMPORTANT - ensure you use a key
	 * and IV size appropriate for your cipher
	 * In this example we are using 256 bit AES (i.e. a 256 bit key). The
	 * IV size for *most* modes is the same as the block size. For AES this
	 * is 128 bits
	 */
	if(1 != EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
		handleErrors();

	/*
	 * Provide the message to be encrypted, and obtain the encrypted output.
	 * EVP_EncryptUpdate can be called multiple times if necessary
	 */
	if(1 != EVP_EncryptUpdate(ctx, ciphertext, &len, plaintext, plaintext_len))
		handleErrors();
	ciphertext_len = len;

	/*
	 * Finalise the encryption. Further ciphertext bytes may be written at
	 * this stage.
	 */
	if(1 != EVP_EncryptFinal_ex(ctx, ciphertext + len, &len))
		handleErrors();
	ciphertext_len += len;

	/* Clean up */
	EVP_CIPHER_CTX_free(ctx);

	return ciphertext_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movl %esi, -0x30(%rbp)
movq %rdi, %r12
callq 0x10e0
testq %rax, %rax
je 0x15fd
movq %rax, %rbx
callq 0x10d0
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r15, %rcx
movq %r13, %r8
callq 0x10a0
cmpl $0x1, %eax
jne 0x15fd
leaq -0x2c(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
movl -0x30(%rbp), %r8d
callq 0x1050
cmpl $0x1, %eax
jne 0x15fd
leaq -0x2c(%rbp), %rdx
movslq (%rdx), %r15
addq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1180
cmpl $0x1, %eax
jne 0x15fd
addl -0x2c(%rbp), %r15d
movq %rbx, %rdi
callq 0x1110
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x154b
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::altitude_with_variation(double, double)
Air Air::altitude_with_variation(double altitude, double input_percent){
    // Pseudo constructor.
    // Enter altitude and variation ratio air density with altitude to calculate air density
    Air air = Air::altitude(altitude);
    double coef = Air::coef_density_variance(altitude, input_percent);
    air.density = air.density * (1.0 + coef);
    return air;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x597c
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x5bf2
addsd 0x19488(%rip), %xmm0    # 0x1f060
mulsd 0x118(%rbx), %xmm0
movsd %xmm0, 0x118(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::altitude_with_variation_table(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
Air Air::altitude_with_variation_table(double altitude, MatrixXd variation_table){
    // Pseudo constructor.
    // Enter altitude and variation ratio air density table to calculate air density
    Air air = Air::altitude(altitude);
    double coef = Air::coef_density_variance_table(altitude, variation_table);
    air.density = air.density * (1.0 + coef);
    return air;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x597c
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x643a
movsd (%rsp), %xmm0
movq %r15, %rsi
callq 0x5ea8
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x5430
movsd (%rsp), %xmm0
addsd 0x191ea(%rip), %xmm0    # 0x1f060
mulsd 0x118(%rbx), %xmm0
movsd %xmm0, 0x118(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x5430
movq %rbx, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::coef_density_variance_table(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
double Air::coef_density_variance_table(double altitude, MatrixXd variation_table){
    // variation table : [altitude[m], air density variation[percent]
    vector<double> altitude_ref;
    vector<double> variation_ref;
    int len = variation_table.rows();

    altitude_ref.resize(len);
    variation_ref.resize(len);

    for(int i=0; i<len; i++){
        altitude_ref[i] = variation_table(i, 0);
        variation_ref[i] = variation_table(i, 1);
    }
    
    double percent_of_density_with_alt = linear_interp1_from_y(altitude, variation_ref, altitude_ref);

    return percent_of_density_with_alt / 100;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rsp)
movaps %xmm0, (%rdi)
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rsi), %r12
movslq %r12d, %r14
movq %r14, %rsi
callq 0x6516
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x6516
xorl %r14d, %r14d
testl %r12d, %r12d
cmovlel %r14d, %r12d
pushq $0x1
popq %r15
cmpq %r14, %r12
je 0x5f44
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6548
movsd (%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax,%r14,8)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6548
movsd (%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x5f01
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x64c8
leaq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x64c8
leaq 0x48(%rsp), %rbx
leaq 0x60(%rsp), %r14
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5fff
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x6870
movq %rbx, %rdi
callq 0x6870
movsd 0x8(%rsp), %xmm0
divsd 0x190c7(%rip), %xmm0    # 0x1f068
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6870
leaq 0x30(%rsp), %rdi
callq 0x6870
movsd 0x8(%rsp), %xmm0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6870
jmp 0x5fe3
jmp 0x5fe0
jmp 0x5fe0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6870
leaq 0x30(%rsp), %rdi
callq 0x6870
movq %rbx, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: linear_interp1_from_y(double, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
double linear_interp1_from_y(double y, vector<double> x_array, vector<double> y_array){
    // linear interpolattion with same number of x_array and y_array from y-axis
    // not extrapolation, It has the same value as the outermost point.
    // @params y: y component of the data you want to obtain
    // @params x_array The x component of the original data
    // @params y_array The x component of the original data
    // @return x(double) interpolated value
    double x = 0.0;
    double alpha = 0.0;
    for (int i = 0; i < y_array.size()-1; i++) {
        if (y >= y_array[i] && y < y_array[i+1]) {
            alpha = (y - y_array[i]) / (y_array[i+1] - y_array[i]);
            x = x_array[i] + alpha * (x_array[i+1] - x_array[i]);
        }
    }
    if (y < y_array[0]) {
        x = x_array[0];
    }else if (y >= y_array.back()){
        x = x_array.back();
    }
    return x;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorpd %xmm1, %xmm1
xorl %esi, %esi
incq %rsi
cmpq %rsi, %rdx
je 0x6063
movsd -0x8(%rcx,%rsi,8), %xmm2
ucomisd %xmm2, %xmm0
jb 0x6016
movsd (%rcx,%rsi,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0x6016
movapd %xmm0, %xmm4
subsd %xmm2, %xmm4
subsd %xmm2, %xmm3
divsd %xmm3, %xmm4
movq (%rdi), %r8
movsd -0x8(%r8,%rsi,8), %xmm2
movsd (%r8,%rsi,8), %xmm1
subsd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
jmp 0x6016
movsd (%rcx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x6072
movq (%rdi), %rax
jmp 0x6081
ucomisd -0x8(%rax), %xmm0
jb 0x6085
movq 0x8(%rdi), %rax
addq $-0x8, %rax
movsd (%rax), %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/util/Memory.h
// Function: double* Eigen::internal::conditional_aligned_new_auto<double, true>(unsigned long)
inline T* conditional_aligned_new_auto(size_t size)
{
  if(size==0)
    return 0; // short-cut. Also fixes Bug 884
  check_size_for_overflow<T>(size);
  T *result = reinterpret_cast<T*>(conditional_aligned_malloc<Align>(sizeof(T)*size));
  if(NumTraits<T>::RequireInitialization)
    construct_elements_of_array(result, size);
  return result;
}

// Assembly:
testq %rdi, %rdi
je 0x65c9
pushq %rbx
movq %rdi, %rbx
movq %rdi, %rax
shrq $0x3d, %rax
je 0x65bc
callq 0x65cc
shlq $0x3, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x65f9
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/PlainObjectBase.h
// Function: Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::resize(long, long)
EIGEN_STRONG_INLINE void resize(Index nbRows, Index nbCols)
    {
      eigen_assert(   EIGEN_IMPLIES(RowsAtCompileTime!=Dynamic,nbRows==RowsAtCompileTime)
                   && EIGEN_IMPLIES(ColsAtCompileTime!=Dynamic,nbCols==ColsAtCompileTime)
                   && EIGEN_IMPLIES(RowsAtCompileTime==Dynamic && MaxRowsAtCompileTime!=Dynamic,nbRows<=MaxRowsAtCompileTime)
                   && EIGEN_IMPLIES(ColsAtCompileTime==Dynamic && MaxColsAtCompileTime!=Dynamic,nbCols<=MaxColsAtCompileTime)
                   && nbRows>=0 && nbCols>=0 && "Invalid sizes when resizing a matrix or array.");
      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(nbRows, nbCols);
      #ifdef EIGEN_INITIALIZE_COEFFS
        Index size = nbRows*nbCols;
        bool size_changed = size != this->size();
        m_storage.resize(size, nbRows, nbCols);
        if(size_changed) EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
      #else
        internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(nbRows, nbCols);
        m_storage.resize(nbRows*nbCols, nbRows, nbCols);
      #endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rax
orq %rsi, %rax
js 0x6742
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x6728
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rbx
cmpq %r14, %rax
jge 0x6728
callq 0x65cc
callq 0x65cc
movq %rbx, %rsi
imulq %r14, %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x6762
leaq 0x18c15(%rip), %rdi     # 0x1f35e
leaq 0x18da9(%rip), %rsi     # 0x1f4f9
leaq 0x18dce(%rip), %rcx     # 0x1f525
movl $0xf1, %edx
callq 0x5250
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long)
void resize(DenseIndex size, DenseIndex nbRows, DenseIndex nbCols)
    {
      if(size != m_rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
      }
      m_rows = nbRows;
      m_cols = nbCols;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x67a0
movq %rsi, %r12
movq (%r15), %rdi
callq 0x5430
testq %r12, %r12
je 0x679b
movq %r12, %rdi
callq 0x65a5
jmp 0x679d
xorl %eax, %eax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %rbx, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/main.cpp
// Function: main
int main(int argc, const char * argv[]) {
    std::chrono::system_clock::time_point  start, end; // calcuration time measurement
    start = std::chrono::system_clock::now(); // mesurement start time
    
    std::cout << "Hello, OpenTsiolkovsky! version:" + current_version + "\n";

    string input_file_name;
    string input_file_default = "param_sample.json";
    if (argc == 1) {
        input_file_name = input_file_default;
    } else if (argc == 2) {
        input_file_name = argv[1];
    } else {
        cout << "argument error";
        return 1;
    }

    Rocket rocket(input_file_name);
    rocket.flight_simulation();
    
    end = std::chrono::system_clock::now();  // mesurement end time
    double elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
    std::cout << "Processing time: " << elapsed << "[ms]\n" << std::endl;
    
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movl %edi, %ebp
callq 0x5070
movq %rax, %rbx
leaq 0x18d64(%rip), %rsi     # 0x1f825
leaq 0x288f8(%rip), %rdx     # 0x2f3c0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6cd8
leaq 0x19fc1(%rip), %rdx     # 0x20a9d
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x6cb9
movq 0x284c0(%rip), %rdi     # 0x2efb0
leaq 0x28(%rsp), %rsi
callq 0x5340
leaq 0x28(%rsp), %rdi
callq 0x56e8
leaq 0x8(%rsp), %rdi
callq 0x56e8
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x18d20(%rip), %rsi     # 0x1f846
leaq 0x78(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x6c7e
cmpl $0x2, %ebp
je 0x6b54
cmpl $0x1, %ebp
jne 0x6bf1
leaq 0x8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x5210
jmp 0x6b62
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x56a0
leaq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x54c0
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x77d0
leaq 0x58(%rsp), %rdi
callq 0x56e8
leaq 0x28(%rsp), %rdi
callq 0xb4a0
callq 0x5070
movq %rax, %r14
movq 0x2840d(%rip), %rdi     # 0x2efb0
leaq 0x18cbd(%rip), %rsi     # 0x1f867
callq 0x5370
movq %rax, %rdi
subq %rbx, %r14
movl $0xf4240, %ecx          # imm = 0xF4240
movq %r14, %rax
cqto
idivq %rcx
cvtsi2sd %rax, %xmm0
callq 0x5570
leaq 0x18ca6(%rip), %rsi     # 0x1f879
movq %rax, %rdi
callq 0x5370
movq %rax, %rdi
callq 0x51b0
leaq 0x28(%rsp), %rdi
callq 0x6d4e
xorl %ebx, %ebx
jmp 0x6c07
movq 0x283b8(%rip), %rdi     # 0x2efb0
leaq 0x18c59(%rip), %rsi     # 0x1f858
callq 0x5370
pushq $0x1
popq %rbx
leaq 0x78(%rsp), %rdi
callq 0x56e8
leaq 0x8(%rsp), %rdi
callq 0x56e8
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6c54
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x56e8
jmp 0x6c61
jmp 0x6c3e
movq %rax, %rbx
jmp 0x6c61
jmp 0x6c4f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x6c66
movq %rax, %rbx
jmp 0x6c6b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6d4e
leaq 0x78(%rsp), %rdi
callq 0x56e8
leaq 0x8(%rsp), %rdi
callq 0x56e8
movq %rbx, %rdi
callq 0x5640
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::value::~value()
inline value::~value() {
    switch (type_) {
#define DEINIT(p) case p##type: delete u_.p; break
      DEINIT(string_);
      DEINIT(array_);
      DEINIT(object_);
#undef DEINIT
    default: break;
    }
  }

// Assembly:
pushq %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
je 0x6ff0
cmpl $0x4, %eax
je 0x6fdb
cmpl $0x3, %eax
jne 0x700d
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x6fd7
movq %rbx, %rdi
callq 0x56e8
pushq $0x20
jmp 0x7003
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x6fec
movq %rbx, %rdi
callq 0x7010
pushq $0x18
jmp 0x7003
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x7001
movq %rbx, %rdi
callq 0x6f3a
pushq $0x30
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x53a0
popq %rbx
retq
nop