LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::datetimeFromBytePos[abi:cxx11](int) const
const string Packet::datetimeFromBytePos(int iPos) const
{
    uint8_t aBytes[4]; // 4 - sizeof(unsigned int)
    // copy 4 bytes to aBytes
    for (int j = 0; j<sizeof(float); ++j)
    {
        aBytes[j] = _packv[iPos+j];
    }
    // convert aBytes to double
   return  Packet::dateFromFourBytes(aBytes);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x4, %rax
jae 0x48d2
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
movslq %eax, %rsi
callq 0x6270
movb (%rax), %cl
movslq -0x1c(%rbp), %rax
movb %cl, -0x18(%rbp,%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x489d
movq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4660
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: Packet::dataToDoubles()
void Packet::dataToDoubles()
{
    uint8_t aBytes[8]; // 8 - sizeof(double)

    for (int i = PACKET_HEADER_LEN; i<_packv.size()-7; ++i)
    {
        // copy 8 bytes to aBytes
        for (int j = 0; j<8; ++j)
        {
            aBytes[j] = _packv[i+j];
        }
        // convert aBytes to double
        _dataDoubles.push_back(doubleFromBytes(aBytes));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xa, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x3750
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x7, %rcx
cmpq %rcx, %rax
jae 0x499d
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0x4968
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movslq %eax, %rsi
callq 0x6290
movb (%rax), %cl
movslq -0x18(%rbp), %rax
movb %cl, -0x10(%rbp,%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4937
movq -0x28(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4540
movq -0x38(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x62b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x490b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Marm0t[P]dji-phantom3-parser/packet.cpp
// Function: GPSPacket::parseHex()
void GPSPacket::parseHex()
{
    Packet::parseHex();
    
    // first we should check packet type (must be 0x01CF)
    if (this->getPacketType() != 0x01CF)
    {
     //   cout << "GPSPacket: Wrong packet type: " << hex << this->getPacketType();
        _valid = false;
        return;
    }

    // then check byte#6 (must be 0x00 for pgs packet)
    if (this->getPacketRaw()[6] != 0x00)
    {
     //   cout << "GPSPacket: Wrong byte#6 (muxt be 0x00) " << hex << this->getPacketRaw()[6] << endl;
        _valid = false;
        return;
    }

    // now we can get lat/long/alt values
    // TODO
    _lon=convertDoubleToGps(doubleFromBytePos(10)); // byte#10 - beginning of longitude
    _lat=convertDoubleToGps(doubleFromBytePos(18)); // byte#18 - beginning of latitude
    _alt=floatFromBytePos(26);

    _bytes30_33_f=floatFromBytePos(30);
    _bytes34_37_f=floatFromBytePos(34);
    _bytes38_41_f=floatFromBytePos(38);
    _bytes42_45_f=floatFromBytePos(42);
    
    _bytes46_49_f=floatFromBytePos(46);
    _bytes50_53_f=floatFromBytePos(50);
    _bytes54_57_f=floatFromBytePos(54);
    _bytes58_61_f=floatFromBytePos(58);
    
    
    _valid = true;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4dc0
movq -0x20(%rbp), %rdi
callq 0x6380
cmpl $0x1cf, %eax            # imm = 0x1CF
je 0x4fe6
movq -0x20(%rbp), %rax
movb $0x0, 0x5c(%rax)
jmp 0x5106
movq -0x20(%rbp), %rdi
callq 0x63a0
movq %rax, %rdi
movl $0x6, %esi
callq 0x6270
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x5011
movq -0x20(%rbp), %rax
movb $0x0, 0x5c(%rax)
jmp 0x5106
movq -0x20(%rbp), %rdi
movl $0xa, %esi
callq 0x4580
movsd %xmm0, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4510
movq -0x20(%rbp), %rdi
movsd %xmm0, 0x48(%rdi)
movl $0x12, %esi
callq 0x4580
movsd %xmm0, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4510
movq -0x20(%rbp), %rdi
movsd %xmm0, 0x50(%rdi)
movl $0x1a, %esi
callq 0x45f0
movq -0x20(%rbp), %rdi
movss %xmm0, 0x58(%rdi)
movl $0x1e, %esi
callq 0x45f0
movq -0x20(%rbp), %rdi
movss %xmm0, 0x60(%rdi)
movl $0x22, %esi
callq 0x45f0
movq -0x20(%rbp), %rdi
movss %xmm0, 0x64(%rdi)
movl $0x26, %esi
callq 0x45f0
movq -0x20(%rbp), %rdi
movss %xmm0, 0x68(%rdi)
movl $0x2a, %esi
callq 0x45f0
movq -0x20(%rbp), %rdi
movss %xmm0, 0x6c(%rdi)
movl $0x2e, %esi
callq 0x45f0
movq -0x20(%rbp), %rdi
movss %xmm0, 0x70(%rdi)
movl $0x32, %esi
callq 0x45f0
movq -0x20(%rbp), %rdi
movss %xmm0, 0x74(%rdi)
movl $0x36, %esi
callq 0x45f0
movq -0x20(%rbp), %rdi
movss %xmm0, 0x78(%rdi)
movl $0x3a, %esi
callq 0x45f0
movq -0x20(%rbp), %rax
movss %xmm0, 0x7c(%rax)
movb $0x1, 0x5c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: tdv[P]boss/boss/examples/query_interface_2/main.cpp
// Function: main
int main()
{
  try
  {
    auto Obj = Boss::Base<MyNs::Impl::Face_1_2>::Create();
    FuncForIFace1(Boss::RefObjQIPtr<MyNs::IFaces::IFace1>(Obj).Get());
    FuncForIFace2(Boss::RefObjQIPtr<MyNs::IFaces::IFace2>(Obj).Get());
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x16530
jmp 0x16308
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x16620
jmp 0x16319
leaq 0x30(%rsp), %rdi
callq 0x16670
movq %rax, 0x18(%rsp)
jmp 0x1632a
movq 0x18(%rsp), %rdi
callq 0x16210
jmp 0x16336
leaq 0x30(%rsp), %rdi
callq 0x16680
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x166a0
jmp 0x16351
leaq 0x28(%rsp), %rdi
callq 0x166f0
movq %rax, 0x10(%rsp)
jmp 0x16362
movq 0x10(%rsp), %rdi
callq 0x16280
jmp 0x1636e
leaq 0x28(%rsp), %rdi
callq 0x16700
leaq 0x48(%rsp), %rdi
callq 0x16720
jmp 0x16451
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x163e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x163d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x16680
jmp 0x163d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x16700
leaq 0x48(%rsp), %rdi
callq 0x16720
movl 0x3c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1646f
movq 0x40(%rsp), %rdi
callq 0x17c60
movq %rax, 0x20(%rsp)
leaq 0xe0eda(%rip), %rdi     # 0xf72e0
leaq 0xa4ca4(%rip), %rsi     # 0xbb0b1
callq 0x81c30
movq %rax, 0x8(%rsp)
jmp 0x16419
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x81c30
movq %rax, (%rsp)
jmp 0x1643a
movq (%rsp), %rdi
leaq 0x6b0cb(%rip), %rsi     # 0x81510
callq 0x80720
jmp 0x1644c
callq 0x17cd0
xorl %eax, %eax
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x17cd0
jmp 0x1646d
jmp 0x1646f
movq 0x40(%rsp), %rdi
callq 0xb85e0
movq %rax, %rdi
callq 0x16740
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_rtc_overhead.cpp
// Function: main
int main(int argc, char* argv[])
{
   const std::size_t rounds = ((argc == 2) ? atoi(argv[1]) : 5);

   for (std::size_t i = 0; i < rounds; ++i)
   {
      vector_rtc_overhead_analysis_01<double>();
   }

   printf("-------------------------\n");

   for (std::size_t i = 0; i < rounds; ++i)
   {
      vector_rtc_overhead_analysis_02<double>();
   }

   return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpl $0x2, 0x30(%rsp)
jne 0x118580
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x111260
movl %eax, 0xc(%rsp)
jmp 0x11858b
movl $0x5, %eax
movl %eax, 0xc(%rsp)
jmp 0x11858b
movl 0xc(%rsp), %eax
cltq
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x1185c0
callq 0x1188c0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x11859f
leaq 0x331f58(%rip), %rdi    # 0x44a51f
movb $0x0, %al
callq 0x111080
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x1185f8
callq 0x119010
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1185d7
xorl %eax, %eax
addq $0x38, %rsp
retq
nop
// File: iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: preliminaries(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>>>>&)
void preliminaries(vector<string>& v)
{
	// process v
	istream_iterator<string> input(cin), eof;
	copy(input, eof, back_inserter(v));
	sort(v.begin(), v.end(),
		 [](const string& a, const string& b)
		 { return a.size() < b.size(); });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq 0x8aaa(%rip), %rsi      # 0xafe0
leaq -0x38(%rbp), %rdi
callq 0x40a0
leaq -0x68(%rbp), %rdi
callq 0x4100
jmp 0x254a
leaq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x42b0
jmp 0x255c
leaq -0xd8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x42b0
jmp 0x256e
movq -0x8(%rbp), %rdi
callq 0x4300
movq %rax, -0x108(%rbp)
jmp 0x2580
movq -0x108(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x4140
movq %rax, -0x110(%rbp)
jmp 0x25b1
movq -0x110(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4330
leaq -0xa8(%rbp), %rdi
callq 0x4330
movq -0x8(%rbp), %rdi
callq 0x4350
movq %rax, -0xf0(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4380
movq %rax, -0xf8(%rbp)
movq -0xf0(%rbp), %rdi
movq -0xf8(%rbp), %rsi
callq 0x2690
jmp 0x260c
leaq -0x68(%rbp), %rdi
callq 0x4330
leaq -0x38(%rbp), %rdi
callq 0x4330
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x267e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2675
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2669
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4330
leaq -0xa8(%rbp), %rdi
callq 0x4330
leaq -0x68(%rbp), %rdi
callq 0x4330
leaq -0x38(%rbp), %rdi
callq 0x4330
movq -0x70(%rbp), %rdi
callq 0x21f0
// File: iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: process2(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>>>>&)
pair<string, int> process2(vector<string>& v)
{
	// process v
	if (!v.empty())
		return make_pair(v.back(), v.back().size());
	else
		return pair<string, int>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43b0
testb $0x1, %al
jne 0x27d0
movq -0x10(%rbp), %rdi
callq 0x43f0
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x43f0
movq %rax, %rdi
callq 0x20c0
movq -0x70(%rbp), %rsi
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
leaq -0x40(%rbp), %rdx
callq 0x44a0
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x44e0
jmp 0x27ae
leaq -0x38(%rbp), %rdi
callq 0x3d30
jmp 0x27d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3d30
jmp 0x27e3
movq -0x60(%rbp), %rdi
callq 0x4470
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x21f0
nopl (%rax)
// File: vianna274[P]dropbox/client.cpp
// Function: getArguments[abi:cxx11]()
vector<string> getArguments(){
	string input;
	cout << "> ";
	getline(cin, input);
	input.erase(std::remove(input.begin(), input.end(), '\n'), input.end());
	vector<string> arguments;
	boost::split(arguments, input, [](char c){return c == ' ';});
	return arguments;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x45c0
movq 0x107c0(%rip), %rdi     # 0x29fc0
leaq 0x4ed0(%rip), %rsi      # 0x1e6d7
callq 0x4470
jmp 0x1980e
movq 0x107cb(%rip), %rdi     # 0x29fe0
leaq -0x28(%rbp), %rsi
callq 0x40e0
jmp 0x19820
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x43e0
movq -0xa0(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x42c0
movq %rax, -0x58(%rbp)
movb $0xa, -0x59(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x59(%rbp), %rdx
callq 0x1ae80
movq %rax, -0x98(%rbp)
jmp 0x19862
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1aed0
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x42c0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1aed0
movq -0xb0(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x4100
movq %rax, -0xa8(%rbp)
jmp 0x198b8
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x79(%rbp)
callq 0x12a30
movq -0x90(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x19960
jmp 0x198ea
movb $0x1, -0x79(%rbp)
testb $0x1, -0x79(%rbp)
jne 0x1992a
jmp 0x1991e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x19943
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x12bb0
jmp 0x19943
movq -0x90(%rbp), %rdi
callq 0x12bb0
leaq -0x28(%rbp), %rdi
callq 0x42f0
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x42f0
movq -0x30(%rbp), %rdi
callq 0x4780
nopw %cs:(%rax,%rax)
// File: legendddhgf[P]Text2RPG/common.cpp
// Function: stringTrim(char*, char const*, char*)
void stringTrim (char *s, const char *trim, char *ret) {
  size_t i = 0;
  // first pass skips front
  while (i < strlen(s)) { // sufficient condition because srlen decreases
    if (strchr(trim, s[i]) == nullptr) {
      break; // if beginning doesn't need to be trimmed anymore
    }
    i++;
  }
  // second pass puts the rest of s in ret
  strncpy(ret, s + i, strlen(s + i) + 1); //copy the null character too

  // third pass trims back of ret
  for (int i = strlen(ret) - 1; i >= 0; i--) {
    if (strchr(trim, ret[i]) == nullptr) {
      ret[i + 1] = '\0'; // trim everything after this character
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x24a4
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x20a0
cmpq $0x0, %rax
jne 0x2496
jmp 0x24a4
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x245c
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
addq -0x20(%rbp), %rdi
callq 0x20e0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x2100
movq -0x18(%rbp), %rdi
callq 0x20e0
subq $0x1, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x252a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x20a0
cmpq $0x0, %rax
jne 0x251d
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x252a
jmp 0x251f
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x24e9
addq $0x40, %rsp
popq %rbp
retq
// File: legendddhgf[P]Text2RPG/common.cpp
// Function: stringToParams(char*, 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>>>>*, char const*)
void stringToParams(char *str, vector<string> *params, const char *delimiters) {
  string temp = string("");
  for (size_t i = 0; i < strlen(str); i++) {
    if (strchr(delimiters, str[i]) != nullptr && temp.size() > 0) {
      params->push_back(temp);
      temp = string("");
      continue;
    } else if (strchr(delimiters, str[i]) != nullptr) continue;
    temp.append(1, str[i]); // unfortunately unintuitive way of appending chars
  }
  if (temp.size() > 0) {
    params->push_back(temp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2310
movq -0x88(%rbp), %rdx
leaq 0xddae(%rip), %rsi      # 0x10313
leaq -0x38(%rbp), %rdi
callq 0x2260
jmp 0x2570
leaq -0x39(%rbp), %rdi
callq 0x21f0
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x26c9
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x20a0
cmpq $0x0, %rax
je 0x267b
leaq -0x38(%rbp), %rdi
callq 0x2180
cmpq $0x0, %rax
jbe 0x267b
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2710
jmp 0x25e9
leaq -0x79(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2310
movq -0x98(%rbp), %rdx
leaq 0xdd0c(%rip), %rsi      # 0x10313
leaq -0x78(%rbp), %rdi
callq 0x2260
jmp 0x2612
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2230
leaq -0x78(%rbp), %rdi
callq 0x2150
leaq -0x79(%rbp), %rdi
callq 0x21f0
jmp 0x26b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x21f0
jmp 0x2704
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x26fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x79(%rbp), %rdi
callq 0x21f0
jmp 0x26fb
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0x20a0
cmpq $0x0, %rax
je 0x2698
jmp 0x26b8
jmp 0x269a
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movsbl (%rax,%rcx), %edx
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x21e0
jmp 0x26b6
jmp 0x26b8
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x2581
leaq -0x38(%rbp), %rdi
callq 0x2180
cmpq $0x0, %rax
jbe 0x26e9
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2710
jmp 0x26e7
jmp 0x26e9
leaq -0x38(%rbp), %rdi
callq 0x2150
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x2150
movq -0x48(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: legendddhgf[P]Text2RPG/ArgParser.cpp
// Function: ArgParser::usage1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ArgParser::usage1(string unexpected) {
  fprintf(stderr, "%s: unexpected field\n", unexpected.c_str());
  fprintf(stderr, "Expected Fields:\n");
  for (string s : expected) {
    fprintf(stderr, "\t%s\n", s.c_str());
  }
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x15cd6(%rip), %rax     # 0x18fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
callq 0x20c0
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq 0xcd44(%rip), %rsi      # 0x10068
movb $0x0, %al
callq 0x2280
movq 0x15cae(%rip), %rax     # 0x18fe0
movq (%rax), %rdi
leaq 0xcd42(%rip), %rsi      # 0x1007e
movb $0x0, %al
callq 0x2280
movq -0x50(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2b70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x29f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3ef0
testb $0x1, %al
jne 0x337c
jmp 0x33d1
leaq -0x20(%rbp), %rdi
callq 0x3f30
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x20d0
movq 0x15c48(%rip), %rax     # 0x18fe0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20c0
movq -0x68(%rbp), %rdi
movq %rax, %rdx
leaq 0xccda(%rip), %rsi      # 0x10090
movb $0x0, %al
callq 0x2280
leaq -0x48(%rbp), %rdi
callq 0x2150
leaq -0x20(%rbp), %rdi
callq 0x3f50
jmp 0x3369
movl $0x1, %edi
callq 0x2220
nopl (%rax,%rax)
// File: legendddhgf[P]Text2RPG/ArgParser.cpp
// Function: ArgParser::usage2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ArgParser::usage2(string expectedstr) {
  fprintf(stderr, "%s: expected field but not found\n", expectedstr.c_str());
  fprintf(stderr, "Expected Fields:\n");
  for (string s : expected) {
    fprintf(stderr, "\t%s\n", s.c_str());
  }
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x15bd6(%rip), %rax     # 0x18fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
callq 0x20c0
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq 0xcc71(%rip), %rsi      # 0x10095
movb $0x0, %al
callq 0x2280
movq 0x15bae(%rip), %rax     # 0x18fe0
movq (%rax), %rdi
leaq 0xcc42(%rip), %rsi      # 0x1007e
movb $0x0, %al
callq 0x2280
movq -0x50(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2b70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x29f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3ef0
testb $0x1, %al
jne 0x347c
jmp 0x34d1
leaq -0x20(%rbp), %rdi
callq 0x3f30
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x20d0
movq 0x15b48(%rip), %rax     # 0x18fe0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20c0
movq -0x68(%rbp), %rdi
movq %rax, %rdx
leaq 0xcbda(%rip), %rsi      # 0x10090
movb $0x0, %al
callq 0x2280
leaq -0x48(%rbp), %rdi
callq 0x2150
leaq -0x20(%rbp), %rdi
callq 0x3f50
jmp 0x3469
movl $0x1, %edi
callq 0x2220
nopl (%rax,%rax)
// File: legendddhgf[P]Text2RPG/ArgParser.cpp
// Function: ArgParser::GetTarget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string ArgParser::GetTarget(string field) {
  if (fields.find(field) == fields.end()) {
    fprintf(stderr, "%s: Not an existing field\n", field.c_str());
    exit(1);
  }
  return fields.at(field);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rdi, -0x40(%rbp)
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x18, %rdi
callq 0x4130
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x18, %rdi
callq 0x4160
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4100
testb $0x1, %al
jne 0x3b53
jmp 0x3b89
movq -0x48(%rbp), %rdi
movq 0x15482(%rip), %rax     # 0x18fe0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
callq 0x20c0
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0xc53f(%rip), %rsi      # 0x100b7
movb $0x0, %al
callq 0x2280
movl $0x1, %edi
callq 0x2220
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x4190
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x20d0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: tomfunkhouser[P]gaps/apps/sfl2pts/sfl2pts.cpp
// Function: ComparePlyPoints(void const*, void const*)
static int
ComparePlyPoints(const void *data1, const void *data2)
{
  // Sort by confidence
  PlyPoint *point1 = *((PlyPoint **) data1);
  PlyPoint *point2 = *((PlyPoint **) data2);
  unsigned char c1 = point1->confidence;
  unsigned char c2 = point2->confidence;
  if (c1 > c2) return -1;
  else if (c2 > c1) return 1;
  else return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
cvttss2si 0x1c(%rax), %eax
movb %al, -0x29(%rsp)
movq -0x28(%rsp), %rax
cvttss2si 0x1c(%rax), %eax
movb %al, -0x2a(%rsp)
movzbl -0x29(%rsp), %eax
movzbl -0x2a(%rsp), %ecx
cmpl %ecx, %eax
jle 0x187a8
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x187c8
movzbl -0x2a(%rsp), %eax
movzbl -0x29(%rsp), %ecx
cmpl %ecx, %eax
jle 0x187c0
movl $0x1, -0x4(%rsp)
jmp 0x187c8
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: enferex[P]fnplot/cs.cc
// Function: CS::CS(char const*)
CS::CS(const char *fname)
{
    FILE *fp;
    uint8_t *data;
    struct stat st;

    if (!(fp = fopen(fname, "r")))
      throw("Could not open cscope database file");

    // mmap the input cscope database
    fstat(fileno(fp), &st);
    data = (uint8_t *)mmap(NULL, st.st_size,
                           PROT_READ, MAP_PRIVATE, fileno(fp), 0);
    if (!data)
      throw("Error memory maping cscope database");

    // Initialize the data
    initHeader(data, st.st_size);
    initTrailer(data, st.st_size);
    initSymbols(data, st.st_size);

    // Done loading data
    munmap(data, st.st_size);
    fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
addq $0x60, %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3e70
movq -0x10(%rbp), %rdi
leaq 0x799b(%rip), %rsi      # 0xa244
callq 0x22c0
movq %rax, -0xc8(%rbp)
jmp 0x28b7
movq -0xc8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2917
movl $0x8, %edi
callq 0x2130
movq %rax, %rdi
leaq 0x796a(%rip), %rax      # 0xa246
movq %rax, (%rdi)
movq 0xd6d2(%rip), %rsi      # 0xffb8
xorl %eax, %eax
movl %eax, %edx
callq 0x23d0
jmp 0x2a06
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x3e90
jmp 0x29fa
movq -0x18(%rbp), %rdi
callq 0x2270
movl %eax, %edi
leaq -0xb0(%rbp), %rsi
callq 0x23c0
movq -0x80(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2270
movq -0xe0(%rbp), %rsi
movl %eax, %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x2400
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2997
movl $0x8, %edi
callq 0x2130
movq %rax, %rdi
leaq 0x78e8(%rip), %rax      # 0xa26a
movq %rax, (%rdi)
movq 0xd62c(%rip), %rsi      # 0xffb8
xorl %eax, %eax
movl %eax, %edx
callq 0x23d0
jmp 0x2a06
movq -0xd8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x2a10
jmp 0x29ad
movq -0xd8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x2c30
jmp 0x29c3
movq -0xd8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x2e20
jmp 0x29d9
movq -0x20(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x2220
jmp 0x29f1
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: enferex[P]fnplot/cs.cc
// Function: CS::initSymbols(unsigned char const*, unsigned long)
void CS::initSymbols(const uint8_t *data, size_t data_len)
{
    pos_t pos = {0};
    char line[1024];
    CSFile *file;

    pos.off = this->_hdr.syms_start;
    pos.data = data;
    pos.data_len = data_len;

    while (VALID(&pos) && pos.off <= this->_hdr.trailer) {
        // Get file info
        getLine(&pos, line, sizeof(line));
        file = newFile(line);
        fileLoadSymbols(file, &pos);

        // No-name file
        if (file->getName().size() == 0) {
            delete file;
            continue;
        }

        // Add the file to the list of files 
        this->addFile(file);
        this->_n_functions += file->getFunctionCount();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp            # imm = 0x480
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x460(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2150
movq -0x460(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x461(%rbp)
ja 0x2e9b
movq -0x460(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x10(%rcx), %rax
setbe %al
movb %al, -0x461(%rbp)
movb -0x461(%rbp), %al
testb $0x1, %al
jne 0x2eaa
jmp 0x2f8f
leaq -0x430(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movl $0x400, %edx            # imm = 0x400
callq 0x3760
leaq -0x430(%rbp), %rdi
callq 0x3880
movq %rax, -0x438(%rbp)
movq -0x438(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3910
movq -0x438(%rbp), %rsi
leaq -0x458(%rbp), %rdi
callq 0x4340
leaq -0x458(%rbp), %rdi
callq 0x21a0
movq %rax, -0x470(%rbp)
leaq -0x458(%rbp), %rdi
callq 0x2180
movq -0x470(%rbp), %rax
cmpq $0x0, %rax
jne 0x2f57
movq -0x438(%rbp), %rax
movq %rax, -0x478(%rbp)
cmpq $0x0, %rax
je 0x2f52
movq -0x478(%rbp), %rdi
callq 0x4370
movq -0x478(%rbp), %rdi
movl $0x68, %esi
callq 0x2240
jmp 0x2e71
movq -0x460(%rbp), %rdi
movq -0x438(%rbp), %rsi
callq 0x43a0
movq -0x438(%rbp), %rdi
callq 0x43d0
movq %rax, %rdx
movq -0x460(%rbp), %rax
movslq 0x58(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x58(%rax)
jmp 0x2e71
addq $0x480, %rsp            # imm = 0x480
popq %rbp
retq
nopl (%rax,%rax)
// File: enferex[P]fnplot/cs.cc
// Function: csPrintCallers(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
void csPrintCallers(FILE *out, CSDB *db, const char *fn_name, int depth)
{
    cout << "Building callers... " << std::flush;
    fprintf(out, "digraph \"Callers to %s\" {\n", fn_name);
    printCallersRec(out, db, fn_name, depth);
    fprintf(out, "}\n");
    cout << "Done" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq 0xccca(%rip), %rdi      # 0xffc8
leaq 0x6fb2(%rip), %rsi      # 0xa2b7
callq 0x2210
movq %rax, %rdi
movq 0xccbc(%rip), %rsi      # 0xffd0
callq 0x2250
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6fa4(%rip), %rsi      # 0xa2cc
movb $0x0, %al
callq 0x2340
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x3380
movq -0x8(%rbp), %rdi
leaq 0x6f99(%rip), %rsi      # 0xa2e7
movb $0x0, %al
callq 0x2340
movq 0xcc6c(%rip), %rdi      # 0xffc8
leaq 0x6f87(%rip), %rsi      # 0xa2ea
callq 0x2210
movq %rax, %rdi
movq 0xcc36(%rip), %rsi      # 0xffa8
callq 0x2250
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: enferex[P]fnplot/cs.cc
// Function: printCallersRec(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
static void printCallersRec(
    FILE       *out,
    CSDB       *db,
    const char *fn_name,
    int         depth)
{
    if (depth <= 0)
      return;

    for (auto pr: *db) {
        const char *item = pr.first.c_str();
        // Does 'item' call 'fn_name' ?
        if (isCallerOf(db, item, fn_name)) {
            fprintf(out, "    %s -> %s\n", item, fn_name);
            printCallersRec(out, db, item, depth - 1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x33a5
jmp 0x3493
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x56e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5710
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5740
testb $0x1, %al
jne 0x33dd
jmp 0x3493
leaq -0x30(%rbp), %rdi
callq 0x5770
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x57a0
movq -0x90(%rbp), %rdi
callq 0x20e0
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3a00
movb %al, -0x85(%rbp)
jmp 0x3422
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x342e
jmp 0x347c
movq -0x8(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x6f47(%rip), %rsi      # 0xa388
xorl %eax, %eax
callq 0x2340
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x78(%rbp), %rdx
movl -0x1c(%rbp), %ecx
decl %ecx
callq 0x3380
jmp 0x3460
jmp 0x347c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5800
jmp 0x349c
leaq -0x70(%rbp), %rdi
callq 0x5800
leaq -0x30(%rbp), %rdi
callq 0x5830
jmp 0x33c7
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x23e0
nopw %cs:(%rax,%rax)
// File: enferex[P]fnplot/cs.cc
// Function: csPrintCallees(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
void csPrintCallees(FILE *out, CSDB *db, const char *fn_name, int depth)
{
    cout << "Building callees... " << std::flush;
    fprintf(out, "digraph \"Callees of %s\" {\n", fn_name);
    printCalleesRec(out, db, fn_name, depth);
    fprintf(out, "}\n");
    cout << "Done" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq 0xcafa(%rip), %rdi      # 0xffc8
leaq 0x6e1a(%rip), %rsi      # 0xa2ef
callq 0x2210
movq %rax, %rdi
movq 0xcaec(%rip), %rsi      # 0xffd0
callq 0x2250
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6e0c(%rip), %rsi      # 0xa304
movb $0x0, %al
callq 0x2340
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x3550
movq -0x8(%rbp), %rdi
leaq 0x6dc9(%rip), %rsi      # 0xa2e7
movb $0x0, %al
callq 0x2340
movq 0xca9c(%rip), %rdi      # 0xffc8
leaq 0x6db7(%rip), %rsi      # 0xa2ea
callq 0x2210
movq %rax, %rdi
movq 0xca66(%rip), %rsi      # 0xffa8
callq 0x2250
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: enferex[P]fnplot/cs.cc
// Function: getLine(pos_t*, char*, unsigned long)
static void getLine(pos_t *pos, char *buf, size_t buf_len)
{
    size_t len, st = pos->off;

    // Get initial line (header line)
    while (CH(pos) != EOF && CH(pos) != '\n')
      ++pos->off;

    len = pos->off - st; // Don't return the '\n'
    ++pos->off;          // +1 to advance to the '\n'
    if (END(pos) || len > buf_len)
      return;

    memcpy(buf, pos->data + st, len);
    buf[len] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x37a8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
jmp 0x37b2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x37b2
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x2d(%rbp)
je 0x37fe
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x37e8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
jmp 0x37f2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x37f2
movl -0x34(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x3807
jmp 0x381a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x377f
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3852
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x3854
jmp 0x3879
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
addq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x21e0
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: enferex[P]fnplot/cs.cc
// Function: newFile(char const*)
static CSFile *newFile(const char *str)
{
    const char *c = str;

    // Skip whitespace
    while (isspace(*c))
      ++c;

    return new CSFile(c+1, *c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2050
cmpl $0x0, %eax
je 0x38b3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3894
movl $0x68, %edi
callq 0x2230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rsi
incq %rsi
movsbl (%rax), %edx
callq 0x7350
jmp 0x38db
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x68, %esi
callq 0x2240
movq -0x18(%rbp), %rdi
callq 0x23e0
nopl (%rax,%rax)
// File: enferex[P]fnplot/cs.cc
// Function: fileLoadSymbols(CSFile*, pos_t*)
static void fileLoadSymbols(CSFile *file, pos_t *pos)
{
    long lineno;
    char line[1024], *c;

    DBG("Loading: %s", file->name);

    // <empty line>
    getLine(pos, line, sizeof(line));

    // Now parse symbol information for eack line in 'file'
    while (VALID(pos)) {
        // Either this is a symbol, or a file.  If this is a file, then we are
        // done processing the current file.  So, in that case we break and
        // restore the position at the start of the next file's data:
        // <mark><file> line.
        //
        // So there are two cases here:
        // 1) New set of symbols: <lineno><blank><non-symbol text>
        // 2) A new file: <mark><file>
        getLine(pos, line, sizeof(line));
        c = line;
        while (isspace(*c))
          ++c;

        // Case 2: New file
        if (c[0] == '@') {
            pos->off -= strlen(line);
            return;
        }

        // Case 1: Symbols at line!
        // <line number><blank>
        lineno = atol(c);
        loadSymbolsInFile(file, pos, lineno);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x3760
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x39eb
movq -0x10(%rbp), %rdi
leaq -0x420(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x3760
leaq -0x420(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rax
movsbl (%rax), %edi
callq 0x2050
cmpl $0x0, %eax
je 0x3998
movq -0x428(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x428(%rbp)
jmp 0x3970
movq -0x428(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
jne 0x39c5
leaq -0x420(%rbp), %rdi
callq 0x2100
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x39eb
movq -0x428(%rbp), %rdi
callq 0x22d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b70
jmp 0x3938
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: enferex[P]fnplot/cs.cc
// Function: isCallerOf(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, char const*)
static bool isCallerOf(CSDB *db, const char *a, const char *b)
{
    // All the functions 'a' calls
    for (auto callee: (*db)[a]) {
        if (strcmp(callee->getName().c_str(), b) == 0)
            return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x23f0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x59e0
jmp 0x3a56
movq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x59b0
movq %rax, -0xb8(%rbp)
jmp 0x3a6f
leaq -0x48(%rbp), %rdi
callq 0x2180
leaq -0x49(%rbp), %rdi
callq 0x2280
movq -0xb8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4b00
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4950
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x5a90
testb $0x1, %al
jne 0x3abc
jmp 0x3b55
leaq -0x68(%rbp), %rdi
callq 0x5020
movq (%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
movq (%rsi), %rax
leaq -0x98(%rbp), %rdi
callq *(%rax)
leaq -0x98(%rbp), %rdi
callq 0x20e0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x2330
movl %eax, -0xbc(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2180
movl -0xbc(%rbp), %eax
cmpl $0x0, %eax
jne 0x3b45
movb $0x1, -0x1(%rbp)
jmp 0x3b59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3b3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2180
leaq -0x49(%rbp), %rdi
callq 0x2280
jmp 0x3b67
jmp 0x3b47
leaq -0x68(%rbp), %rdi
callq 0x5ad0
jmp 0x3aa6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x23e0
// File: enferex[P]fnplot/cs.cc
// Function: isMark(char)
static bool isMark(char c)
{
    unsigned i;
    for (i=0; i<sizeof(cs_marks)/sizeof(cs_marks[0]); ++i)
      if (c == cs_marks[i])
        return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpq $0x12, %rax
jae 0x3e65
movsbl -0x2(%rbp), %eax
movl -0x8(%rbp), %ecx
movl %ecx, %edx
leaq 0x6586(%rip), %rcx      # 0xa3d0
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x3e58
movb $0x1, -0x1(%rbp)
jmp 0x3e69
jmp 0x3e5a
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3e31
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
// File: wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TodoList::add(std::string task) {
  if (task.find_first_not_of("1234567890. ") == std::string::npos) return;

  std::cout << "Added #" << first_unset() << ": " << task << std::endl;
  tasks.insert(std::make_pair(first_unset(), task));
  write();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, %rax
movq -0x78(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x3efe(%rip), %rsi      # 0x914f
xorl %eax, %eax
movl %eax, %edx
callq 0x3160
cmpq $-0x1, %rax
jne 0x5265
jmp 0x5323
movq 0x7d64(%rip), %rdi      # 0xcfd0
leaq 0x3f5d(%rip), %rsi      # 0x91d0
callq 0x3240
movq -0x68(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x5350
movq -0x98(%rbp), %rdi
movl %eax, %esi
callq 0x33f0
movq %rax, %rdi
leaq 0x3f38(%rip), %rsi      # 0x91d8
callq 0x3240
movq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
movq 0x7d05(%rip), %rsi      # 0xcfc0
callq 0x3290
movq -0x68(%rbp), %rdi
callq 0x5350
movq -0x70(%rbp), %rdx
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0x5a70
movq -0x68(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x5a30
movb %dl, -0x81(%rbp)
movq %rax, -0x80(%rbp)
jmp 0x5300
movb -0x81(%rbp), %al
movq -0x80(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5ab0
movq -0x68(%rbp), %rdi
callq 0x5400
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5ab0
movq -0x48(%rbp), %rdi
callq 0x3400
nopw (%rax,%rax)
// File: wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::first_unset()
int TodoList::first_unset() {
  if (tasks.size()) {
    for (int i = 1; i < tasks.rbegin()->first; i++) {
      if (!tasks.count(i)) return i;
    }
    return tasks.rbegin()->first + 1;
  } else {
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x5d40
cmpq $0x0, %rax
je 0x53e4
movl $0x1, -0x14(%rbp)
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5ef0
leaq -0x20(%rbp), %rdi
callq 0x5f20
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jge 0x53c4
movq -0x30(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x5ad0
cmpq $0x0, %rax
jne 0x53b7
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x53eb
jmp 0x53b9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5376
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5ef0
leaq -0x28(%rbp), %rdi
callq 0x5f20
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x53eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::write()
void TodoList::write() {
  std::ofstream ofs(path.c_str());

  tmap::iterator it;

  for (it = tasks.begin(); it != tasks.end(); ++it) {
    ofs << get(it->first) << std::endl;
  }

  ofs.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x258(%rbp)
addq $0x30, %rdi
callq 0x3110
movq %rax, %rsi
leaq -0x208(%rbp), %rdi
movl $0x10, %edx
callq 0x32c0
leaq -0x210(%rbp), %rdi
callq 0x5c40
movq -0x258(%rbp), %rdi
callq 0x5c60
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x210(%rbp)
movq -0x258(%rbp), %rdi
callq 0x5cc0
movq %rax, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x5c90
testb $0x1, %al
jne 0x5493
jmp 0x5538
leaq -0x210(%rbp), %rdi
callq 0x5cf0
movq -0x258(%rbp), %rsi
movl (%rax), %edx
leaq -0x240(%rbp), %rdi
callq 0x5660
jmp 0x54b6
leaq -0x208(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x3230
movq %rax, -0x260(%rbp)
jmp 0x54d2
movq -0x260(%rbp), %rdi
movq 0x7ae0(%rip), %rsi      # 0xcfc0
callq 0x3290
jmp 0x54e7
leaq -0x240(%rbp), %rdi
callq 0x3190
leaq -0x210(%rbp), %rdi
callq 0x5d10
jmp 0x5464
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x555b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x3190
jmp 0x555b
leaq -0x208(%rbp), %rdi
callq 0x3360
jmp 0x5546
leaq -0x208(%rbp), %rdi
callq 0x3380
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x208(%rbp), %rdi
callq 0x3380
movq -0x248(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)