LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ctz[P]openssl-bench/bench.cc
// Function: Conn::get_session()
SSL_SESSION *get_session() {
    ragged_close();
    if (m_one_session) {
      SSL_SESSION_up_ref(m_one_session);
      return m_one_session;
    }
    return SSL_get1_session(m_ssl);
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x3, %esi
callq 0x3080
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x6609
callq 0x3090
movq 0x30(%rbx), %rax
popq %rbx
retq
movq (%rbx), %rdi
popq %rbx
jmp 0x3510
// File: /workspace/github_cpp_makefile_star2_O3/ctz[P]openssl-bench/bench.cc
// Function: Conn::Conn(Conn&&)
Conn(Conn &&other)
      : m_ssl(other.m_ssl), m_reads_from(nullptr),
        m_writes_to(other.m_writes_to), m_one_session(other.m_one_session) {
    SSL_set_app_data(m_ssl, this);
    other.m_ssl = nullptr;
    m_read_buffer.swap(other.m_read_buffer);
    install_read_bio();
    other.m_writes_to = nullptr;
    other.m_one_session = nullptr;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rdi, (%rbx)
leaq 0x8(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups 0x28(%rsi), %xmm0
movups %xmm0, 0x28(%rbx)
xorl %esi, %esi
movq %rbx, %rdx
callq 0x30b0
movq $0x0, (%r14)
movq 0x18(%rbx), %rax
movq 0x18(%r14), %rcx
movq %rcx, 0x18(%rbx)
movups 0x8(%rbx), %xmm0
movups 0x8(%r14), %xmm1
movups %xmm1, 0x8(%rbx)
movups %xmm0, 0x8(%r14)
movq %rax, 0x18(%r14)
movq %rbx, %rdi
callq 0x5f82
addq $0x28, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x6ab9
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x32c0
movq %r14, %rdi
callq 0x34c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kodejuice[P]chip8-emulator/./chip8.cc
// Function: Chip8::load_program(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Chip8::load_program(string file) {
	FILE *f = fopen(file.c_str(), "rb");

	if (f == NULL) 
		return printf("Error: Couldn't open '%s'\n", file.c_str()), false;

	// get file size
	fseek(f, 0L, SEEK_END);
	program_size = ftell(f);
	fseek(f, 0L, SEEK_SET);

	// allocate memory for ROM (buffer)
	byte* rom = (byte*) malloc(sizeof(byte) * program_size);

	// read program into buffer
	fread(rom, sizeof(byte), program_size, f);

	// load program from buffer into memory
	for (int i=PC, j=0; i < int(PC + program_size); ++i, ++j) {
		memory[i] = rom[j];
	}

	free(rom);
	fclose(f);

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rdi
leaq 0x2bce(%rip), %rsi      # 0x5220
callq 0x22c0
movq %rax, %rbx
testq %rax, %rax
je 0x26ff
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2290
movq %rbx, %rdi
callq 0x2030
movq %rax, 0x1028(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2290
movq 0x1028(%r14), %r12
movq %r12, %rdi
callq 0x2300
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2320
movzwl 0x1002(%r14), %eax
movl 0x1028(%r14), %ecx
addl %eax, %ecx
cmpl %ecx, %eax
jge 0x26ed
movq %r15, %rcx
movb (%rcx), %dl
movb %dl, (%r14,%rax)
movzwl 0x1002(%r14), %edx
addl 0x1028(%r14), %edx
incq %rax
movslq %edx, %rdx
incq %rcx
cmpq %rdx, %rax
jl 0x26ca
movq %r15, %rdi
callq 0x22d0
movq %rbx, %rdi
callq 0x2260
jmp 0x2710
movq (%r15), %rsi
leaq 0x2b1a(%rip), %rdi      # 0x5223
xorl %eax, %eax
callq 0x2070
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/kodejuice[P]chip8-emulator/./debug/disassembler.cc
// Function: Chip8::disassemble[abi:cxx11]()
string Chip8::disassemble() {

	byte lsb, msb;
	string str = "";

	for (int i=PC; i < (PC + program_size); i+=2) {
		msb = memory[i], lsb = memory[i+1];

		str += decode(i, msb, lsb) + "\n";
	}

	return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x25d7(%rip), %rdx      # 0x523d
movq %rdx, %rsi
callq 0x4098
movzwl 0x1002(%r14), %r15d
movq 0x1028(%r14), %rax
addq %r15, %rax
cmpq %r15, %rax
jbe 0x2d5e
leaq 0x18(%rsp), %rbp
leaq 0x28(%rsp), %r12
leaq 0x25a2(%rip), %r13      # 0x523c
movzbl (%r14,%r15), %edx
movzbl 0x1(%r14,%r15), %ecx
movq %r12, %rdi
movl %r15d, %esi
callq 0x2dd0
movq %r12, %rdi
movq %r13, %rsi
callq 0x23d0
movq %rbp, 0x8(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2cde
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x2ce5
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2130
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d26
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2280
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2d42
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2280
addq $0x2, %r15
movzwl 0x1002(%r14), %eax
addq 0x1028(%r14), %rax
cmpq %r15, %rax
ja 0x2c9a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2db0
movq %rax, %r14
jmp 0x2d94
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2d94
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2280
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x2db0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2280
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x2dc8
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2280
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O3/kodejuice[P]chip8-emulator/main.cc
// Function: getfilename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string getfilename(const string filepath) {
	string filename = filepath;

	// Remove directory if present.
	// Do this before extension removal incase directory has a period character.
	const size_t last_slash_idx = filename.find_last_of("\\/");
	if (std::string::npos != last_slash_idx)
		filename.erase(0, last_slash_idx + 1);

	// Remove extension if present.
	const size_t period_idx = filename.rfind('.');
	if (std::string::npos != period_idx)
	    filename.erase(period_idx);

	return filename;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4002
leaq 0x1838(%rip), %rsi      # 0x541e
movl $0x2, %ecx
movq %rbx, %rdi
movq $-0x1, %rdx
callq 0x23f0
cmpq $-0x1, %rax
je 0x3c10
incq %rax
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x20e0
movq %rbx, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x23e0
cmpq $-0x1, %rax
je 0x3c3e
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x3c47
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1841(%rip), %rdi      # 0x548f
leaq 0x1826(%rip), %rsi      # 0x547b
movq %rax, %rdx
xorl %eax, %eax
callq 0x2330
jmp 0x3c61
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3c77
movq (%r15), %rsi
incq %rsi
callq 0x2280
movq %r14, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Couragewang[P]50_clss/./TcpServer.hpp
// Function: TcpServer::Service(int)
static void Service(int sock)
        {
            while(1){
                char buf[1024];
                ssize_t s = read(sock, buf, sizeof(buf)-1);
                if(s > 0){
                    buf[s] = 0;
                    auto it = dict.find(buf);
                    if(it == dict.end()){
                        write(sock, "NULL", strlen("NULL"));
                        continue;
                    }
                    write(sock, (it->second).c_str(), (it->second).size());
                }
                else if(s == 0){
                    std::cout << "client quit!" << std::endl;
                    break;
                }
                else{
                    std::cerr << "read error" << std::endl;
                    break;
                }
            }
            close(sock);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x428, %rsp            # imm = 0x428
movl %edi, %ebx
leaq -0x450(%rbp), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x2250
testq %rax, %rax
jle 0x2f08
leaq -0x38(%rbp), %r12
leaq -0x450(%rbp), %r14
leaq -0x48(%rbp), %r15
movb $0x0, -0x450(%rbp,%rax)
movq %r12, -0x48(%rbp)
movq %r14, %rdi
callq 0x20f0
leaq (%rax,%rbp), %rdx
addq $-0x450, %rdx           # imm = 0xFBB0
movq %r15, %rdi
movq %r14, %rsi
callq 0x32a6
leaq 0x3324(%rip), %rdi      # 0x61d0
movq %r15, %rsi
callq 0x2ffc
movq %rax, %r13
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2ec5
callq 0x21b0
leaq 0x330c(%rip), %rax      # 0x61d8
cmpq %rax, %r13
je 0x2edd
movq 0x40(%r13), %rsi
movq 0x48(%r13), %rdx
movl %ebx, %edi
jmp 0x2eeb
movl $0x4, %edx
movl %ebx, %edi
leaq 0x11a0(%rip), %rsi      # 0x408b
callq 0x20b0
movl $0x3ff, %edx            # imm = 0x3FF
movl %ebx, %edi
movq %r14, %rsi
callq 0x2250
testq %rax, %rax
jg 0x2e7b
testq %rax, %rax
je 0x2f22
movq 0x30dc(%rip), %r14      # 0x5ff0
leaq 0x1182(%rip), %rsi      # 0x409d
movl $0xa, %edx
jmp 0x2f35
movq 0x30a7(%rip), %r14      # 0x5fd0
leaq 0x1160(%rip), %rsi      # 0x4090
movl $0xc, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
movl %ebx, %edi
callq 0x2340
addq $0x428, %rsp            # imm = 0x428
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2f8e
callq 0x21b0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/Couragewang[P]50_clss/./ThreadPool.hpp
// Function: ThreadPool::PushTask(Task const&)
void PushTask(const Task &t)
        {
            LockQueue();
            task_queue.push(t);
            WakeupOneThread();
            UnlockQueue();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x58(%rdi), %rbx
movq %rbx, %rdi
callq 0x2270
movq 0x38(%r14), %rax
movq 0x48(%r14), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
je 0x2fd1
movups (%r15), %xmm0
movups %xmm0, (%rax)
addq $0x10, 0x38(%r14)
jmp 0x2fdd
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x309a
subq $-0x80, %r14
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O3/salleaffaire[P]MXFParser/bit_extractor.cpp
// Function: operator<<(std::ostream&, bit_code)
std::ostream& operator<<(std::ostream& os, const bit_code bc) {
   
   unsigned int n    = bc.mSize;
   unsigned int mask = 1 << (n-1);
      
   os << "0b";
   while (n) {
      if (bc.mValue & mask) {
         os << "1";
      }
      else {
         os << "0";
      }
      mask >>= 1;
      --n;
   }
   
   return os;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x49f0(%rip), %rsi      # 0x7004
movl $0x2, %edx
callq 0x21a0
movq %r14, %r15
shrq $0x20, %r15
je 0x265f
movl %r15d, %ecx
decb %cl
movl $0x1, %ebp
shll %cl, %ebp
leaq 0x49cf(%rip), %r12      # 0x7009
leaq 0x49c6(%rip), %r13      # 0x7007
testl %r14d, %ebp
movq %r13, %rsi
cmoveq %r12, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21a0
shrl %ebp
decl %r15d
jne 0x2641
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/salleaffaire[P]MXFParser/hex_out.cpp
// Function: hex_bulk_output(std::ostream&, int, unsigned char*, unsigned long)
void hex_bulk_output(std::ostream &os, const int width, uint8_t *p, size_t size) {
   int column = 0;
   for (uint32_t i=0;i<size;++i) {
      os << std::hex << std::setw(2) << std::setfill('0') << (uint32_t)p[i] << " ";
      
      if (width == ++column) {
         os << std::endl;
         column = 0;
      }
   }
   os << std::endl;
 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, %rbx
testq %rcx, %rcx
je 0x275e
movq %rcx, %r14
xorl %ebp, %ebp
movl $0x1, %r12d
xorl %r15d, %r15d
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rcx
movq $0x2, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r13
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x26ee
movq %r13, %rdi
movl $0x20, %esi
callq 0x2150
movb $0x1, 0xe1(%r13)
movb $0x30, 0xe0(%r13)
movq 0x10(%rsp), %rax
movzbl (%rax,%rbp), %esi
movq %rbx, %rdi
callq 0x20d0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4e12(%rip), %rsi      # 0x7528
callq 0x21a0
incl %r15d
cmpl 0xc(%rsp), %r15d
jne 0x274f
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
xorl %r15d, %r15d
movl %r12d, %ebp
incl %r12d
cmpq %r14, %rbp
jb 0x26a5
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/salleaffaire[P]MXFParser/klv.cpp
// Function: klv_item::parse_value()
bool klv_item::parse_value() {
   int rval = 0;

   switch (mKey[4]) {
   case KLV_RC_DICTIONARY:
      break;
   case KLV_RC_GROUP:
      if (mKey[5] == KLV_GROUP_UNIVERSAL_SET) {
         if (mKLVList) {
            delete mKLVList;
         }

         mKLVList = new std::list<std::shared_ptr<klv_item>>;
         
         // Initialize Bit Extractor
         bit_extractor be(mValue, mLength, BE_BIG_ENDIAN);
         // Need a KLV parser instance
         klv_parser klvp;
         
         klvp.set_verbosity(true);
         klvp.set_validation(true);
         
         bool klv_ret_val;
         do {
            auto p_klvi = std::shared_ptr<klv_item>(new klv_item);
            klv_ret_val = klvp.get_klv_item(*p_klvi, be);
            if (klv_ret_val) {
               mKLVList->push_back(p_klvi);
            }
            std::cout << "    Bytes left: " << be.get_bytes_left() << std::endl;
         } while (true == klv_ret_val);
      }
      else if (mKey[6] == KLV_GROUP_GLOBAL_SET) {
         
      }
      else if (mKey[6] == KLV_GROUP_LOCAL_SET) {
         
      }
      else if (mKey[6] == KLV_GROUP_VARIABLE_LENGTH_PACK) {
         
      }
      else if (mKey[6] == KLV_GROUP_FIXED_LENGTH_PACK) {
         
      }
      break;
   case KLV_RC_WRAPPER:
      break;           
   case KLV_RC_LABEL:
      break;            
   }
   
   return rval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpb $0x2, 0x4(%rdi)
jne 0x291a
movq %rdi, %rbx
cmpb $0x1, 0x5(%rdi)
jne 0x291a
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x280b
movq %r14, %rdi
callq 0x3ae4
movl $0x18, %esi
movq %r14, %rdi
callq 0x2170
movl $0x18, %edi
callq 0x2160
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
movl 0x10(%rbx), %ecx
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movl %ecx, 0x8(%r14)
movb $0x0, 0xc(%r14)
movl $0x0, 0x10(%r14)
movb $0x1, 0x14(%r14)
movq 0x7784(%rip), %r13      # 0x9fd8
leaq 0x47b0(%rip), %rbp      # 0x700b
movl $0x28, %edi
callq 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movups %xmm0, 0x18(%rax)
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3c52
movq (%rsp), %rsi
movq %r14, %rdx
callq 0x2952
movl %eax, %r12d
testb %al, %al
je 0x28b8
movq 0x20(%rbx), %r15
movq %r15, %rdi
movq %rsp, %rsi
callq 0x3d0e
movq %rax, %rdi
movq %r15, %rsi
callq 0x2050
incq 0x10(%r15)
movl $0x10, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x21a0
movl 0x18(%rsp), %esi
subl 0x20(%rsp), %esi
movq %r13, %rdi
callq 0x20d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2911
callq 0x3b2c
testb %r12b, %r12b
jne 0x285b
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x293d
callq 0x3b2c
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/salleaffaire[P]MXFParser/./bit_extractor.hpp
// Function: bit_extractor::show_bits(unsigned char)
unsigned int show_bits(unsigned char n) {
      unsigned int rval = 0;

      unsigned char *p = mBuffer + mContextBytePos; 
      
      const unsigned char comp_bit_pos = 8 - mContextBitPos;


      rval |= ((unsigned int)*p++ >> mContextBitPos);
      //std::cout << "R0: " << std::hex << rval << std::endl;
      rval |= ((unsigned int)*p++ << comp_bit_pos);
      //std::cout << "R1: " << std::hex << rval << std::endl;
      rval |= ((unsigned int)*p++ << (comp_bit_pos+8));
      //std::cout << "R2: " << std::hex << rval << std::endl;
      rval |= ((unsigned int)*p++ << (comp_bit_pos+16));
      //std::cout << "R3: " << std::hex << rval << std::endl;
      
      if (mContextBitPos) {
         rval |= ((unsigned int)*p++ << (comp_bit_pos+24));
         //std::cout << "R4: " << std::hex << rval << std::endl;
      }
      
      unsigned int mask = g_mask[n-1]; 
      
      rval &= mask;

      if (mEndianess) {
         unsigned int temp1 = 0;
         unsigned int temp2 = 0;
         unsigned int temp3 = 0;
         unsigned int temp4 = 0;

         if (n == 16) {
            temp1 = rval >> 8;

            rval = temp1 | ((rval & 0xFF) << 8);
         }
         else if (n == 24) {
            temp1 = rval & 0xFF;     // First byte
            temp2 = rval & 0xFF0000; // Third byte

            rval  = (temp1 << 16) | (rval & 0xFF00) | (temp2 >> 16);  
         }
         else if (n == 32) {
            temp1 = rval & 0xFF;        // First byte
            temp2 = rval & 0xFF00;      // Second byte            
            temp3 = rval & 0xFF0000;    // Third byte
            temp4 = rval & 0xFF000000;  // Fourth byte
            
            rval = (temp1 << 24) | (temp2 << 8) | (temp3 >> 8) | (temp4 >> 24);
         }
      }

      return rval;
   }

// Assembly:
pushq %rbp
pushq %rbx
movq (%rdi), %r9
movl 0x10(%rdi), %r10d
movb 0xc(%rdi), %r8b
movb $0x8, %dl
subb %r8b, %dl
movzbl (%r9,%r10), %r11d
movl %r8d, %ecx
shrl %cl, %r11d
movzbl 0x1(%r9,%r10), %ebx
movl %edx, %ecx
shll %cl, %ebx
movzbl 0x2(%r9,%r10), %ebp
movb $0x10, %cl
subb %r8b, %cl
shll %cl, %ebp
movzbl 0x3(%r9,%r10), %eax
movb $0x18, %cl
subb %r8b, %cl
shll %cl, %eax
orl %r11d, %ebx
orl %ebp, %eax
orl %ebx, %eax
testb %r8b, %r8b
je 0x3bfa
movzbl 0x4(%r9,%r10), %r8d
addb $0x18, %dl
movl %edx, %ecx
shll %cl, %r8d
orl %r8d, %eax
movzbl %sil, %ecx
leaq 0x654b(%rip), %rdx      # 0xa150
andl -0x4(%rdx,%rcx,4), %eax
cmpb $0x1, 0x14(%rdi)
jne 0x3c4f
cmpb $0x20, %sil
je 0x3c4d
cmpl $0x18, %ecx
je 0x3c2e
cmpl $0x10, %ecx
jne 0x3c4f
movl %eax, %ecx
shrl $0x8, %ecx
shll $0x8, %eax
movzwl %ax, %eax
orl %ecx, %eax
jmp 0x3c4f
movl $0xff, %ecx
movl %eax, %edx
andl %ecx, %edx
shll $0x10, %edx
movl %eax, %esi
andl $0xff00, %esi           # imm = 0xFF00
orl %edx, %esi
shrl $0x10, %eax
andl %ecx, %eax
orl %esi, %eax
jmp 0x3c4f
bswapl %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/salleaffaire[P]MXFParser/./mxf_base.hpp
// Function: mxf_file::build_klv_list()
bool build_klv_list() {
      bool rval = true;
      if (m_p_data) {
         // Initialize Bit Extractor
         bit_extractor be(m_p_data, m_file_size, BE_BIG_ENDIAN);
         // Need a KLV parser instance
         klv_parser klvp;

         klvp.set_verbosity(true);
         klvp.set_validation(true);

         bool klv_ret_val;
         do {
            auto p_klvi = std::shared_ptr<klv_item>(new klv_item);
            klv_ret_val = klvp.get_klv_item(*p_klvi, be);
            
            if (klv_ret_val) {
               m_klv_list.push_back(p_klvi);
            }
            //std::cout << "  Bytes left: " << be.get_bytes_left() << std::endl; 
         } while (true == klv_ret_val);
      }
      return rval;
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x1a0(%rdi), %rax
testq %rax, %rax
je 0x4115
movq %rdi, %rbx
movl 0x198(%rdi), %ecx
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
movl %ecx, 0x8(%rdx)
movb $0x0, 0xc(%rdx)
movl $0x0, 0x10(%rdx)
movb $0x1, 0x14(%rdx)
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x3adc
movq %r15, %rdi
movl $0x1, %esi
callq 0x2946
movq %r15, %rdi
movl $0x1, %esi
callq 0x294c
leaq 0x10(%rsp), %r12
leaq 0x1b0(%rbx), %r13
leaq 0x8(%rsp), %rbp
movl $0x28, %edi
callq 0x2160
movq %rax, %r14
movq %rax, %rdi
callq 0x2794
movq %r14, 0x8(%rsp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x3c52
movq 0x8(%rsp), %rsi
movq %r15, %rdi
leaq 0x20(%rsp), %rdx
callq 0x2952
testb %al, %al
je 0x4106
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3d0e
movq %rax, %rdi
movq %r13, %rsi
callq 0x2050
incq 0x1c0(%rbx)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x409d
callq 0x3b2c
jmp 0x409d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4115
callq 0x3b2c
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x2170
jmp 0x414a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x414a
callq 0x3b2c
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/salleaffaire[P]MXFParser/./dictionary.hpp
// Function: Dictionary<16>::find[abi:cxx11](Key<16> const&)
std::string find(const Key<T> &x) {
      std::string rval = "NULL";
      bool found = true;
      // Find the root
      auto it = mRootNodes.find(x[0]);
      if (it != mRootNodes.end()) {
         DictionaryNode *current_node = it->second;
         for (int i=1;i<T;i++) {
            // Test if there is a pass-all vertex
            auto pa_it = current_node->mChildrenNodes.find(0xFFFF);
            // Test if there is a matching vertex
            auto it = current_node->mChildrenNodes.find(x[i]);

            // If there is a matching node - take it
            if (it != current_node->mChildrenNodes.end()) {              
               current_node = it->second;
            }
            // Else if there is a pass-all node - take it
            else if (pa_it != current_node->mChildrenNodes.end()) { 
               current_node = pa_it->second;
            }
            // No Match
            else {
               found = false;
               break;
            }
         }
         if (found) {
            rval = current_node->mValue;
         }
      }
      return rval;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x2f42(%rip), %rsi      # 0x7401
leaq 0x2f3f(%rip), %rdx      # 0x7405
callq 0x6052
movq 0x10(%r15), %rcx
testq %rcx, %rcx
je 0x458f
movzbl (%r14), %eax
addq $0x8, %r15
movq %r15, %rdx
xorl %esi, %esi
cmpw %ax, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rdx
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x44e3
cmpq %r15, %rdx
je 0x458f
cmpw %ax, 0x20(%rdx)
ja 0x458f
movq 0x28(%rdx), %rsi
movl $0x1, %eax
movq 0x30(%rsi), %rdx
testq %rdx, %rdx
je 0x458f
addq $0x28, %rsi
movq %rdx, %rdi
movq %rsi, %rcx
xorl %r8d, %r8d
cmpw $-0x1, 0x20(%rdi)
setne %r8b
cmoveq %rdi, %rcx
movq 0x10(%rdi,%r8,8), %rdi
testq %rdi, %rdi
jne 0x452a
movzbl (%r14,%rax), %r8d
movq %rsi, %rdi
xorl %r9d, %r9d
cmpw %r8w, 0x20(%rdx)
setb %r9b
cmovaeq %rdx, %rdi
movq 0x10(%rdx,%r9,8), %rdx
testq %rdx, %rdx
jne 0x454c
cmpq %rsi, %rdi
je 0x4572
cmpw %r8w, 0x20(%rdi)
jbe 0x457a
movq %rcx, %rdi
cmpq %rsi, %rcx
je 0x458f
incq %rax
movq 0x28(%rdi), %rsi
cmpq $0x10, %rax
jne 0x4517
movq %rbx, %rdi
callq 0x20c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x45b5
movq (%r12), %rsi
incq %rsi
callq 0x2170
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/salleaffaire[P]MXFParser/./mxf_base.hpp
// Function: mxf_file::decode_partition_pack(klv_item&)
int decode_partition_pack(klv_item &klv) {
      int rval = 0;
      switch (klv.mKey[13]) {
      case 0x02:
         decode_header_partition_pack(klv);
         break;
      case 0x03:
         decode_body_partition_pack(klv);
         break;
      case 0x04:
         decode_footer_partition_pack(klv);
         break;
      }
      return rval;
   }

// Assembly:
pushq %rax
movzbl 0xd(%rsi), %eax
cmpl $0x4, %eax
je 0x45e0
cmpl $0x3, %eax
je 0x45d9
cmpl $0x2, %eax
jne 0x45e5
callq 0x45ea
jmp 0x45e5
callq 0x4d90
jmp 0x45e5
callq 0x5560
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/salleaffaire[P]MXFParser/./dictionary.hpp
// Function: Dictionary<16>::add(Signature<16>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void add(const Signature<T> x, std::string name) {
      DictionaryNode *current_node;

      // Adding the root
      auto it = mRootNodes.find(x[0]);
      if (it == mRootNodes.end()) {
         current_node = new DictionaryNode;
         mRootNodes[x[0]] = current_node;
         //std::cout << "Creating a new root node for " << x[0] << std::endl;
      }
      else {
         current_node = it->second;
         //std::cout << "Following root node for " << x[0] << std::endl; 
      }
      // Adding all other node
      for (int i=1;i<T;i++) {
         auto it = current_node->mChildrenNodes.find(x[i]);
         if (it == current_node->mChildrenNodes.end()) {
            DictionaryNode *new_node = new DictionaryNode;
            current_node->mChildrenNodes[x[i]] = new_node;
            current_node = new_node;
            //std::cout << "Creating a new node for " << x[i] << std::endl;
         }
         else {
            current_node = it->second;
            //std::cout << "Following node for " << x[i] << std::endl;
         }         
      }
      current_node->mValue = name;
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movzwl 0x50(%rsp), %ebx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x6386
leaq 0x8(%r15), %rdx
movq %rdx, %rax
xorl %esi, %esi
cmpw %bx, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x635f
cmpq %rdx, %rax
je 0x6386
cmpw 0x20(%rax), %bx
jae 0x64ab
movl $0x50, %edi
callq 0x2160
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x28(%r14), %rcx
movl $0x0, 0x28(%r14)
movq %rax, 0x30(%r14)
movq %rcx, 0x38(%r14)
movq %rcx, 0x40(%r14)
movq %rax, 0x48(%r14)
leaq 0xe(%rsp), %rsi
movw %bx, (%rsi)
movq %r15, %rdi
callq 0x6582
movq %r14, (%rax)
leaq 0x50(%rsp), %r13
movl $0x1, %ebp
xorl %ebx, %ebx
movzwl (%r13,%rbp,2), %r15d
movq 0x30(%r14), %rcx
testq %rcx, %rcx
je 0x641b
leaq 0x28(%r14), %rdx
movq %rdx, %rax
xorl %esi, %esi
cmpw %r15w, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x63f6
cmpq %rdx, %rax
je 0x641b
cmpw 0x20(%rax), %r15w
jae 0x6489
addq $0x20, %r14
movl $0x50, %edi
callq 0x2160
movq %rax, %r12
addq $0x10, %rax
movq %rax, (%r12)
movq %rbx, 0x8(%r12)
movb $0x0, 0x10(%r12)
leaq 0x28(%r12), %rax
movl $0x0, 0x28(%r12)
movq %rbx, 0x30(%r12)
movq %rax, 0x38(%r12)
movq %rax, 0x40(%r12)
movq %rbx, 0x48(%r12)
movw %r15w, 0xc(%rsp)
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x6582
movq %r12, (%rax)
movq %r12, %r14
incq %rbp
cmpq $0x10, %rbp
jne 0x63e0
jmp 0x648f
movq 0x28(%rax), %r14
jmp 0x647a
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x20c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rax), %r14
jmp 0x63d4
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: eval_ternary(peg::AstBase<peg::EmptyType> const&, std::shared_ptr<Environment>)
Value eval_ternary(const Ast& ast, shared_ptr<Environment> env) {
  auto cond = eval(*ast.nodes[0], env).get<bool>();
  auto val1 = eval(*ast.nodes[1], env);
  auto val2 = eval(*ast.nodes[2], env);
  return cond ? val1 : val2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0xc0(%rsi), %rax
movq (%rax), %rsi
movq (%rdx), %rax
movq %rax, -0x60(%rbp)
movq 0x8(%rdx), %rax
movq %rax, -0x58(%rbp)
testq %rax, %rax
je 0x8a40
movq 0x5553e(%rip), %rcx     # 0x5df70
cmpb $0x0, (%rcx)
je 0x8a3c
incl 0x8(%rax)
jmp 0x8a40
lock
incl 0x8(%rax)
leaq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x8bff
leaq -0x88(%rbp), %rdi
callq 0xdc38
movl %eax, %r15d
leaq -0x88(%rbp), %rsi
movzbl 0x20(%rsi), %eax
leaq 0x5507f(%rip), %rcx     # 0x5daf0
leaq -0xb0(%rbp), %rdi
callq *(%rcx,%rax,8)
movb $-0x1, -0x68(%rbp)
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x8a8d
callq 0x123fc
movq 0xc0(%r12), %rax
movq 0x10(%rax), %rsi
movq (%r14), %rax
movq %rax, -0x50(%rbp)
movq 0x8(%r14), %rax
movq %rax, -0x48(%rbp)
testq %rax, %rax
je 0x8ac2
movq 0x554bc(%rip), %rcx     # 0x5df70
cmpb $0x0, (%rcx)
je 0x8abe
incl 0x8(%rax)
jmp 0x8ac2
lock
incl 0x8(%rax)
leaq -0x88(%rbp), %r13
leaq -0x50(%rbp), %rdx
movq %r13, %rdi
callq 0x8bff
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x8ae3
callq 0x123fc
movq 0xc0(%r12), %rax
movq 0x20(%rax), %rsi
movq (%r14), %rax
movq %rax, -0x40(%rbp)
movq 0x8(%r14), %rax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x8b18
movq 0x55466(%rip), %rcx     # 0x5df70
cmpb $0x0, (%rcx)
je 0x8b14
incl 0x8(%rax)
jmp 0x8b18
lock
incl 0x8(%rax)
leaq -0xb0(%rbp), %r14
leaq -0x40(%rbp), %rdx
movq %r14, %rdi
callq 0x8bff
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x8b39
callq 0x123fc
testb %r15b, %r15b
cmovneq %r13, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39b56
leaq -0xb0(%rbp), %rsi
movzbl 0x20(%rsi), %eax
leaq -0x29(%rbp), %rdi
leaq 0x54f8f(%rip), %r14     # 0x5daf0
callq *(%r14,%rax,8)
leaq -0x88(%rbp), %rsi
movzbl 0x20(%rsi), %eax
leaq -0xb0(%rbp), %rdi
callq *(%r14,%rax,8)
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8bcd
jmp 0x8bcd
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0xdcb2
jmp 0x8bb6
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x8bb6
callq 0x123fc
leaq -0x88(%rbp), %rdi
callq 0xdcb2
jmp 0x8bf7
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8bed
movq %rax, %rdi
callq 0xe032
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0xdcb2
jmp 0x8be9
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x8bf7
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: eval_multiplicative(peg::AstBase<peg::EmptyType> const&, std::shared_ptr<Environment>)
Value eval_multiplicative(const Ast& ast, shared_ptr<Environment> env) {
  auto l = eval(*ast.nodes[0], env).get<long>();
  for (size_t i = 1; i < ast.nodes.size(); i += 2) {
    auto r = eval(*ast.nodes[i + 1], env).get<long>();
    l = l % r;
  }
  return Value(l);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rsi, -0x38(%rbp)
movq 0xc0(%rsi), %rax
movq (%rax), %rsi
movq (%rdx), %rax
movq %rax, -0x58(%rbp)
movq %rdx, -0x68(%rbp)
movq 0x8(%rdx), %rax
movq %rax, -0x50(%rbp)
testq %rax, %rax
je 0x9049
movq 0x54f35(%rip), %rcx     # 0x5df70
cmpb $0x0, (%rcx)
je 0x9045
incl 0x8(%rax)
jmp 0x9049
lock
incl 0x8(%rax)
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x8bff
leaq -0x90(%rbp), %rdi
callq 0xdd86
movq %rax, %r12
leaq -0x90(%rbp), %rsi
movzbl 0x20(%rsi), %eax
leaq 0x54a76(%rip), %rcx     # 0x5daf0
leaq -0x29(%rbp), %rdi
callq *(%rcx,%rax,8)
movb $-0x1, -0x70(%rbp)
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x9093
callq 0x123fc
movq %rbx, -0x60(%rbp)
movq -0x38(%rbp), %rcx
movq 0xc0(%rcx), %rax
movq 0xc8(%rcx), %rcx
subq %rax, %rcx
cmpq $0x11, %rcx
jb 0x916d
movl $0x1, %r14d
movl $0x20, %r15d
leaq -0x90(%rbp), %r13
movq (%rax,%r15), %rsi
movq -0x68(%rbp), %rcx
movq (%rcx), %rax
movq %rax, -0x48(%rbp)
movq 0x8(%rcx), %rax
movq %rax, -0x40(%rbp)
testq %rax, %rax
je 0x90fa
movq 0x54e84(%rip), %rcx     # 0x5df70
cmpb $0x0, (%rcx)
je 0x90f6
incl 0x8(%rax)
jmp 0x90fa
lock
incl 0x8(%rax)
movq %r13, %rdi
leaq -0x48(%rbp), %rdx
callq 0x8bff
movq %r13, %rdi
callq 0xdd86
movq %rax, %rbx
movzbl -0x70(%rbp), %eax
leaq -0x29(%rbp), %rdi
movq %r13, %rsi
leaq 0x549cd(%rip), %rcx     # 0x5daf0
callq *(%rcx,%rax,8)
movb $-0x1, -0x70(%rbp)
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x9138
callq 0x123fc
movq %r12, %rax
cqto
idivq %rbx
addq $0x2, %r14
movq -0x38(%rbp), %rcx
movq 0xc0(%rcx), %rax
movq 0xc8(%rcx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x20, %r15
movq %rdx, %r12
cmpq %rcx, %r14
jb 0x90c9
movq -0x60(%rbp), %rax
movq %r12, (%rax)
movb $0x2, 0x20(%rax)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x91cd
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0xdcb2
jmp 0x919d
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x91bb
movq %rax, %rbx
jmp 0x91b7
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0xdcb2
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x91c5
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
movq %rax, %rdi
callq 0xe032
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: interpret(peg::AstBase<peg::EmptyType> const&)
Value interpret(const Ast& ast) {
  auto env = make_shared<Environment>();

  env->set_value("puts", Value(Function([](auto& val) {
                   cout << val.str() << endl;
                   return Value();
                 })));

  return eval(ast, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x50, %edi
callq 0x82a0
movq %rax, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%rbx)
leaq 0x54681(%rip), %rax     # 0x5dcd8
movq %rax, (%rbx)
leaq 0x28(%rbx), %rax
movl $0x0, 0x28(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq %rax, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movq %rcx, 0x48(%rbx)
movaps %xmm0, -0x80(%rbp)
leaq 0x413(%rip), %rax       # 0x9a9c
movq %rax, -0x48(%rbp)
movaps %xmm0, -0x60(%rbp)
leaq 0x4b2(%rip), %rax       # 0x9b4a
movq %rax, -0x50(%rbp)
movaps %xmm0, -0x70(%rbp)
movb $0x4, -0x40(%rbp)
leaq -0x90(%rbp), %rsi
movq $0x4, (%rsi)
leaq 0x38f41(%rip), %rax     # 0x425fa
movq %rax, 0x8(%rsi)
leaq 0x20(%rbx), %rdi
callq 0x39eec
leaq -0x98(%rbp), %rdi
movq %rax, (%rdi)
leaq -0x60(%rbp), %rsi
leaq -0x19(%rbp), %rdx
callq 0x3a391
leaq -0x60(%rbp), %rsi
movzbl 0x20(%rsi), %eax
leaq 0x54404(%rip), %rcx     # 0x5daf0
leaq -0x90(%rbp), %rdi
callq *(%rcx,%rax,8)
movb $-0x1, -0x40(%rbp)
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x9711
leaq -0x80(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq %rbx, -0x28(%rbp)
movq 0x54849(%rip), %rax     # 0x5df70
cmpb $0x0, (%rax)
je 0x9731
incl 0x8(%rbx)
jmp 0x9735
lock
incl 0x8(%rbx)
leaq -0x30(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8bff
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x9752
callq 0x123fc
movq %rbx, %rdi
callq 0x123fc
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x97b5
movq %rax, %r14
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x97a5
callq 0x123fc
jmp 0x97a5
jmp 0x97b5
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0xdcb2
movq -0x70(%rbp), %rax
testq %rax, %rax
je 0x97a5
leaq -0x80(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x123fc
movq %r14, %rdi
callq 0x8420
movq %rax, %rdi
callq 0xe032
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: main
int main(int argc, const char** argv) {
  if (argc < 2) {
    cerr << "usage: fzbz [source file path]" << endl;
    return 1;
  }

  ifstream file{argv[1]};
  if (!file) {
    cerr << "can't open the source file." << endl;
    return 2;
  }

  auto source =
      string(istreambuf_iterator<char>(file), istreambuf_iterator<char>());

  auto ast = parse(source, cerr);
  if (!ast) {
    return 3;
  }

  try {
    interpret(*ast);
  } catch (const exception& e) {
    cerr << e.what() << endl;
    return 4;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x270, %rsp            # imm = 0x270
cmpl $0x1, %edi
jg 0x981c
movq 0x54809(%rip), %rbx     # 0x5dfe0
leaq 0x38e21(%rip), %rsi     # 0x425ff
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x8310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x81e0
movl $0x1, %ebx
jmp 0x9933
movq 0x8(%rsi), %rsi
leaq -0x278(%rbp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x8450
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x258(%rbp,%rax)
je 0x9895
movq 0x54794(%rip), %rbx     # 0x5dfe0
leaq 0x38dcb(%rip), %rsi     # 0x4261e
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x8310
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x8280
movsbl %al, %esi
movq 0x54762(%rip), %rdi     # 0x5dfe0
callq 0x8030
movl $0x2, %ebx
movq %rax, %rdi
callq 0x81e0
jmp 0x9927
movq -0x190(%rbp,%rax), %rsi
leaq -0x38(%rbp), %r14
movq %r14, -0x10(%r14)
leaq -0x48(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x41220
movq 0x5471e(%rip), %rdx     # 0x5dfe0
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x881c
movq -0x28(%rbp), %rsi
testq %rsi, %rsi
je 0x98ff
leaq -0x70(%rbp), %rdi
callq 0x961f
leaq -0x70(%rbp), %rsi
movzbl 0x20(%rsi), %eax
leaq 0x54200(%rip), %rcx     # 0x5daf0
leaq -0x11(%rbp), %rdi
callq *(%rcx,%rax,8)
movb $-0x1, -0x50(%rbp)
xorl %ebx, %ebx
jmp 0x9904
movl $0x3, %ebx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x9912
callq 0x123fc
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x9927
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x82b0
leaq -0x278(%rbp), %rdi
callq 0x80a0
movl %ebx, %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0xe032
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x9995
movq %rbx, %rdi
callq 0x8110
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x54677(%rip), %rdi     # 0x5dfe0
movq %rax, %rsi
callq 0x8290
movq %rax, %rdi
callq 0x8140
movl $0x4, %ebx
callq 0x83f0
jmp 0x9904
movq %rax, %rbx
jmp 0x9995
movq %rax, %rbx
callq 0x83f0
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x99aa
callq 0x123fc
jmp 0x99aa
jmp 0x9941
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x99c6
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x82b0
jmp 0x99c6
jmp 0x99c3
movq %rax, %rbx
leaq -0x278(%rbp), %rdi
callq 0x80a0
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Trie::match(char const*, unsigned long, unsigned long&) const
size_t match(const char *text, size_t text_len, size_t &id) const {
    std::string lower_text;
    if (ignore_case_) {
      lower_text = to_lower(text);
      text = lower_text.data();
    }

    size_t match_len = 0;
    auto done = false;
    size_t len = 1;
    while (!done && len <= text_len) {
      std::string_view sv(text, len);
      auto it = dic_.find(sv);
      if (it == dic_.end()) {
        done = true;
      } else {
        if (it->second.match) {
          match_len = len;
          id = it->second.id;
        }
        if (it->second.done) { done = true; }
      }
      len += 1;
    }
    return match_len;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, -0x88(%rbp)
movq %rdx, -0x38(%rbp)
movq %rsi, %r13
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rdi, -0x40(%rbp)
cmpb $0x1, 0x30(%rdi)
jne 0xa0cf
leaq -0x60(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r13, %rsi
callq 0x115f6
movq -0x60(%rbp), %rbx
movq -0x58(%rbp), %r14
testq %r14, %r14
je 0xa0a7
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x8380
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0xa08d
movq -0x60(%rbp), %rbx
leaq -0x98(%rbp), %r15
movq %r15, -0x10(%r15)
leaq -0x50(%rbp), %r14
cmpq %r14, %rbx
je 0xa0d4
movq %rbx, -0xa8(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xa0dc
movq %rax, %rdi
jmp 0xa13e
movups (%r14), %xmm0
movups %xmm0, (%r15)
movq -0x58(%rbp), %rax
leaq -0xa8(%rbp), %rbx
movq %rax, 0x8(%rbx)
movq %r14, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movb $0x0, -0x50(%rbp)
leaq -0x80(%rbp), %rdi
movq %rbx, %rsi
callq 0x8330
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xa11e
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x82b0
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0xa133
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x82b0
movq -0x80(%rbp), %rdi
movq %rdi, %r13
leaq -0x70(%rbp), %rax
cmpq $0x0, -0x38(%rbp)
je 0xa1b0
movq -0x40(%rbp), %rax
leaq 0x8(%rax), %r14
movl $0x2, %r15d
xorl %ebx, %ebx
leaq -0x1(%r15), %r12
movq %r12, -0xa8(%rbp)
movq %r13, -0xa0(%rbp)
movq -0x40(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x116d2
cmpq %r14, %rax
je 0xa1a6
cmpb $0x1, 0x41(%rax)
jne 0xa193
movq 0x48(%rax), %rcx
movq -0x88(%rbp), %rdx
movq %rcx, (%rdx)
movq %r12, %rbx
cmpb $0x0, 0x40(%rax)
jne 0xa1a6
leaq 0x1(%r15), %rax
cmpq -0x38(%rbp), %r15
movq %rax, %r15
jbe 0xa155
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
jmp 0xa1b2
xorl %ebx, %ebx
cmpq %rax, %rdi
je 0xa1c3
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x82b0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa1da
movq %rax, %rbx
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0xa1f6
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x82b0
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Context::set_error_pos(char const*, char const*)
inline void Context::set_error_pos(const char *a_s, const char *literal) {
  if (log) {
    if (error_info.error_pos <= a_s) {
      if (error_info.error_pos < a_s || !error_info.keep_previous_token) {
        error_info.error_pos = a_s;
        error_info.expected_tokens.clear();
      }

      const char *error_literal = nullptr;
      const Definition *error_rule = nullptr;

      if (literal) {
        error_literal = literal;
      } else if (!rule_stack.empty()) {
        auto rule = rule_stack.back();
        auto ope = rule->get_core_operator();
        if (auto token = FindLiteralToken::token(*ope);
            token && token[0] != '\0') {
          error_literal = token;
        }
      }

      for (auto r : rule_stack) {
        error_rule = r;
        if (r->is_token()) { break; }
      }

      if (error_literal || error_rule) {
        error_info.add(error_literal, error_rule);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x258(%rdi)
je 0xa349
movq %rdi, %r15
leaq 0x18(%rdi), %rcx
cmpq %rsi, 0x18(%rdi)
ja 0xa349
movq %rdx, %r14
jb 0xa23d
cmpb $0x0, 0x88(%r15)
jne 0xa24f
movq %rsi, 0x18(%r15)
movq 0x20(%r15), %rax
cmpq %rax, 0x28(%r15)
je 0xa24f
movq %rax, 0x28(%r15)
testq %r14, %r14
jne 0xa2e0
movq 0xc0(%r15), %rax
cmpq %rax, 0xb8(%r15)
je 0xa296
movq %rcx, %rbx
movq -0x8(%rax), %rax
movq 0x1c0(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %r12
testq %r12, %r12
je 0xa2a1
movq 0x53ce6(%rip), %rax     # 0x5df70
cmpb $0x0, (%rax)
je 0xa29b
incl 0x8(%r12)
jmp 0xa2a1
xorl %r14d, %r14d
jmp 0xa2e0
lock
incl 0x8(%r12)
leaq 0x52220(%rip), %rax     # 0x5c4c8
leaq -0x40(%rbp), %rsi
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x38(%rbp), %rax
xorl %r14d, %r14d
testq %rax, %rax
je 0xa2d0
cmpb $0x0, (%rax)
cmovneq %rax, %r14
testq %r12, %r12
je 0xa2dd
movq %r12, %rdi
callq 0x123fc
movq %rbx, %rcx
movq 0xb8(%r15), %rbx
movq 0xc0(%r15), %r13
cmpq %r13, %rbx
je 0xa32e
movq %rcx, -0x30(%rbp)
addq $0x8, %rbx
leaq -0x40(%rbp), %r12
movq -0x8(%rbx), %r15
leaq 0x1d0(%r15), %rdi
movq %r15, -0x40(%rbp)
movq %r12, %rsi
callq 0x11842
cmpb $0x0, 0x1d4(%r15)
jne 0xa33a
leaq 0x8(%rbx), %rax
cmpq %r13, %rbx
movq %rax, %rbx
jne 0xa2ff
jmp 0xa33a
testq %r14, %r14
je 0xa349
movq %rcx, -0x30(%rbp)
xorl %r15d, %r15d
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x117e4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r12, %r12
je 0xa368
movq %r12, %rdi
callq 0x123fc
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Ope::parse(char const*, unsigned long, peg::SemanticValues&, peg::Context&, std::any&) const
inline size_t Ope::parse(const char *s, size_t n, SemanticValues &vs,
                         Context &c, std::any &dt) const {
  if (c.is_traceable(*this)) {
    c.trace_enter(*this, s, n, vs, dt);
    auto len = parse_core(s, n, vs, c, dt);
    c.trace_leave(*this, s, n, vs, dt, len);
    return len;
  }
  return parse_core(s, n, vs, c, dt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r10
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
cmpq $0x0, 0x200(%r8)
je 0xa81d
cmpq $0x0, 0x220(%rbx)
je 0xa81d
cmpb $0x0, 0x288(%rbx)
jne 0xa81d
leaq 0x51519(%rip), %rsi     # 0x5bd18
leaq 0x51532(%rip), %rdx     # 0x5bd38
movq %r14, %rdi
xorl %ecx, %ecx
movq %r10, -0x30(%rbp)
callq 0x8300
movq -0x30(%rbp), %r10
testq %rax, %rax
je 0xa846
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %r10, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x268(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x268(%rbx)
movq %rax, -0x38(%rbp)
movq 0x278(%rbx), %rsi
cmpq 0x280(%rbx), %rsi
je 0xa884
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x278(%rbx)
movq %r13, -0x38(%rbp)
movq %r12, -0x40(%rbp)
jmp 0xa8b1
leaq 0x270(%rbx), %rdi
leaq -0x38(%rbp), %rdx
callq 0x12468
movq -0x30(%rbp), %r10
cmpq $0x0, 0x200(%rbx)
leaq -0x38(%rbp), %rax
movq %r13, (%rax)
movq %r12, -0x40(%rbp)
je 0xa941
leaq 0x1f0(%rbx), %rdi
leaq 0x230(%rbx), %rax
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
movq %r14, %rsi
movq %r15, %r8
movq %rbx, %r9
pushq %rax
pushq %r10
callq *0x208(%rbx)
addq $0x10, %rsp
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq -0x30(%rbp), %r9
callq *0x10(%rax)
leaq 0x210(%rbx), %rdi
subq $0x8, %rsp
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
pushq -0x48(%rbp)
movq %rax, %r14
pushq %rax
pushq -0x30(%rbp)
callq 0x1258a
addq $0x20, %rsp
addq $-0x8, 0x278(%rbx)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x80f0