LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x20e0
movq %r15, %rsi
callq 0x4642
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4698
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x21f0
movq 0x69c6(%rip), %rsi      # 0xafb8
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x88(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x6995(%rip), %rsi      # 0xafb8
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x88(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x531b(%rip), %r14      # 0xafd8
leaq 0x1864(%rip), %rsi      # 0x7528
movl $0x1c, %edx
movq %r14, %rdi
callq 0x2190
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, 0x8(%rsp)
movq $0x0, 0x10(%rbx)
cmpl $0x0, 0x545e(%rip)      # 0xb170
jle 0x5d84
xorl %ebp, %ebp
movabsq $0x3fc70a3d70a3d70a, %r13 # imm = 0x3FC70A3D70A3D70A
movabsq $0x3fe0000000000000, %rbx # imm = 0x3FE0000000000000
leaq 0x10(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0x7(%rsp), %r12
movq %r13, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x6278
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6a9e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5d7a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
incl %ebp
cmpl 0x53ee(%rip), %ebp      # 0xb170
jl 0x5d39
movq 0x524d(%rip), %r14      # 0xafd8
leaq 0x17b3(%rip), %rsi      # 0x7545
movl $0x1b, %edx
movq %r14, %rdi
callq 0x2190
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq 0x521b(%rip), %rdi      # 0xafd8
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5de0
movq %rax, %r14
jmp 0x5dff
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5dff
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x8(%rsp), %rdi
callq 0x5268
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/gkosae[P]ArduinoNeuralNet/main.cpp
// Function: testNetwork(NeuralNet&)
void testNetwork(NeuralNet& network) {

    vector<double> input_one{25.04, 25, 25, 25, 25, 30, 22, 31, 25, 28};
    vector<double> input_two{34, 31, 26, 22, 21, 35, 22, 31, 25, 18};
    vector<double> input_three{22.04, 35, 29.55, 23, 26, 31, 33, 21, 22, 41};
    vector<double> input_four{50, 50, 50, 50, 50, 50, 50, 50, 50, 50};

    printResults(network, input_one);
    printResults(network, input_two);
    printResults(network, input_three);
    printResults(network, input_four);
}

// Assembly:
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
leaq 0x1755(%rip), %rsi      # 0x7578
leaq 0x70(%rsp), %rax
movl $0xa, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rcx
movl $0xa, %edx
movq %rax, %rsi
callq 0x6278
leaq 0x1777(%rip), %rsi      # 0x75c8
leaq 0x70(%rsp), %rax
movl $0xa, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x40(%rsp), %rdi
leaq 0x28(%rsp), %rcx
movl $0xa, %edx
movq %rax, %rsi
callq 0x6278
leaq 0x1799(%rip), %rsi      # 0x7618
leaq 0x70(%rsp), %rax
movl $0xa, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movl $0xa, %edx
movq %rax, %rsi
callq 0x6278
leaq 0x17bb(%rip), %rsi      # 0x7668
leaq 0x70(%rsp), %rax
movl $0xa, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0xa, %edx
movq %rax, %rsi
callq 0x6278
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x5fe3
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x5fe3
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5fe3
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5fe3
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5f1f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5f36
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x5f4d
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x5f64
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0xc0, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x5f96
movq %rax, %rbx
jmp 0x5fad
movq %rax, %rbx
jmp 0x5fc4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5f96
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5fad
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x5fc4
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x5fdb
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/gkosae[P]ArduinoNeuralNet/main.cpp
// Function: printResults(NeuralNet&, std::vector<double, std::allocator<double>>&)
void printResults(NeuralNet& network, vector<double>& inputs) {

    cout << "Inputs: ";
    for(auto& input : inputs) {
      cout << input << " ";
      input = input/NORMALIZER;
    }

    cout << endl;

    network.feed(inputs);
    network.forward();
    vector<double> outputs = network.getOutputs();

    cout << "Outputs: ";
    for(auto& output : outputs) {
      output = output * NORMALIZER;
      cout << output << " ";
    }

    cout << endl << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x4fda(%rip), %rdi      # 0xafd8
leaq 0x155c(%rip), %rsi      # 0x7561
movl $0x8, %edx
callq 0x2190
movq (%r14), %rbp
movq 0x8(%r14), %r15
cmpq %r15, %rbp
je 0x6061
movq 0x4fb6(%rip), %r12      # 0xafd8
leaq 0x1217(%rip), %r13      # 0x7240
movsd (%rbp), %xmm0
movq %r12, %rdi
callq 0x2200
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2190
movsd (%rbp), %xmm0
divsd 0xfbd(%rip), %xmm0      # 0x7010
movsd %xmm0, (%rbp)
addq $0x8, %rbp
cmpq %r15, %rbp
jne 0x6029
movq 0x4f70(%rip), %r15      # 0xafd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e86
movq 0x18(%rbx), %rdi
movq %r15, %rsi
callq 0x52b6
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x60c2
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x3396
movq 0x20(%rbx), %rsi
addq $-0x30, %rsi
leaq 0x8(%rsp), %rdi
callq 0x2d28
movq 0x4ef5(%rip), %rbx      # 0xafd8
leaq 0x1480(%rip), %rsi      # 0x756a
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2190
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %r13
cmpq %r13, %r12
je 0x6149
movq 0x4ecb(%rip), %r14      # 0xafd8
leaq 0x112c(%rip), %r15      # 0x7240
movsd (%r12), %xmm0
mulsd 0xeee(%rip), %xmm0      # 0x7010
movsd %xmm0, (%r12)
movq %r14, %rdi
callq 0x2200
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
addq $0x8, %r12
cmpq %r13, %r12
jne 0x6114
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq 0x4e71(%rip), %rdi      # 0xafd8
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x61b5
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x61f4
movq 0x30(%rsp), %rsi
jmp 0x61ec
jmp 0x61da
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x61f4
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2de4
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x2de4
movq -0x40(%rbp), %rdx
movb $0x1, %bl
cmpq -0x60(%rbp), %rdx
jne 0x265d
testq %rdx, %rdx
je 0x265b
movq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x2100
testl %eax, %eax
setne %bl
jmp 0x265d
xorl %ebx, %ebx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x2672
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x20f0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2687
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x20f0
testb %bl, %bl
jne 0x26b7
movl 0x20(%r14), %eax
addl %eax, 0x20(%r15)
movsd 0x28(%r14), %xmm0
addsd 0x28(%r15), %xmm0
movsd %xmm0, 0x28(%r15)
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %edi
callq 0x2070
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq %r12, (%rdi)
leaq 0x95f(%rip), %rsi       # 0x3031
leaq 0x963(%rip), %rdx       # 0x303c
callq 0x2edc
leaq -0x68(%rbp), %rdi
movq %r13, (%rdi)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x2de4
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x2de4
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x88(%rbp), %rcx
movq %rbx, %rdi
callq 0x2c98
xorl %r15d, %r15d
leaq 0x263a(%rip), %rsi      # 0x4d70
leaq 0x5f7(%rip), %rdx       # 0x2d34
movq %rbx, %rdi
callq 0x2170
movq %rax, %r14
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x276c
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x20f0
jmp 0x276c
movq %rax, %r14
movb $0x1, %r15b
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x2789
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x20f0
jmp 0x2789
movq %rax, %r14
movb $0x1, %r15b
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x27a6
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x20f0
jmp 0x27a6
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x27cd
movq %rbx, %rdi
callq 0x20b0
jmp 0x27cd
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x27cd
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rdx
movl %edi, %esi
leal -0x6(%rsi), %ebp
cmpl $-0x3, %ebp
jbe 0x4ffe
movq %rsp, %rdi
callq 0x356c
movq %rsp, %rdi
callq 0x4160
movq %rsp, %rdi
callq 0x40e2
xorl %eax, %eax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x3120
movq %rax, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x11ae(%rip), %rsi      # 0x61c9
leaq 0x11c0(%rip), %rdx      # 0x61e2
movq %rsp, %rdi
callq 0x4bf6
movb $0x1, %r12b
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5132
xorl %r12d, %r12d
leaq 0x2d16(%rip), %rsi      # 0x7d58
leaq -0x65f(%rip), %rdx      # 0x49ea
movq %r14, %rdi
callq 0x3340
movq %rdx, %r15
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5078
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
jmp 0x5078
movq %rdx, %r15
movq %rax, %rbx
movb $0x1, %r12b
testb %r12b, %r12b
je 0x509d
movq %r14, %rdi
callq 0x3170
jmp 0x509d
movq %rdx, %r15
movq %rax, %rbx
movq %rsp, %rdi
callq 0x40e2
jmp 0x509d
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x1, %r15d
jne 0x5119
movq %rbx, %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x512c
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x2f2f(%rip), %rdi      # 0x7ff0
callq 0x3260
movq %rsp, %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
cmpl $-0x3, %ebp
ja 0x5102
movq 0x2eeb(%rip), %rdi      # 0x7fd0
leaq 0x10f7(%rip), %rsi      # 0x61e3
movl $0x88, %edx
callq 0x3260
movq 0x2ed3(%rip), %rdi      # 0x7fd0
callq 0x3110
callq 0x3310
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4fec
movq %rax, %rbx
callq 0x3310
movq %rbx, %rdi
callq 0x3360
movq %rax, %rdi
callq 0x4a19
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rsi), %rax
movq -0x18(%rax), %rdi
addq %rsi, %rdi
movl $0xa, %esi
callq 0x31b0
movsbl %al, %edx
leaq -0x80(%rbp), %rsi
movq %r14, %rdi
callq 0x3310
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movl $0x2c, %ecx
callq 0x414a
movq -0x60(%rbp), %rax
movq (%rax), %r12
callq 0x3040
movq %rax, %r14
movl (%rax), %r15d
movl $0x0, (%rax)
leaq -0x38(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x30b0
cmpq %r12, (%r13)
je 0x40d8
movl (%r14), %ecx
testl %ecx, %ecx
movq %rax, -0x40(%rbp)
movq %rbx, -0x48(%rbp)
je 0x3feb
cmpl $0x22, %ecx
jne 0x3fee
leaq 0x221f(%rip), %rdi      # 0x6205
callq 0x3270
movl %r15d, (%r14)
movq -0x60(%rbp), %r12
movq 0x40(%r12), %rbx
movl (%r14), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%r14)
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x30b0
cmpq %rbx, (%r15)
je 0x40e4
movq %rax, %r13
movl (%r14), %eax
testl %eax, %eax
je 0x403c
cmpl $0x22, %eax
jne 0x4042
leaq 0x21ce(%rip), %rdi      # 0x6205
callq 0x3270
movl -0x2c(%rbp), %eax
movl %eax, (%r14)
movq -0x60(%rbp), %rax
movq 0x60(%rax), %rbx
movl (%r14), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x30b0
cmpq %rbx, (%r15)
je 0x40f0
movl (%r14), %ecx
testl %ecx, %ecx
movq -0x48(%rbp), %rbx
je 0x408c
cmpl $0x22, %ecx
jne 0x4092
leaq 0x217e(%rip), %rdi      # 0x6205
callq 0x3270
movl -0x2c(%rbp), %ecx
movl %ecx, (%r14)
addq $0x20, %r12
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x4608
leaq -0x60(%rbp), %rdi
callq 0x4292
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x40c6
callq 0x31a0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2126(%rip), %rdi      # 0x6205
callq 0x3120
leaq 0x211a(%rip), %rdi      # 0x6205
callq 0x3120
leaq 0x210e(%rip), %rdi      # 0x6205
callq 0x3120
movq %rax, %rbx
jmp 0x4122
jmp 0x412d
jmp 0x4105
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x4122
movl -0x2c(%rbp), %eax
movl %eax, (%r14)
jmp 0x4122
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x4122
movl %r15d, (%r14)
leaq -0x60(%rbp), %rdi
callq 0x4292
jmp 0x4130
movq %rax, %rbx
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x4142
callq 0x31a0
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %ecx, %r14d
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x1c8(%rbp), %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x32d0
movsbl %r14b, %r14d
leaq -0x1c8(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x3310
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x41cd
movq %rbx, %rdi
movq %r12, %rsi
callq 0x42e0
jmp 0x41a4
movq 0x4df4(%rip), %rsi      # 0x8fc8
leaq -0x1c8(%rbp), %rdi
callq 0x3260
leaq -0x150(%rbp), %rdi
callq 0x30c0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x41fa
callq 0x31a0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4236
movq %rax, %r14
movq 0x4daa(%rip), %rsi      # 0x8fc8
leaq -0x1c8(%rbp), %rdi
callq 0x3260
leaq -0x150(%rbp), %rdi
callq 0x30c0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4244
callq 0x31a0
movq %rbx, %rdi
callq 0x4292
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq -0x260(%rbp), %rdi
movl $0x10, %edx
callq 0x3320
movq 0x18(%rbx), %r14
movq %rbx, -0x58(%rbp)
leaq 0x8(%rbx), %rax
movq %rax, -0x50(%rbp)
cmpq %rax, %r14
je 0x4813
leaq -0x48(%rbp), %r15
leaq -0x260(%rbp), %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4508
movq %r14, -0x60(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r12, %rdi
callq 0x3210
movq -0x58(%rbp), %rax
movq 0x30(%rax), %r14
movq 0x38(%rax), %r13
cmpq %r13, %r14
je 0x47d4
movq (%r14), %rbx
movl $0x1, %edx
movq %r12, %rdi
leaq 0x1a73(%rip), %rsi      # 0x6225
callq 0x3210
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x8(%rax)
movq %r12, %rdi
movq %rax, %rsi
callq 0x3130
addq $0x8, %r14
jmp 0x479b
movl $0x1, %edx
movq %r12, %rdi
leaq 0x1a44(%rip), %rsi      # 0x6227
callq 0x3210
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
movq -0x60(%rbp), %rbx
je 0x47fe
callq 0x31a0
movq %rbx, %rdi
callq 0x3220
movq %rax, %r14
cmpq -0x50(%rbp), %rax
jne 0x4760
movq 0x47a6(%rip), %rax      # 0x8fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x258(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x260(%rbp,%rcx)
callq 0x3170
leaq -0x168(%rbp), %rdi
callq 0x30c0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4877
jmp 0x4862
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4877
callq 0x31a0
leaq -0x260(%rbp), %rdi
callq 0x3290
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x4508
movq (%r14), %r14
addq $0x8, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4c50
movq %rax, %rcx
testq %rax, %rax
je 0x4bee
movq %rcx, %rax
addq $0x30, %rax
movq %r14, %rdx
subq 0x30(%rcx), %rdx
movq 0x28(%rcx), %rsi
cmpq %rdx, %rsi
cmovaq %rsi, %rdx
movq %rdx, 0x28(%rcx)
jmp 0x4c05
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d7c
movq $0x0, (%rax)
addq $0x8, %rax
movq %r14, (%rax)
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4c16
callq 0x31a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c25
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4c36
callq 0x31a0
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O1/yuryu[P]tfoecho/client.cpp
// Function: main
int main(int argc, char *argv[])
{
    if( argc <= 4 )
    {
        std::cerr << "Usage: client [server addr] [msg size] [count] [thread]" << std::endl;
        return EXIT_FAILURE;
    }
    
    std::string server_addr(argv[1]);
    int msg_size = std::atoi(argv[2]);
    std::atomic_int count(std::atoi(argv[3]));
    int nthreads = std::atoi(argv[4]);

    std::vector<std::thread> threads;
    threads.reserve(nthreads);
    for( int i = 0; i < nthreads; ++i )
        threads.push_back(std::thread(send_recv, server_addr, msg_size, std::ref(count)));
    std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpl $0x4, %edi
jg 0x2931
movq 0x3704(%rip), %rbx      # 0x5ff0
leaq 0x1751(%rip), %rsi      # 0x4044
movl $0x37, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movl $0x1, %eax
jmp 0x2a22
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rdx
callq 0x2af2
movq 0x10(%rbx), %rdi
callq 0x2240
movl %eax, 0x4(%rsp)
movq 0x18(%rbx), %rdi
callq 0x2240
movl %eax, (%rsp)
movq 0x20(%rbx), %rdi
callq 0x2240
movl %eax, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movslq %eax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x2b30
testl %ebx, %ebx
jle 0x29de
leaq 0x8(%rsp), %r15
leaq 0x38(%rsp), %r12
leaq 0x4(%rsp), %r13
leaq 0x30(%rsp), %rbp
leaq 0x10(%rsp), %r14
movq %rsp, %rax
movq %rax, 0x30(%rsp)
movq %r15, %rdi
leaq -0x38f(%rip), %rsi      # 0x262a
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x2bdc
movq %r14, %rdi
movq %r15, %rsi
callq 0x3132
cmpq $0x0, 0x8(%rsp)
jne 0x2a3d
decl %ebx
jne 0x29a7
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x29fb
movq %rbx, %rdi
callq 0x2260
addq $0x8, %rbx
jmp 0x29e8
leaq 0x10(%rsp), %rdi
callq 0x2c88
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a20
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21c0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a42
jmp 0x2a42
cmpq $0x0, 0x8(%rsp)
je 0x2a42
callq 0x2070
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2c88
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a6a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/ALSchwalm[P]entrospy/entrospy/category.cpp
// Function: categorize[abi:cxx11](double, PrintingPolicy const&)
std::string categorize(double score, const PrintingPolicy& policy) {
    if (score > 0.93) {
        return "compressed/random/encrypted";
    } else if (score > 0.8) {
        return "uncompressed binary format";
    } else if (score > 0.65) {
        return "uncompressed text format";
    } else if (score > 0.55) {
        return "text";
    } else if (score > 0.35) {
        return "executable instructions";
    } else {
        return "low entropy format";
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
ucomisd 0xf55c(%rip), %xmm0     # 0x18008
jbe 0x8ac4
movq %rax, (%rbx)
leaq 0xf578(%rip), %rsi      # 0x18030
leaq 0xf58c(%rip), %rdx      # 0x1804b
jmp 0x8b46
ucomisd 0xf544(%rip), %xmm0     # 0x18010
jbe 0x8ae1
movq %rax, (%rbx)
leaq 0xf574(%rip), %rsi      # 0x1804c
leaq 0xf587(%rip), %rdx      # 0x18066
jmp 0x8b46
ucomisd 0xf52f(%rip), %xmm0     # 0x18018
jbe 0x8afe
movq %rax, (%rbx)
leaq 0xf572(%rip), %rsi      # 0x18067
leaq 0xf583(%rip), %rdx      # 0x1807f
jmp 0x8b46
ucomisd 0xf51a(%rip), %xmm0     # 0x18020
jbe 0x8b1b
movq %rax, (%rbx)
leaq 0xf56e(%rip), %rsi      # 0x18080
leaq 0xf56b(%rip), %rdx      # 0x18084
jmp 0x8b46
ucomisd 0xf505(%rip), %xmm0     # 0x18028
movq %rax, (%rbx)
jbe 0x8b38
leaq 0xf556(%rip), %rsi      # 0x18085
leaq 0xf566(%rip), %rdx      # 0x1809c
jmp 0x8b46
leaq 0xf55e(%rip), %rsi      # 0x1809d
leaq 0xf569(%rip), %rdx      # 0x180af
movq %rbx, %rdi
callq 0x8b54
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x8340
movq (%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8c09
callq 0x8370
leaq 0xf66b(%rip), %rsi      # 0x1827b
movq %rsp, %rdi
callq 0x80f0
testl %eax, %eax
je 0x8c3a
leaq 0xf659(%rip), %rsi      # 0x1827c
movq %rsp, %rdi
callq 0x80f0
testl %eax, %eax
je 0x8c3a
movq (%rsp), %rcx
movb $0x1, %al
cmpb $0x2e, (%rcx)
je 0x8c3c
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %r12
callq 0x8050
movq %rax, %r15
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x8550
cmpq %r12, (%r13)
je 0x8d80
movq %rax, %rbx
movl (%r15), %eax
testl %eax, %eax
je 0x8ca0
cmpl $0x22, %eax
jne 0x8ca3
leaq 0xf9b1(%rip), %rdi      # 0x1864c
callq 0x8570
movl %ebp, (%r15)
movq (%r14), %rax
movq 0x8(%r14), %rcx
movsbl -0x1(%rax,%rcx), %edi
callq 0x8580
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x8cce
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x6a, %eax
jg 0x8ce6
cmpl $0x62, %eax
je 0x8cbc
cmpl $0x67, %eax
jne 0x8cfa
imulq $0x7de00000, %rbx, %rbx # imm = 0x7DE00000
jmp 0x8cbc
cmpl $0x6b, %eax
je 0x8d77
cmpl $0x6d, %eax
jne 0x8cfa
shlq $0x14, %rbx
jmp 0x8cbc
movq 0x1a2e7(%rip), %r15     # 0x22fe8
leaq 0xf534(%rip), %rsi      # 0x1823c
movl $0x10, %edx
movq %r15, %rdi
callq 0x8420
movq (%r14), %rax
movq 0x8(%r14), %rcx
movb -0x1(%rax,%rcx), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x8420
movq %rax, %r14
leaq 0xf50f(%rip), %rsi      # 0x1824d
movl $0xf, %edx
movq %rax, %rdi
callq 0x8420
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x8390
movsbl %al, %esi
movq %r14, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x82c0
jmp 0x8cbc
shlq $0xa, %rbx
jmp 0x8cbc
leaq 0xf8c5(%rip), %rdi      # 0x1864c
callq 0x8240
cmpl $0x0, (%r15)
jne 0x8d95
movl %ebp, (%r15)
movq %rax, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %rsi
callq 0x84b0
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x8760
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq %rax, %rcx
leaq 0x48(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq %r15, %rsi
callq 0x1124b
leaq 0x28(%rsp), %rdi
callq 0x8560
leaq 0x7443(%rip), %rsi      # 0x1852c
leaq 0x8(%rsp), %rdi
callq 0x80f0
testl %eax, %eax
je 0x111b2
leaq 0x6f7e(%rip), %rsi      # 0x18080
leaq 0x8(%rsp), %rdi
callq 0x80f0
testl %eax, %eax
je 0x111b9
leaq 0x79a7(%rip), %rsi      # 0x18ac2
leaq 0x8(%rsp), %rdi
callq 0x80f0
movl $0x40, %ecx
testl %eax, %eax
je 0x111be
movl $0xc0, %edi
callq 0x81d0
movq %rax, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x797a(%rip), %rsi      # 0x18ac9
leaq 0x7981(%rip), %rdx      # 0x18ad7
leaq 0x48(%rsp), %rdi
callq 0x8b54
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8c41(%rip), %rdx      # 0x19db1
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x8b54
movb $0x1, %bpl
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
movl $0x22, %esi
xorl %r8d, %r8d
callq 0xee2a
xorl %ebp, %ebp
leaq 0x10ec5(%rip), %rsi     # 0x22068
leaq -0x4e88(%rip), %rdx     # 0xc322
movq %rbx, %rdi
callq 0x8670
movl $0x100, %ecx            # imm = 0x100
jmp 0x111be
movl $0x80, %ecx
movl %ecx, (%r14)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x111d0
callq 0x8370
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x111fc
callq 0x8370
jmp 0x111fc
movq %rax, %r14
movb $0x1, %bpl
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x11213
callq 0x8370
jmp 0x11213
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x11234
movq %rbx, %rdi
callq 0x82f0
jmp 0x11234
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8560
jmp 0x11234
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11243
callq 0x8370
movq %r14, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %rsi
callq 0x84b0
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x8760
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq %rax, %rcx
leaq 0x48(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movq %r15, %rsi
callq 0x1124b
leaq 0x28(%rsp), %rdi
callq 0x8560
leaq 0x3523(%rip), %rsi      # 0x19e18
leaq 0x8(%rsp), %rdi
callq 0x80f0
testl %eax, %eax
je 0x169a5
leaq 0x1b68(%rip), %rsi      # 0x18476
leaq 0x8(%rsp), %rdi
callq 0x80f0
movl $0x1, %ecx
testl %eax, %eax
je 0x169a7
movl $0xc0, %edi
callq 0x81d0
movq %rax, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x34da(%rip), %rsi      # 0x19e1c
leaq 0x34e9(%rip), %rdx      # 0x19e32
leaq 0x48(%rsp), %rdi
callq 0x8b54
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x344e(%rip), %rdx      # 0x19db1
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x8b54
movb $0x1, %bpl
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx, %rdi
movl $0x22, %esi
xorl %r8d, %r8d
callq 0xee2a
xorl %ebp, %ebp
leaq 0xb6d2(%rip), %rsi      # 0x22068
leaq -0xa67b(%rip), %rdx     # 0xc322
movq %rbx, %rdi
callq 0x8670
xorl %ecx, %ecx
movl %ecx, (%r14)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x169b9
callq 0x8370
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x169e5
callq 0x8370
jmp 0x169e5
movq %rax, %r14
movb $0x1, %bpl
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x169fc
callq 0x8370
jmp 0x169fc
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x16a1d
movq %rbx, %rdi
callq 0x82f0
jmp 0x16a1d
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8560
jmp 0x16a1d
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x16a2c
callq 0x8370
movq %r14, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rax
cmpl $0x1, %edi
je 0x16a66
testl %edi, %edi
jne 0x16a9f
movq %rsi, %xmm1
punpckldq 0x33a5(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x33ad(%rip), %xmm1     # 0x19e00
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x81e0
jmp 0x16a94
movq %rsi, %xmm1
punpckldq 0x337d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3385(%rip), %xmm1     # 0x19e00
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x86c0
mulsd 0x337c(%rip), %xmm0     # 0x19e10
callq 0x8090
cvttsd2si %xmm0, %eax
popq %rcx
retq
leaq 0x338d(%rip), %rdi      # 0x19e33
leaq 0x33a8(%rip), %rsi      # 0x19e55
leaq 0x33b5(%rip), %rcx      # 0x19e69
movl $0x1f, %edx
callq 0x8290
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x8(%rsp)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0xc291(%rip), %rdi      # 0x22fb0
callq 0x8420
movq %rax, %r14
leaq 0x318c(%rip), %rsi      # 0x19eba
movl $0x9, %edx
movq %rax, %rdi
callq 0x8420
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x85f0
cmpb $0x1, 0x2(%rbx)
jne 0x16da2
movq 0xc25a(%rip), %r14      # 0x22fb0
leaq 0x3150(%rip), %rsi      # 0x19ead
movl $0xc, %edx
movq %r14, %rdi
callq 0x8420
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
callq 0x8a9c
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x8420
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16da2
callq 0x8370
movq 0xc207(%rip), %rdi      # 0x22fb0
leaq 0x3000(%rip), %rsi      # 0x19db0
movl $0x1, %edx
callq 0x8420
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16dda
callq 0x8370
movq %rbx, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O1/ALSchwalm[P]entrospy/entrospy/shannon.cpp
// Function: shannon_score(std::array<unsigned long, 256ul> const&, unsigned long, DataFormat)
double shannon_score(const counter_t& counts, std::size_t total_size,
                     DataFormat format) {
    const allowed_t* allowed = nullptr;
    switch (format) {
    case DataFormat::DATA:
        allowed = &ALLOWED_DATA;
        break;
    case DataFormat::TEXT:
        allowed = &ALLOWED_TEXT;
        break;
    case DataFormat::BASE64:
        allowed = &ALLOWED_BASE64;
        break;
    }

    double score = 0;
    for (std::size_t index = 0; index < counts.size(); ++index) {
        auto count = counts[index];
        if (count == 0 || !(*allowed)[index])
            continue;
        double p_i = count / static_cast<double>(total_size);
        score += p_i * log2(p_i);
    }

    switch (format) {
    case DataFormat::DATA:
        return std::abs(score) / 8.0;
    case DataFormat::TEXT:
        return std::abs(score) / 7.0;
    case DataFormat::BASE64:
        return std::abs(score) / 6.0;
    }
    return 0.0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rdi, %r14
cmpl $0x40, %edx
je 0x16eaf
cmpl $0x80, %ebx
je 0x16ea6
cmpl $0x100, %ebx            # imm = 0x100
jne 0x16eb8
leaq 0x30b4(%rip), %r15      # 0x19f58
jmp 0x16ebb
leaq 0x31ab(%rip), %r15      # 0x1a058
jmp 0x16ebb
leaq 0x32a2(%rip), %r15      # 0x1a158
jmp 0x16ebb
xorl %r15d, %r15d
movq %rsi, %xmm0
punpckldq 0x2f28(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2f30(%rip), %xmm0     # 0x19e00
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
xorpd %xmm1, %xmm1
xorl %r12d, %r12d
movq (%r14,%r12,8), %rax
testq %rax, %rax
je 0x16f3f
cmpb $0x1, (%r15,%r12)
jne 0x16f3f
movq %rax, %xmm2
punpckldq 0x2eeb(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x2ef3(%rip), %xmm2     # 0x19e00
movapd %xmm2, %xmm0
unpckhpd %xmm2, %xmm0            # xmm0 = xmm0[1],xmm2[1]
addsd %xmm2, %xmm0
divsd (%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
movapd %xmm1, 0x20(%rsp)
callq 0x86c0
movapd 0x20(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm1
incq %r12
cmpq $0x100, %r12            # imm = 0x100
jne 0x16ee8
cmpl $0x40, %ebx
je 0x16f88
cmpl $0x80, %ebx
je 0x16f76
xorpd %xmm0, %xmm0
cmpl $0x100, %ebx            # imm = 0x100
jne 0x16f9c
andpd 0x2fc4(%rip), %xmm1     # 0x19f30
mulsd 0x2fdc(%rip), %xmm1     # 0x19f50
jmp 0x16f98
andpd 0x2fb2(%rip), %xmm1     # 0x19f30
divsd 0x2fc2(%rip), %xmm1     # 0x19f48
jmp 0x16f98
andpd 0x2fa0(%rip), %xmm1     # 0x19f30
divsd 0x2fa8(%rip), %xmm1     # 0x19f40
movapd %xmm1, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movq %rdi, %r14
movq %rsi, (%rdi)
movl %ecx, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
leaq 0x18(%rdi), %rbx
leaq 0xf(%rsp), %rax
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1798c
movb %bpl, 0x30(%r14)
leaq 0x38(%r14), %rdi
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x8210
movq %r14, %rdi
callq 0x179ec
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17298
callq 0x8370
movq %r14, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x17c51
cmpb $0x1, 0x30(%rbx)
jne 0x17c0b
leaq 0x38(%rbx), %rdi
movq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
jmp 0x17c4b
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rdi,%rax)
je 0x17c36
xorl %esi, %esi
movl $0x2, %edx
callq 0x8510
movq (%rbx), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x8660
movq (%rbx), %rdi
callq 0x8680
movl 0x8(%rbx), %edx
addq $0x38, %rbx
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x16e78
leaq 0x2675(%rip), %rdi      # 0x1a2cd
leaq 0x261c(%rip), %rsi      # 0x1a27b
leaq 0x267b(%rip), %rcx      # 0x1a2e1
movl $0x79, %edx
callq 0x8290
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x32ae
movslq 0xc(%r15), %rax
movl 0x8(%r15), %ecx
imull %eax, %ecx
testl %ecx, %ecx
jle 0x2a71
cvtsi2ss %r14d, %xmm0
movq 0x38(%rsp), %rdx
movss %xmm0, (%rdx)
cmpl %ecx, %eax
jge 0x2a71
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movss %xmm0, (%rdx,%rax,4)
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x32ae
movl 0x10(%rsp), %eax
imull 0x14(%rsp), %eax
testl %eax, %eax
jle 0x2a71
leaq 0x8(%rsp), %rdx
movq 0x10(%rdx), %rax
xorl %r14d, %ebp
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movss %xmm0, (%rax)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x350c
leaq 0x60a5(%rip), %r14      # 0x8ae0
movq %r14, 0x8(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2a4f
callq 0x349c
movq %r14, 0x28(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2a63
callq 0x349c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x35e2(%rip), %rdi      # 0x605a
leaq 0x35f9(%rip), %rsi      # 0x6078
leaq 0x3619(%rip), %rcx      # 0x609f
movl $0x79, %edx
callq 0x20d0
movq %rax, %rbx
leaq 0x6046(%rip), %rax      # 0x8ae0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2ab3
callq 0x349c
jmp 0x2ab3
movq %rax, %rbx
leaq 0x6026(%rip), %rax      # 0x8ae0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2ace
callq 0x349c
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::transpose() const
Matrix<T> transpose(void) const
    {
        Matrix trans(cols_, rows_);
        for (int y = 0; y < rows_; ++y)
            for (int x = 0; x < cols_; ++x)
                trans(x, y) = (*this)(y, x);
        return trans;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %esi
callq 0x32ae
cmpl $0x0, 0x8(%r14)
jle 0x3076
xorl %ebp, %ebp
cmpl $0x0, 0xc(%r14)
jle 0x306e
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x502c
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x334e
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rax)
incl %r15d
cmpl 0xc(%r14), %r15d
jl 0x303b
incl %ebp
cmpl 0x8(%r14), %ebp
jl 0x3031
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x5a52(%rip), %rax      # 0x8ae0
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x309f
callq 0x349c
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: operator<<(std::ostream&, Matrix<float>&)
std::ostream& operator<<(std::ostream& os, Matrix& m)
    {
        for (int r = 0; r < m.get_rows(); r++)
        {
            os << m(r, 0);
            for (int c = 1; c < m.get_cols(); c++)
                os << "\t" << m(r, c);
            os << std::endl;
        }
        return os;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %eax
testl %eax, %eax
jle 0x3169
movq %rsi, %r14
xorl %ebp, %ebp
leaq 0x319c(%rip), %r15      # 0x6265
movl 0xc(%r14), %ecx
imull %ecx, %eax
imull %ebp, %ecx
cmpl %eax, %ecx
jge 0x3175
movslq %ecx, %rax
movq 0x10(%r14), %rcx
xorps %xmm0, %xmm0
cvtss2sd (%rcx,%rax,4), %xmm0
movq %rbx, %rdi
callq 0x21d0
cmpl $0x2, 0xc(%r14)
jl 0x3134
movl $0x1, %r12d
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x334e
xorps %xmm0, %xmm0
cvtss2sd (%rax), %xmm0
movq %rbx, %rdi
callq 0x21d0
incl %r12d
cmpl 0xc(%r14), %r12d
jl 0x30ff
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
incl %ebp
movl 0x8(%r14), %eax
cmpl %eax, %ebp
jl 0x30c9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ede(%rip), %rdi      # 0x605a
leaq 0x2ef5(%rip), %rsi      # 0x6078
leaq 0x2f15(%rip), %rcx      # 0x609f
movl $0x79, %edx
callq 0x20d0