LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::getLayerInfo(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&)
void NeuralNet::getLayerInfo(stringstream& ss) {
  if((layers.size() - 2) == 0 ) return;

  ss << "LAYER INFO\n";

  // Print info on the hidden layers
  unsigned short number_of_hidden_layers = layers.size() - 2;

  for(auto i = 1; i <= number_of_hidden_layers; i++) {
    ss << "Size of hidden layer " << i << ": " << layers.at(i).size() << '\n';
  }

  ss << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x18, %rdi
callq 0x82e0
subq $0x2, %rax
cmpq $0x0, %rax
jne 0x6c40
jmp 0x6cfc
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7568(%rip), %rsi      # 0xe1b7
callq 0x2190
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x82e0
subq $0x2, %rax
movw %ax, -0x12(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jg 0x6cea
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7539(%rip), %rsi      # 0xe1c3
callq 0x2190
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x22f0
movq %rax, %rdi
leaq 0x74a4(%rip), %rsi      # 0xe148
callq 0x2190
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
movslq -0x18(%rbp), %rsi
callq 0x8280
movq %rax, %rdi
callq 0x8220
movq -0x28(%rbp), %rdi
movzwl %ax, %esi
callq 0x22d0
movq %rax, %rdi
movl $0xa, %esi
callq 0x2210
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6c70
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movl $0xa, %esi
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::buildCodeString[abi:cxx11]()
std::string NeuralNet::buildCodeString() {
    stringstream ss{};
    includeHeaders(ss);
    writeBody(ss);
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
callq 0x20e0
movq -0x1b8(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
callq 0x70e0
jmp 0x7067
movq -0x1b8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x7150
jmp 0x707c
movq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2180
jmp 0x7091
leaq -0x198(%rbp), %rdi
callq 0x2100
movq -0x1c0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x2100
movq -0x1a0(%rbp), %rdi
callq 0x2310
nopw (%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/neuralnet.cpp
// Function: NeuralNet::includeHeaders(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&)
void NeuralNet::includeHeaders(stringstream& ss) {
    ss << "#include <StandardCplusplus.h>\n";
    ss << "#include <system_configuration.h>\n";
    ss << "#include \"neuralnet.h\"\n\n";
    ss << "using namespace std;\n\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7127(%rip), %rsi      # 0xe226
callq 0x2190
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7133(%rip), %rsi      # 0xe246
callq 0x2190
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7142(%rip), %rsi      # 0xe269
callq 0x2190
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x7147(%rip), %rsi      # 0xe282
callq 0x2190
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gkosae[P]ArduinoNeuralNet/main.cpp
// Function: createOutputSamples()
vector<vector<double>> createOutputSamples() {

  cout << "Entering createOutputSamples" << endl;
  vector<vector<double>> samples{};

  for(auto i = 0; i < number_of_samples; ++i) {
    samples.push_back(vector<double>{18.00/NORMALIZER, 50.00/NORMALIZER});
  }

  cout << "Leaving createOutputSamples" << endl;

  return samples;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq 0xa727(%rip), %rdi      # 0x14fd8
leaq 0x3c60(%rip), %rsi      # 0xe518
callq 0x2190
movq %rax, %rdi
movq 0xa701(%rip), %rsi      # 0x14fc8
callq 0x21c0
movq -0x68(%rbp), %rdi
movb $0x0, -0x9(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20b0
movq -0x68(%rbp), %rdi
callq 0xb220
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0xa8e7(%rip), %eax      # 0x151e0
jge 0xa9ac
movabsq $0x3fc70a3d70a3d70a, %rax # imm = 0x3FC70A3D70A3D70A
movq %rax, -0x48(%rbp)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x2, -0x30(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x28d0
movq -0x78(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xb330
jmp 0xa94f
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb300
jmp 0xa95e
leaq -0x28(%rbp), %rdi
callq 0x2990
leaq -0x49(%rbp), %rdi
callq 0x29f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa8f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa9a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2990
leaq -0x49(%rbp), %rdi
callq 0x29f0
jmp 0xaa07
movq 0xa625(%rip), %rdi      # 0x14fd8
leaq 0x3b7b(%rip), %rsi      # 0xe535
callq 0x2190
movq %rax, -0x80(%rbp)
jmp 0xa9c5
movq -0x80(%rbp), %rdi
movq 0xa5f8(%rip), %rsi      # 0x14fc8
callq 0x21c0
jmp 0xa9d7
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xa9fa
jmp 0xa9f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xaa07
movq -0x68(%rbp), %rdi
callq 0x80b0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x80b0
movq -0x58(%rbp), %rdi
callq 0x2310
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/book.cc
// Function: main
int main()
{
    // use the hypothetical bookstore exceptions 
    Sales_data item1, item2, sum;
    while (cin >> item1 >> item2) {  // read two transactions
        try {
            sum = item1 + item2;     // calculate their sum
            // use sum
        } catch (const isbn_mismatch &e) {
          cerr << e.what() << ": left isbn(" << e.left
               << ") right isbn(" << e.right << ")" << endl;
        }
    }
     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2650
leaq -0x68(%rbp), %rdi
callq 0x2650
leaq -0x98(%rbp), %rdi
callq 0x2650
movq 0x3bd1(%rip), %rdi      # 0x5fd8
leaq -0x38(%rbp), %rsi
callq 0x2a40
movq %rax, -0xe8(%rbp)
jmp 0x2419
movq -0xe8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2a40
movq %rax, -0xf0(%rbp)
jmp 0x2432
movq -0xf0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2160
movb %al, -0xf1(%rbp)
jmp 0x2450
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x245f
jmp 0x25e2
leaq -0xd8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x28f0
jmp 0x2475
leaq -0x98(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x2690
leaq -0xd8(%rbp), %rdi
callq 0x26d0
jmp 0x25c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x2613
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2613
movq -0xa0(%rbp), %rdi
callq 0x2060
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq 0x3aee(%rip), %rdi      # 0x5ff0
callq 0x2110
movq %rax, -0x100(%rbp)
jmp 0x2510
movq -0x100(%rbp), %rdi
leaq 0x1af6(%rip), %rsi      # 0x4014
callq 0x2110
movq %rax, -0x108(%rbp)
jmp 0x252c
movq -0x108(%rbp), %rdi
movq -0xe0(%rbp), %rsi
addq $0x10, %rsi
callq 0x2100
movq %rax, -0x110(%rbp)
jmp 0x254c
movq -0x110(%rbp), %rdi
leaq 0x1ac7(%rip), %rsi      # 0x4021
callq 0x2110
movq %rax, -0x118(%rbp)
jmp 0x2568
movq -0x118(%rbp), %rdi
movq -0xe0(%rbp), %rsi
addq $0x30, %rsi
callq 0x2100
movq %rax, -0x120(%rbp)
jmp 0x2588
movq -0x120(%rbp), %rdi
leaq 0x1a99(%rip), %rsi      # 0x402f
callq 0x2110
movq %rax, -0x128(%rbp)
jmp 0x25a4
movq -0x128(%rbp), %rdi
movq 0x3a0e(%rip), %rsi      # 0x5fc0
callq 0x2130
jmp 0x25b9
callq 0x21e0
jmp 0x25c0
jmp 0x25c2
jmp 0x2400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
callq 0x21e0
jmp 0x25e0
jmp 0x2613
movl $0x0, -0x4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x26d0
leaq -0x68(%rbp), %rdi
callq 0x26d0
leaq -0x38(%rbp), %rdi
callq 0x26d0
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
leaq -0x98(%rbp), %rdi
callq 0x26d0
leaq -0x68(%rbp), %rdi
callq 0x26d0
leaq -0x38(%rbp), %rdi
callq 0x26d0
movq -0xa0(%rbp), %rdi
callq 0x2200
movq %rax, %rdi
callq 0x26f0
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/Sales_data.cc
// Function: Sales_data::operator+=(Sales_data const&)
Sales_data& Sales_data::operator+=(const Sales_data &rhs)
{
    if (isbn() != rhs.isbn())
        throw isbn_mismatch("wrong isbns", isbn(), rhs.isbn());
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xd8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2e60
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2e60
jmp 0x2736
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2e30
movb %al, -0xd9(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20b0
leaq -0x30(%rbp), %rdi
callq 0x20b0
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x276a
jmp 0x28b1
movb $0x1, -0xc9(%rbp)
movl $0x50, %edi
callq 0x2090
movq %rax, -0xf0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x2220
movq -0xe8(%rbp), %rdx
leaq 0x188e(%rip), %rsi      # 0x4031
leaq -0x80(%rbp), %rdi
callq 0x21a0
jmp 0x27ae
movq -0xd8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x2e60
jmp 0x27c3
movq -0x10(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0x2e60
jmp 0x27d5
movq -0xf0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0xc8(%rbp), %rcx
callq 0x2e90
jmp 0x27f5
movq -0xf0(%rbp), %rdi
movb $0x0, -0xc9(%rbp)
leaq 0x355e(%rip), %rsi      # 0x5d68
leaq 0x71f(%rip), %rdx       # 0x2f30
callq 0x21f0
jmp 0x28ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20b0
jmp 0x28e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x288c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2883
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2877
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x20b0
leaq -0xa8(%rbp), %rdi
callq 0x20b0
leaq -0x80(%rbp), %rdi
callq 0x20b0
leaq -0x81(%rbp), %rdi
callq 0x2140
testb $0x1, -0xc9(%rbp)
jne 0x28a3
jmp 0x28af
movq -0xf0(%rbp), %rdi
callq 0x20d0
jmp 0x28e1
movq -0xd8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movsd 0x28(%rcx), %xmm0
addsd 0x28(%rax), %xmm0
movsd %xmm0, 0x28(%rax)
addq $0xf0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2200
nopw (%rax,%rax)
// File: Necrelox[P]Auto_Presence/src/main.cpp
// Function: main
int main(int ac, char **av)
{
    try
    {
        if (ac < 4 || ac > 5)
            throw CError("Error number of arguments");
        else {
            automatic_presence presence(ac, av);
            presence.AutomaticPresence();
            return OK;
        }
    }
    catch(const CError& e)
    {
        std::cerr << e.get_error_msg() << '\n';
        if (ac < 4 || ac > 5)
            std::cout << "\nFor use Precense : \n\t./presence (file of meetingAttendanceReport by Teams) (Hour of start activity) (Hour of end activity) [limit late]" << std::endl;
    }
    return ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
jl 0x6999
cmpl $0x5, -0x8(%rbp)
jle 0x6a4e
movb $0x1, -0x45(%rbp)
movl $0x28, %edi
callq 0x3190
movq %rax, -0x2b8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x2b0(%rbp)
callq 0x34c0
movq -0x2b0(%rbp), %rdx
leaq 0x17ad(%rip), %rsi      # 0x8179
leaq -0x30(%rbp), %rdi
callq 0x4d30
jmp 0x69d7
movq -0x2b8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6bc0
jmp 0x69e9
movq -0x2b8(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x4365(%rip), %rsi      # 0xad60
leaq -0x18b2(%rip), %rdx     # 0x5150
callq 0x34a0
jmp 0x6b92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6a2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31d0
leaq -0x31(%rbp), %rdi
callq 0x3330
testb $0x1, -0x45(%rbp)
jne 0x6a40
jmp 0x6a4c
movq -0x2b8(%rbp), %rdi
callq 0x3210
jmp 0x6aaf
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x2a0(%rbp), %rdi
callq 0x3760
jmp 0x6a63
leaq -0x2a0(%rbp), %rdi
callq 0x4040
jmp 0x6a71
movl $0x0, -0x4(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x3fe0
jmp 0x6b75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6aaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x3fe0
movl -0x44(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6b81
movq -0x40(%rbp), %rdi
callq 0x3120
movq %rax, -0x2a8(%rbp)
movq -0x2a8(%rbp), %rdi
callq 0x6ba0
movq %rax, -0x2c0(%rbp)
jmp 0x6ae4
movq -0x2c0(%rbp), %rsi
movq 0x44fe(%rip), %rdi      # 0xaff0
callq 0x32b0
movq %rax, -0x2c8(%rbp)
jmp 0x6b00
movq -0x2c8(%rbp), %rdi
movl $0xa, %esi
callq 0x3390
jmp 0x6b13
cmpl $0x4, -0x8(%rbp)
jl 0x6b1f
cmpl $0x5, -0x8(%rbp)
jle 0x6b65
movq 0x44aa(%rip), %rdi      # 0xafd0
leaq 0x1666(%rip), %rsi      # 0x8193
callq 0x32e0
movq %rax, -0x2d0(%rbp)
jmp 0x6b3b
movq -0x2d0(%rbp), %rdi
movq 0x446f(%rip), %rsi      # 0xafb8
callq 0x3310
jmp 0x6b50
jmp 0x6b65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3460
jmp 0x6b73
callq 0x3460
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6b75
jmp 0x6b81
movl -0x4(%rbp), %eax
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34b0
movq %rax, %rdi
callq 0x5190
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dsudheerdantuluri[P]quantlab/TradeStreamReader.cc
// Function: TradeStreamReader::next()
Trade TradeStreamReader::next()
{
  std::string line;
  getline(m_fs, line);
  std::vector<std::string> tokens = split(line, ',');
  return Trade(stoul(tokens[0]), 
               tokens[1], 
               stoul(tokens[2]), 
               stoul(tokens[3]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x32b0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x3060
jmp 0x8532
movq -0x68(%rbp), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rdx
movl $0x2c, %ecx
callq 0x8660
jmp 0x854a
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x88(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8880
movq -0x88(%rbp), %rsi
movq %rax, %rdi
movl $0xa, %edx
callq 0x8840
movq %rax, -0x80(%rbp)
jmp 0x8578
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x1, %esi
callq 0x8880
movq -0xa0(%rbp), %rdi
movq %rax, -0x98(%rbp)
movl $0x2, %esi
callq 0x8880
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x8840
movq %rax, -0x90(%rbp)
jmp 0x85bf
leaq -0x58(%rbp), %rdi
movl $0x3, %esi
callq 0x8880
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x8840
movq %rax, -0xa8(%rbp)
jmp 0x85e7
movq -0xa8(%rbp), %r8
movq -0x90(%rbp), %rcx
movq -0x98(%rbp), %rdx
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x96d0
jmp 0x860b
leaq -0x58(%rbp), %rdi
callq 0x88a0
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0x70(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x864d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x88a0
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0x38(%rbp), %rdi
callq 0x3360
nop
// File: dsudheerdantuluri[P]quantlab/TradeStreamReader.cc
// Function: TradeStreamReader::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> TradeStreamReader::split(const std::string& s, 
                                                  char delimiter)
{
  std::vector<std::string> tokens;
  std::string token;
  std::istringstream tokenStream(s);
  while (std::getline(tokenStream, token, delimiter)) {
    tokens.push_back(token);
  }
  return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e0(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
callq 0x8900
leaq -0x40(%rbp), %rdi
callq 0x32b0
movq -0x18(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
movl $0x8, %edx
callq 0x3350
jmp 0x86b6
jmp 0x86b8
movsbl -0x19(%rbp), %edx
leaq -0x1c0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3380
movq %rax, -0x1e8(%rbp)
jmp 0x86d5
movq -0x1e8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3260
movb %al, -0x1e9(%rbp)
jmp 0x86f3
movb -0x1e9(%rbp), %al
testb $0x1, %al
jne 0x86ff
jmp 0x8747
movq -0x1e0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8920
jmp 0x8711
jmp 0x86b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x8768
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3130
jmp 0x8768
movb $0x1, -0x1a(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3130
leaq -0x40(%rbp), %rdi
callq 0x3180
testb $0x1, -0x1a(%rbp)
jne 0x878b
jmp 0x877f
leaq -0x40(%rbp), %rdi
callq 0x3180
movq -0x1e0(%rbp), %rdi
callq 0x88a0
jmp 0x879b
movq -0x1e0(%rbp), %rdi
callq 0x88a0
movq -0x1d8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: dsudheerdantuluri[P]quantlab/TradeProcessor.cc
// Function: TradeProcessor::dumpResults(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void TradeProcessor::dumpResults(const std::string &fileName)
{
  std::ofstream ofs(fileName);
  for (auto sym: m_syms) {
    ofs << sym;
    for(auto p_op: m_ops) {
      ofs << "," << p_op->getVal(sym);
    }
    ofs << "\n";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x280(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x3390
movq -0x280(%rbp), %rax
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rdi
callq 0x9c40
movq %rax, -0x220(%rbp)
movq -0x218(%rbp), %rdi
callq 0x9c70
movq %rax, -0x228(%rbp)
leaq -0x220(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x9ca0
testb $0x1, %al
jne 0x98d3
jmp 0x9a39
leaq -0x220(%rbp), %rdi
callq 0x9cd0
movq %rax, %rsi
leaq -0x248(%rbp), %rdi
callq 0x3110
jmp 0x98f0
leaq -0x210(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x31d0
jmp 0x9905
movq -0x280(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x260(%rbp)
movq -0x260(%rbp), %rdi
callq 0x9ae0
movq %rax, -0x268(%rbp)
movq -0x260(%rbp), %rdi
callq 0x9b10
movq %rax, -0x270(%rbp)
leaq -0x268(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x9b40
testb $0x1, %al
jne 0x9959
jmp 0x9a07
leaq -0x268(%rbp), %rdi
callq 0x9b80
movq (%rax), %rax
movq %rax, -0x278(%rbp)
leaq 0x5897(%rip), %rsi      # 0xf20d
leaq -0x210(%rbp), %rdi
callq 0x31f0
movq %rax, -0x288(%rbp)
jmp 0x998b
movq -0x278(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq -0x248(%rbp), %rsi
callq *%rax
movq %rax, -0x290(%rbp)
jmp 0x99ab
movq -0x290(%rbp), %rsi
movq -0x288(%rbp), %rdi
callq 0x3090
jmp 0x99c0
jmp 0x99c2
leaq -0x268(%rbp), %rdi
callq 0x9ba0
jmp 0x993d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0x9a4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x3180
jmp 0x9a4e
leaq 0x5801(%rip), %rsi      # 0xf20f
leaq -0x210(%rbp), %rdi
callq 0x31f0
jmp 0x9a1c
leaq -0x248(%rbp), %rdi
callq 0x3180
leaq -0x220(%rbp), %rdi
callq 0x9cf0
jmp 0x98b7
leaq -0x210(%rbp), %rdi
callq 0x32f0
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x32f0
movq -0x250(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: dsudheerdantuluri[P]quantlab/TradeMTGap.cc
// Function: TradeMTGap::process(Trade const&)
void TradeMTGap::process(const Trade &t)
{
  std::string sym(t.getSym());
  auto time = t.getTime();
  auto it = m_mtg.find(sym);
  if (it == m_mtg.end()) {
    m_mtg[sym] = {0,time}; 
    return;
  }
  auto &val = it->second; 
  val.first = std::max(val.first, time - val.second);
  val.second = time; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x9c10
movq -0x10(%rbp), %rdi
callq 0xae00
movq %rax, -0x88(%rbp)
jmp 0xac8d
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0xae20
movq %rax, -0x98(%rbp)
jmp 0xacb5
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x8, %rdi
callq 0xae80
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xae50
testb $0x1, %al
jne 0xace7
jmp 0xad4e
movl $0x0, -0x6c(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xaeb0
jmp 0xad01
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0xaee0
movq %rax, -0xa0(%rbp)
jmp 0xad1e
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xaf10
movl $0x1, -0x70(%rbp)
jmp 0xada8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3180
jmp 0xadba
leaq -0x50(%rbp), %rdi
callq 0xaf40
addq $0x20, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rdi), %rcx
subq %rcx, %rax
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x9310
movq %rax, -0xa8(%rbp)
jmp 0xad84
movq -0xa8(%rbp), %rax
movq (%rax), %rcx
movq -0x78(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3180
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: ALSchwalm[P]entrospy/entrospy/entrospy.cpp
// Function: is_hidden(boost::filesystem::path const&)
bool is_hidden(const fs::path& path) {
    const auto& name = path.filename().string();
    if (name != ".." && name != "." && name[0] == '.') {
        return true;
    }
    return false;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xa460
movq (%rsp), %rdi
callq 0xd280
movq %rax, 0x8(%rsp)
jmp 0xb16c
leaq 0x20(%rsp), %rdi
callq 0xd290
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x2b2e4(%rip), %rsi     # 0x36470
callq 0xd2a0
testb $0x1, %al
jne 0xb197
jmp 0xb1e5
movq 0x40(%rsp), %rdi
leaq 0x2b2ce(%rip), %rsi     # 0x36471
callq 0xd2a0
testb $0x1, %al
jne 0xb1ae
jmp 0xb1e5
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa5a0
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xb1e5
movb $0x1, 0x57(%rsp)
jmp 0xb1ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd290
jmp 0xb1f5
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xa9b0
nop
// File: ALSchwalm[P]entrospy/entrospy/entrospy.cpp
// Function: parse_block_size(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
uint64_t parse_block_size(const std::string& bs) {
    auto num = std::stol(bs);
    auto suffix = std::tolower(bs.back());
    if (!std::isdigit(suffix)) {
        switch (suffix) {
        case 'g':
            num *= 1024 * 1024 * 2014;
            break;
        case 'm':
            num *= 1024 * 1024;
            break;
        case 'k':
            num *= 1024;
            break;
        case 'b':
            break;
        default:
            std::cerr << "Unknown suffix: " << bs.back() << " assuming bytes"
                      << std::endl;
        }
    }
    return num;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xd2d0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xa240
movsbl (%rax), %edi
callq 0xa820
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
callq 0xa4a0
cmpl $0x0, %eax
jne 0xb2f0
movl 0x14(%rsp), %eax
addl $-0x62, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0xb, %eax
ja 0xb2a3
movq 0x8(%rsp), %rax
leaq 0x2ae48(%rip), %rcx     # 0x360b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
imulq $0x7de00000, 0x18(%rsp), %rax # imm = 0x7DE00000
movq %rax, 0x18(%rsp)
jmp 0xb2ee
movq 0x18(%rsp), %rax
shlq $0x14, %rax
movq %rax, 0x18(%rsp)
jmp 0xb2ee
movq 0x18(%rsp), %rax
shlq $0xa, %rax
movq %rax, 0x18(%rsp)
jmp 0xb2ee
jmp 0xb2ee
movq 0x40d3e(%rip), %rdi     # 0x4bfe8
leaq 0x2b180(%rip), %rsi     # 0x36431
callq 0xa510
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0xa240
movq (%rsp), %rdi
movsbl (%rax), %esi
callq 0xa630
movq %rax, %rdi
leaq 0x2b168(%rip), %rsi     # 0x36442
callq 0xa510
movq %rax, %rdi
movq 0x40c77(%rip), %rsi     # 0x4bf60
callq 0xa540
jmp 0xb2f0
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ALSchwalm[P]entrospy/entrospy/include/shannon.hpp
// Function: operator>>(std::istream&, DataFormat&)
inline std::istream& operator>>(std::istream& in, DataFormat& format) {
    std::string token;
    in >> token;
    boost::algorithm::to_lower(token);
    if (token == "data") {
        format = DataFormat::DATA;
    } else if (token == "text") {
        format = DataFormat::TEXT;
    } else if (token == "base64") {
        format = DataFormat::BASE64;
    } else {
        throw boost::program_options::validation_error(
            boost::program_options::validation_error::invalid_option,
            "Unknown format");
    }
    return in;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xa7a0
movq 0x28(%rsp), %rsi
movq 0xc0(%rsp), %rdi
callq 0xa690
jmp 0x20f2d
leaq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xaaf0
movq 0x20(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x211a0
jmp 0x20f53
leaq 0x80(%rsp), %rdi
callq 0xa7c0
leaq 0x98(%rsp), %rdi
leaq 0x157b2(%rip), %rsi     # 0x36721
callq 0x14070
testb $0x1, %al
jne 0x20f7a
jmp 0x20fcc
movq 0xb8(%rsp), %rax
movl $0x100, (%rax)          # imm = 0x100
jmp 0x21149
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x2116e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xa7c0
jmp 0x2116e
leaq 0x98(%rsp), %rdi
leaq 0x150a5(%rip), %rsi     # 0x36080
callq 0x14070
testb $0x1, %al
jne 0x20fe6
jmp 0x20ff9
movq 0xb8(%rsp), %rax
movl $0x80, (%rax)
jmp 0x21147
leaq 0x98(%rsp), %rdi
leaq 0x15d17(%rip), %rsi     # 0x36d1f
callq 0x14070
testb $0x1, %al
jne 0x21013
jmp 0x21026
movq 0xb8(%rsp), %rax
movl $0x40, (%rax)
jmp 0x21145
movb $0x1, 0x36(%rsp)
movl $0xc0, %edi
callq 0xa270
movq %rax, 0x10(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xa9d0
movq 0x18(%rsp), %rdx
leaq 0x15cd1(%rip), %rsi     # 0x36d26
leaq 0x60(%rsp), %rdi
callq 0xa750
jmp 0x21061
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xa9d0
movq 0x8(%rsp), %rdx
leaq 0x1730e(%rip), %rsi     # 0x3838a
leaq 0x38(%rsp), %rdi
callq 0xa750
jmp 0x21088
movq 0x10(%rsp), %rdi
movl $0x22, %esi
leaq 0x60(%rsp), %rdx
leaq 0x38(%rsp), %rcx
xorl %r8d, %r8d
callq 0x1d020
jmp 0x210a6
movq 0x10(%rsp), %rdi
movb $0x0, 0x36(%rsp)
leaq 0x29e91(%rip), %rsi     # 0x4af48
leaq -0x83fe(%rip), %rdx     # 0x18cc0
callq 0xa960
jmp 0x21188
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x21126
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x21112
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xab18
leaq 0x37(%rsp), %rdi
callq 0xa560
leaq 0x60(%rsp), %rdi
callq 0xab18
leaq 0x5f(%rsp), %rdi
callq 0xa560
testb $0x1, 0x36(%rsp)
jne 0x21139
jmp 0x21143
movq 0x10(%rsp), %rdi
callq 0xa3f0
jmp 0x2116e
jmp 0x21147
jmp 0x21149
movq 0xc0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x98(%rsp), %rdi
callq 0xab18
movq (%rsp), %rax
addq $0xc8, %rsp
retq
leaq 0x98(%rsp), %rdi
callq 0xab18
movq 0x90(%rsp), %rdi
callq 0xa9b0
nopl (%rax,%rax)
// File: ALSchwalm[P]entrospy/entrospy/output.cpp
// Function: operator>>(std::istream&, AddressFormat&)
std::istream& operator>>(std::istream& in, AddressFormat& format) {
    std::string token;
    in >> token;
    boost::algorithm::to_lower(token);
    if (token == "dec") {
        format = AddressFormat::DECIMAL;
    } else if (token == "hex") {
        format = AddressFormat::HEX;
    } else {
        throw boost::program_options::validation_error(
            boost::program_options::validation_error::invalid_option,
            "Unknown address format");
    }
    return in;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xa7a0
movq 0x38(%rsp), %rsi
movq 0xd0(%rsp), %rdi
callq 0xa690
jmp 0x3116d
leaq 0x90(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xaaf0
movq 0x30(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x211a0
jmp 0x31193
leaq 0x90(%rsp), %rdi
callq 0xa7c0
leaq 0x7249(%rip), %rsi      # 0x383f0
leaq 0xa8(%rsp), %rdi
callq 0x14070
movb %al, 0x2f(%rsp)
jmp 0x311ba
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x311c4
jmp 0x31216
movq 0xc8(%rsp), %rax
movl $0x0, (%rax)
jmp 0x3136e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x31395
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xa7c0
jmp 0x31395
leaq 0x544e(%rip), %rsi      # 0x3666b
leaq 0xa8(%rsp), %rdi
callq 0x14070
movb %al, 0x2e(%rsp)
jmp 0x31230
movb 0x2e(%rsp), %al
testb $0x1, %al
jne 0x3123a
jmp 0x3124d
movq 0xc8(%rsp), %rax
movl $0x1, (%rax)
jmp 0x3136c
movb $0x1, 0x46(%rsp)
movl $0xc0, %edi
callq 0xa270
movq %rax, 0x18(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xa9d0
movq 0x20(%rsp), %rdx
leaq 0x7178(%rip), %rsi      # 0x383f4
leaq 0x70(%rsp), %rdi
callq 0xa750
jmp 0x31288
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xa9d0
movq 0x10(%rsp), %rdx
leaq 0x70e7(%rip), %rsi      # 0x3838a
leaq 0x48(%rsp), %rdi
callq 0xa750
jmp 0x312af
movq 0x18(%rsp), %rdi
movl $0x22, %esi
leaq 0x70(%rsp), %rdx
leaq 0x48(%rsp), %rcx
xorl %r8d, %r8d
callq 0x1d020
jmp 0x312cd
movq 0x18(%rsp), %rdi
movb $0x0, 0x46(%rsp)
leaq 0x19c6a(%rip), %rsi     # 0x4af48
leaq -0x18625(%rip), %rdx    # 0x18cc0
callq 0xa960
jmp 0x313af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x3134d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x31339
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xab18
leaq 0x47(%rsp), %rdi
callq 0xa560
leaq 0x70(%rsp), %rdi
callq 0xab18
leaq 0x6f(%rsp), %rdi
callq 0xa560
testb $0x1, 0x46(%rsp)
jne 0x31360
jmp 0x3136a
movq 0x18(%rsp), %rdi
callq 0xa3f0
jmp 0x31395
jmp 0x3136e
movq 0xd0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0xab18
movq 0x8(%rsp), %rax
addq $0xd8, %rsp
retq
leaq 0xa8(%rsp), %rdi
callq 0xab18
movq 0xa0(%rsp), %rdi
callq 0xa9b0
nop
// File: ALSchwalm[P]entrospy/entrospy/output.cpp
// Function: address_width(AddressFormat, unsigned long)
uint8_t address_width(AddressFormat format, uint64_t address) {
    switch (format) {
    case AddressFormat::DECIMAL:
        return std::ceil(std::log10(address));
    case AddressFormat::HEX:
        return std::ceil(std::log2(address) / std::log2(16));
    }
    assert(false && "Unknown address format");
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x313d6
jmp 0x313cb
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x313ef
jmp 0x31425
movq 0x18(%rsp), %rdi
callq 0x31790
callq 0xa0a0
cvttsd2si %xmm0, %eax
movb %al, 0x27(%rsp)
jmp 0x31444
movq 0x18(%rsp), %rdi
callq 0x317d0
movsd %xmm0, 0x8(%rsp)
movl $0x10, %edi
callq 0x31810
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0xa0a0
cvttsd2si %xmm0, %eax
movb %al, 0x27(%rsp)
jmp 0x31444
leaq 0x6fdf(%rip), %rdi      # 0x3840b
leaq 0x6ffa(%rip), %rsi      # 0x3842d
movl $0x1f, %edx
leaq 0x7002(%rip), %rcx      # 0x38441
callq 0xa3a0
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ALSchwalm[P]entrospy/entrospy/output.cpp
// Function: print_score(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long, double, PrintingPolicy const&)
void print_score(const std::string& path, uint64_t address,
                 uint64_t address_width, double score,
                 const PrintingPolicy& policy) {
    auto out = boost::format("%1%: %2%: score: %3%");
    out % path;
    out % boost::io::group(address_format_modifier(policy.addr_format),
                           std::setw(address_width), std::setfill('0'),
                           address);
    out % score;
    std::cout << out;
    if (policy.categorize) {
        std::cout << ": category: " << categorize(score, policy);
    }
    std::cout << "\n";
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
movq %rdx, 0x160(%rsp)
movsd %xmm0, 0x158(%rsp)
movq %rcx, 0x150(%rsp)
leaq 0x6fe9(%rip), %rsi      # 0x38470
leaq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd940
movq 0x18(%rsp), %rdi
movq 0x170(%rsp), %rsi
callq 0xdaf0
jmp 0x314aa
movq 0x150(%rsp), %rax
movl 0x18(%rax), %edi
callq 0x318f0
movq %rax, 0x10(%rsp)
jmp 0x314c1
movl 0x160(%rsp), %edi
callq 0x31960
movl %eax, 0xc(%rsp)
jmp 0x314d3
movl 0xc(%rsp), %eax
movl %eax, 0x44(%rsp)
movl $0x30, %edi
callq 0x31980
movb %al, 0xb(%rsp)
jmp 0x314eb
movq 0x10(%rsp), %rsi
movb 0xb(%rsp), %al
movb %al, 0x43(%rsp)
movl 0x44(%rsp), %edx
movzbl 0x43(%rsp), %ecx
leaq 0x48(%rsp), %rdi
leaq 0x168(%rsp), %r8
callq 0x31860
jmp 0x31515
leaq 0x70(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x31830
jmp 0x31526
leaq 0x70(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0x319a0
jmp 0x3153a
movq 0x1aa6f(%rip), %rdi     # 0x4bfb0
leaq 0x70(%rsp), %rsi
callq 0x2f0c0
jmp 0x3154d
movq 0x150(%rsp), %rax
testb $0x1, 0x2(%rax)
je 0x315d7
movq 0x1aa4e(%rip), %rdi     # 0x4bfb0
leaq 0x6f1c(%rip), %rsi      # 0x38485
callq 0xa510
movq %rax, (%rsp)
jmp 0x31574
movsd 0x158(%rsp), %xmm0
movq 0x150(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0xae90
jmp 0x31591
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xa490
jmp 0x315a1
leaq 0x20(%rsp), %rdi
callq 0xab18
jmp 0x315d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x315fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xab18
jmp 0x315fe
movq 0x1a9d2(%rip), %rdi     # 0x4bfb0
leaq 0x6da4(%rip), %rsi      # 0x38389
callq 0xa510
jmp 0x315ec
leaq 0x70(%rsp), %rdi
callq 0xdea0
addq $0x178, %rsp            # imm = 0x178
retq
leaq 0x70(%rsp), %rdi
callq 0xdea0
movq 0x68(%rsp), %rdi
callq 0xa9b0
nopw %cs:(%rax,%rax)
// File: ALSchwalm[P]entrospy/entrospy/output.cpp
// Function: print_score(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double, PrintingPolicy const&)
void print_score(const std::string& path, double score,
                 const PrintingPolicy& policy) {
    std::cout << path << ": score: " << score;
    if (policy.categorize) {
        std::cout << ": category: " << categorize(score, policy);
    }
    std::cout << "\n";
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x50(%rsp), %rsi
movq 0x1a970(%rip), %rdi     # 0x4bfb0
callq 0xa490
movq %rax, %rdi
leaq 0x6e43(%rip), %rsi      # 0x38492
callq 0xa510
movq %rax, %rdi
movsd 0x48(%rsp), %xmm0
callq 0xaa90
movq 0x40(%rsp), %rax
testb $0x1, 0x2(%rax)
je 0x316d4
movq 0x1a93c(%rip), %rdi     # 0x4bfb0
leaq 0x6e0a(%rip), %rsi      # 0x38485
callq 0xa510
movq %rax, (%rsp)
movsd 0x48(%rsp), %xmm0
movq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xae90
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xa490
jmp 0x316ae
leaq 0x20(%rsp), %rdi
callq 0xab18
jmp 0x316d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xab18
jmp 0x316ec
movq 0x1a8d5(%rip), %rdi     # 0x4bfb0
leaq 0x6ca7(%rip), %rsi      # 0x38389
callq 0xa510
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xa9b0
nopw %cs:(%rax,%rax)
// File: ALSchwalm[P]entrospy/entrospy/include/output.hpp
// Function: address_format_modifier(AddressFormat)
inline auto address_format_modifier(AddressFormat format)
    -> decltype(&std::hex) {
    switch (format) {
    case AddressFormat::DECIMAL:
        return std::dec;
    case AddressFormat::HEX:
        return std::hex;
    }
    assert(false && "Unknown address format");
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x31911
jmp 0x31906
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x3191f
jmp 0x3192d
leaq 0xb8(%rip), %rax        # 0x319d0
movq %rax, 0x10(%rsp)
jmp 0x3194c
leaq 0xca(%rip), %rax        # 0x319f0
movq %rax, 0x10(%rsp)
jmp 0x3194c
leaq 0x6ad7(%rip), %rdi      # 0x3840b
leaq 0x6b61(%rip), %rsi      # 0x3849c
movl $0x1e, %edx
leaq 0x6b71(%rip), %rcx      # 0x384b8
callq 0xa3a0
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ALSchwalm[P]entrospy/entrospy/shannon.cpp
// Function: shannon_iterator::shannon_iterator(std::istream&, unsigned long, DataFormat, bool)
shannon_iterator(std::istream& stream, uint64_t block_size,
                     DataFormat format, bool clear_stats = true)
        : m_stream{&stream},
          m_format{format},
          m_block_size{block_size},
          m_block(block_size),
          m_clear_stats{clear_stats},
          m_counter{} {
        this->increment(); // Get meaningful data in the buffer
    }

// Assembly:
subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
andb $0x1, %al
movb %al, 0x3b(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, (%rax)
movl 0x3c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x3a(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x332e0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x332f0
jmp 0x3286a
leaq 0x3a(%rsp), %rdi
callq 0x33370
movq 0x8(%rsp), %rdi
movb 0x3b(%rsp), %al
andb $0x1, %al
movb %al, 0x30(%rdi)
addq $0x38, %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0xa2d0
movq 0x8(%rsp), %rdi
callq 0x33380
jmp 0x3289e
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3a(%rsp), %rdi
callq 0x33370
jmp 0x328d5
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x33490
movq 0x30(%rsp), %rdi
callq 0xa9b0
nop
// File: ALSchwalm[P]entrospy/entrospy/shannon.cpp
// Function: shannon_iterator::increment()
void increment() {
        assert(m_block.capacity() >= m_block_size);

        if (m_stream != nullptr) {
            m_stream->read(reinterpret_cast<char*>(&m_block.front()),
                           m_block_size);
            std::streamsize bytes_read = m_stream->gcount();
            m_block.resize(bytes_read);

            if (m_clear_stats) {
                m_counter.fill(0);
            }
            shannon_digest(m_block.begin(), m_block.end(), m_counter);
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
callq 0x33bc0
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x333a9
jmp 0x333c8
leaq 0x5180(%rip), %rdi      # 0x38530
leaq 0x519c(%rip), %rsi      # 0x38553
movl $0x64, %edx
leaq 0x51a5(%rip), %rcx      # 0x38568
callq 0xa3a0
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x3348b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq %rax, (%rsp)
addq $0x18, %rdi
callq 0x33be0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0xa680
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xaae0
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x18, %rdi
movq 0x28(%rsp), %rsi
callq 0x33c10
movq 0x8(%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x3344d
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
movq $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x33cb0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x33d70
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x18, %rdi
callq 0x33da0
movq 0x8(%rsp), %rdx
movq %rax, 0x10(%rsp)
addq $0x38, %rdx
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x33d00
addq $0x38, %rsp
retq
// File: ALSchwalm[P]entrospy/entrospy/shannon.cpp
// Function: shannon_iterator::dereference() const
double dereference() const {
        assert(m_stream != nullptr);

        if (m_clear_stats) {
            return shannon_score(m_counter, m_block_size, m_format);
        } else {
            // If we have reached eof, seek to end and clear so we can
            // use tellg to get the total bytes read
            if (m_stream->fail()) {
                m_stream->seekg(0, std::ios_base::end);
                m_stream->clear();
            }
            auto bytes_read = m_stream->tellg();
            return shannon_score(m_counter, bytes_read, m_format);
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
je 0x347cb
jmp 0x347ea
leaq 0x3dd3(%rip), %rdi      # 0x385a5
leaq 0x3d7a(%rip), %rsi      # 0x38553
movl $0x79, %edx
leaq 0x3dd4(%rip), %rcx      # 0x385b9
callq 0xa3a0
movq 0x10(%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x34818
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movq 0x10(%rax), %rsi
movl 0x8(%rax), %edx
callq 0x31ed0
movsd %xmm0, 0x30(%rsp)
jmp 0x348ab
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0xa030
testb $0x1, %al
jne 0x34832
jmp 0x3485e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xa730
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0xa950
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xa990
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
addq $0x38, %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x11b70
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edx
callq 0x31ed0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: theolepage[P]prophecy/src/main.cc
// Function: create_dataset(std::vector<Matrix<float>, std::allocator<Matrix<float>>>&, std::vector<Matrix<float>, std::allocator<Matrix<float>>>&)
static void create_dataset(
        training_set& x_train,
        training_set& y_train)
{
    auto a = get_xor(0, 0);
    x_train.emplace_back(a.first);
    y_train.emplace_back(a.second);

    auto b = get_xor(0, 1);
    x_train.emplace_back(b.first);
    y_train.emplace_back(b.second);

    auto c = get_xor(1, 0);
    x_train.emplace_back(c.first);
    y_train.emplace_back(c.second);

    auto d = get_xor(1, 1);
    x_train.emplace_back(d.first);
    y_train.emplace_back(d.second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x128(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x2940
movq -0x128(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x3660
jmp 0x27d9
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3660
jmp 0x27e8
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2940
jmp 0x27fd
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3660
jmp 0x280f
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3660
jmp 0x281e
leaq -0xe0(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2940
jmp 0x2833
movq -0x8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x3660
jmp 0x2845
movq -0x10(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x3660
jmp 0x2857
leaq -0x120(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x2940
jmp 0x286c
movq -0x8(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x3660
jmp 0x287e
movq -0x10(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x3660
jmp 0x2890
leaq -0x120(%rbp), %rdi
callq 0x36e0
leaq -0xe0(%rbp), %rdi
callq 0x36e0
leaq -0xa0(%rbp), %rdi
callq 0x36e0
leaq -0x50(%rbp), %rdi
callq 0x36e0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2914
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2908
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x36e0
leaq -0xe0(%rbp), %rdi
callq 0x36e0
leaq -0xa0(%rbp), %rdi
callq 0x36e0
leaq -0x50(%rbp), %rdi
callq 0x36e0
movq -0x58(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: theolepage[P]prophecy/src/main.cc
// Function: get_xor(unsigned int, unsigned int)
static auto get_xor(unsigned a, unsigned b)
{
    auto mx = Matrix<model_type>(2, 1);
    mx(0, 0) = a;
    mx(1, 0) = b;

    auto my = Matrix<model_type>(1, 1);
    my(0, 0) = a^b;

    return std::make_pair(mx, my);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x2, %esi
movl $0x1, %edx
callq 0x3710
movq -0x78(%rbp), %rdi
movl -0xc(%rbp), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x6c(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x37d0
movq %rax, -0x68(%rbp)
jmp 0x299a
movq -0x68(%rbp), %rax
movss -0x6c(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x10(%rbp), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x94(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x37d0
movq %rax, -0x90(%rbp)
jmp 0x29d0
movq -0x90(%rbp), %rax
movss -0x94(%rbp), %xmm0
movss %xmm0, (%rax)
leaq -0x60(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x3710
jmp 0x29f5
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
xorl %ecx, %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0xa4(%rbp)
leaq -0x60(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x37d0
movq %rax, -0xa0(%rbp)
jmp 0x2a20
movq -0x88(%rbp), %rdi
movq -0xa0(%rbp), %rax
movss -0xa4(%rbp), %xmm0
movss %xmm0, (%rax)
leaq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x3850
jmp 0x2a49
leaq -0x60(%rbp), %rdi
callq 0x34d0
leaq -0x30(%rbp), %rdi
callq 0x34d0
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2a8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x34d0
leaq -0x30(%rbp), %rdi
callq 0x34d0
movq -0x38(%rbp), %rdi
callq 0x2200
nopl (%rax)