LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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), %rbx
movq %rbx, -0x10(%rbx)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2dfe
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x2dfe
movq -0x40(%rbp), %rdx
cmpq -0x60(%rbp), %rdx
jne 0x265c
movq -0x68(%rbp), %rbx
testq %rdx, %rdx
je 0x2665
movq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x2100
testl %eax, %eax
setne %r12b
jmp 0x2668
movb $0x1, %r12b
movq -0x68(%rbp), %rbx
jmp 0x2668
xorl %r12d, %r12d
cmpq %r13, %rbx
je 0x267c
movq -0x58(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x20f0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rbx
cmpq %rbx, %rdi
je 0x2695
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x20f0
testb %r12b, %r12b
jne 0x26c6
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 %rbx, %rcx
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq %rcx, (%rdi)
leaq 0x94d(%rip), %rsi       # 0x3031
leaq 0x951(%rip), %rdx       # 0x303c
callq 0x2efa
leaq -0x68(%rbp), %rdi
movq %r13, (%rdi)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x2dfe
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x2dfe
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
leaq -0x88(%rbp), %rcx
movq %rbx, %rdi
callq 0x2cb2
xorl %r15d, %r15d
leaq 0x2627(%rip), %rsi      # 0x4d70
leaq 0x5fe(%rip), %rdx       # 0x2d4e
movq %rbx, %rdi
callq 0x2170
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x277b
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x20f0
jmp 0x277b
movq %rax, %r14
movb $0x1, %r15b
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x2790
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x20f0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x27a9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x20f0
testb %r15b, %r15b
jne 0x27d1
jmp 0x27f3
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x27d1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x20f0
jmp 0x27d1
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
jmp 0x27f3
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x27f3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4fe6
movq %rsp, %rdi
callq 0x356c
movq %rsp, %rdi
callq 0x4186
movq %rsp, %rdi
callq 0x4108
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, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x11c5(%rip), %rsi      # 0x61c9
leaq 0x11d7(%rip), %rdx      # 0x61e2
movq %rsp, %rdi
callq 0x4c06
movb $0x1, %r13b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5116
xorl %r13d, %r13d
leaq 0x2d2d(%rip), %rsi      # 0x7d58
leaq -0x642(%rip), %rdx      # 0x49f0
movq %rbx, %rdi
callq 0x3340
movq %rdx, %r15
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5056
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3230
testb %r13b, %r13b
jne 0x5063
jmp 0x5083
movq %rdx, %r15
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
jmp 0x5083
movq %rdx, %r15
movq %rax, %r14
movq %rsp, %rdi
callq 0x4108
jmp 0x5083
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x50ff
movq %r14, %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x5110
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x2f49(%rip), %rdi      # 0x7ff0
callq 0x3260
movq %rsp, %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
cmpl $-0x3, %ebp
ja 0x50e8
movq 0x2f05(%rip), %rdi      # 0x7fd0
leaq 0x1111(%rip), %rsi      # 0x61e3
movl $0x88, %edx
callq 0x3260
movq 0x2eed(%rip), %rdi      # 0x7fd0
callq 0x3110
callq 0x3310
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4fd4
movq %rax, %r14
callq 0x3310
movq %r14, %rdi
callq 0x3360
movq %rax, %rdi
callq 0x4a1f
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x78(%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 -0x88(%rbp), %rsi
movq %r14, %rdi
callq 0x3310
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
movl $0x2c, %ecx
callq 0x411e
movq -0x68(%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 0x409c
movl (%r14), %r13d
testl %r13d, %r13d
movq %rbx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
je 0x3faf
cmpl $0x22, %r13d
jne 0x3fb5
leaq 0x225b(%rip), %rdi      # 0x6205
callq 0x3270
movl %r15d, (%r14)
movl %r15d, %r13d
movq -0x68(%rbp), %r12
movq 0x40(%r12), %rbx
movl $0x0, (%r14)
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x30b0
cmpq %rbx, (%r15)
je 0x40a8
movl (%r14), %ecx
testl %ecx, %ecx
movq %rax, -0x40(%rbp)
je 0x4001
movl %ecx, -0x2c(%rbp)
cmpl $0x22, %ecx
jne 0x4008
leaq 0x2209(%rip), %rdi      # 0x6205
callq 0x3270
movl %r13d, (%r14)
movl %r13d, -0x2c(%rbp)
movq -0x68(%rbp), %rax
movq 0x60(%rax), %rbx
movl $0x0, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x30b0
cmpq %rbx, (%r15)
je 0x40b4
movl (%r14), %ecx
testl %ecx, %ecx
movq -0x50(%rbp), %rbx
je 0x404c
cmpl $0x22, %ecx
jne 0x4052
leaq 0x21be(%rip), %rdi      # 0x6205
callq 0x3270
movl -0x2c(%rbp), %ecx
movl %ecx, (%r14)
addq $0x20, %r12
movq %rbx, %rdi
movq -0x48(%rbp), %rsi
movq %r12, %rdx
movq -0x40(%rbp), %rcx
movq %rax, %r8
callq 0x45b8
leaq -0x68(%rbp), %rdi
callq 0x4266
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x408a
callq 0x31a0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2162(%rip), %rdi      # 0x6205
callq 0x3120
leaq 0x2156(%rip), %rdi      # 0x6205
callq 0x3120
leaq 0x214a(%rip), %rdi      # 0x6205
callq 0x3120
movq %rax, %rbx
jmp 0x40f2
jmp 0x40fd
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x40f2
movl -0x2c(%rbp), %eax
movl %eax, (%r14)
jmp 0x40f2
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x40f2
movl %r13d, (%r14)
jmp 0x40f2
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x40f2
movl %r15d, (%r14)
leaq -0x68(%rbp), %rdi
callq 0x4266
jmp 0x4100
movq %rax, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x4115
callq 0x31a0
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x41a1
movq %rbx, %rdi
movq %r12, %rsi
callq 0x42be
jmp 0x4178
movq 0x4e20(%rip), %rsi      # 0x8fc8
leaq -0x1c8(%rbp), %rdi
callq 0x3260
leaq -0x150(%rbp), %rdi
callq 0x30c0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x41ce
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 0x420a
movq %rax, %r14
movq 0x4dd6(%rip), %rsi      # 0x8fc8
leaq -0x1c8(%rbp), %rdi
callq 0x3260
leaq -0x150(%rbp), %rdi
callq 0x30c0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x4218
callq 0x31a0
movq %rbx, %rdi
callq 0x4266
movq %r14, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x47c3
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 0x44b4
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 0x4784
movq (%r14), %rbx
movl $0x1, %edx
movq %r12, %rdi
leaq 0x1ac3(%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 0x474b
movl $0x1, %edx
movq %r12, %rdi
leaq 0x1a94(%rip), %rsi      # 0x6227
callq 0x3210
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
movq -0x60(%rbp), %rbx
je 0x47ae
callq 0x31a0
movq %rbx, %rdi
callq 0x3220
movq %rax, %r14
cmpq -0x50(%rbp), %rax
jne 0x4710
movq 0x47f6(%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 0x4827
jmp 0x4812
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4827
callq 0x31a0
leaq -0x260(%rbp), %rdi
callq 0x3290
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x44b4
movq (%r14), %r14
addq $0x8, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4bf8
movq %rax, %rcx
testq %rax, %rax
je 0x4b96
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 0x4bad
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d24
movq $0x0, (%rax)
addq $0x8, %rax
movq %r14, (%rax)
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4bbe
callq 0x31a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4bcd
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4bde
callq 0x31a0
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x290d
movq 0x3728(%rip), %rbx      # 0x5ff0
leaq 0x17b1(%rip), %rsi      # 0x4080
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 0x29fe
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rdx
callq 0x2ace
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 0x2b0c
testl %ebx, %ebx
jle 0x29ba
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 -0x391(%rip), %rsi      # 0x2604
movq %r12, %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x2bb8
movq %r14, %rdi
movq %r15, %rsi
callq 0x3130
cmpq $0x0, 0x8(%rsp)
jne 0x2a19
decl %ebx
jne 0x2983
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x29d7
movq %rbx, %rdi
callq 0x2260
addq $0x8, %rbx
jmp 0x29c4
leaq 0x10(%rsp), %rdi
callq 0x2c54
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29fc
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 0x2a1e
jmp 0x2a1e
cmpq $0x0, 0x8(%rsp)
je 0x2a1e
callq 0x2070
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2c54
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a46
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8c11
callq 0x8370
leaq 0xf663(%rip), %rsi      # 0x1827b
movq %rsp, %rdi
callq 0x80f0
testl %eax, %eax
je 0x8c42
leaq 0xf651(%rip), %rsi      # 0x1827c
movq %rsp, %rdi
callq 0x80f0
testl %eax, %eax
je 0x8c42
movq (%rsp), %rcx
movb $0x1, %al
cmpb $0x2e, (%rcx)
je 0x8c44
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d88
movq %rax, %rbx
movl (%r15), %eax
testl %eax, %eax
je 0x8ca8
cmpl $0x22, %eax
jne 0x8cab
leaq 0xf9a9(%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 0x8cd6
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x6a, %eax
jg 0x8cee
cmpl $0x62, %eax
je 0x8cc4
cmpl $0x67, %eax
jne 0x8d02
imulq $0x7de00000, %rbx, %rbx # imm = 0x7DE00000
jmp 0x8cc4
cmpl $0x6b, %eax
je 0x8d7f
cmpl $0x6d, %eax
jne 0x8d02
shlq $0x14, %rbx
jmp 0x8cc4
movq 0x1a2df(%rip), %r15     # 0x22fe8
leaq 0xf52c(%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 0xf507(%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 0x8cc4
shlq $0xa, %rbx
jmp 0x8cc4
leaq 0xf8bd(%rip), %rdi      # 0x1864c
callq 0x8240
cmpl $0x0, (%r15)
jne 0x8d9d
movl %ebp, (%r15)
movq %rax, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x110c1
leaq 0x28(%rsp), %rdi
callq 0x8560
leaq 0x75d6(%rip), %rsi      # 0x1852c
leaq 0x8(%rsp), %rdi
callq 0x80f0
testl %eax, %eax
je 0x1101f
leaq 0x7111(%rip), %rsi      # 0x18080
leaq 0x8(%rsp), %rdi
callq 0x80f0
testl %eax, %eax
je 0x11026
leaq 0x7a76(%rip), %rsi      # 0x189fe
leaq 0x8(%rsp), %rdi
callq 0x80f0
movl $0x40, %ecx
testl %eax, %eax
je 0x1102b
movl $0xc0, %edi
callq 0x81d0
movq %rax, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7a49(%rip), %rsi      # 0x18a05
leaq 0x7a50(%rip), %rdx      # 0x18a13
leaq 0x48(%rsp), %rdi
callq 0x8b54
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8c8f(%rip), %rdx      # 0x19c6c
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 0xecec
xorl %ebp, %ebp
leaq 0x110a0(%rip), %rsi     # 0x220b0
leaq -0x4d95(%rip), %rdx     # 0xc282
movq %rbx, %rdi
callq 0x8670
movl $0x100, %ecx            # imm = 0x100
jmp 0x1102b
movl $0x80, %ecx
movl %ecx, (%r14)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1103d
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 0x11061
callq 0x8370
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x11070
callq 0x8370
testb %bpl, %bpl
jne 0x1108e
jmp 0x110aa
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1108e
callq 0x8370
jmp 0x1108e
movq %rax, %r14
movq %rbx, %rdi
callq 0x82f0
jmp 0x110aa
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8560
jmp 0x110aa
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x110b9
callq 0x8370
movq %r14, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x110c1
leaq 0x28(%rsp), %rdi
callq 0x8560
leaq 0x3467(%rip), %rsi      # 0x19cd8
leaq 0x8(%rsp), %rdi
callq 0x80f0
testl %eax, %eax
je 0x16921
leaq 0x1bec(%rip), %rsi      # 0x18476
leaq 0x8(%rsp), %rdi
callq 0x80f0
movl $0x1, %ecx
testl %eax, %eax
je 0x16923
movl $0xc0, %edi
callq 0x81d0
movq %rax, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x341e(%rip), %rsi      # 0x19cdc
leaq 0x342d(%rip), %rdx      # 0x19cf2
leaq 0x48(%rsp), %rdi
callq 0x8b54
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x338d(%rip), %rdx      # 0x19c6c
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 0xecec
xorl %ebp, %ebp
leaq 0xb79e(%rip), %rsi      # 0x220b0
leaq -0xa697(%rip), %rdx     # 0xc282
movq %rbx, %rdi
callq 0x8670
xorl %ecx, %ecx
movl %ecx, (%r14)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x16935
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 0x16959
callq 0x8370
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x16968
callq 0x8370
testb %bpl, %bpl
jne 0x16986
jmp 0x169a2
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x16986
callq 0x8370
jmp 0x16986
movq %rax, %r14
movq %rbx, %rdi
callq 0x82f0
jmp 0x169a2
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8560
jmp 0x169a2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x169b1
callq 0x8370
movq %r14, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x169eb
testl %edi, %edi
jne 0x16a24
movq %rsi, %xmm1
punpckldq 0x32e0(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x32e8(%rip), %xmm1     # 0x19cc0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x81e0
jmp 0x16a19
movq %rsi, %xmm1
punpckldq 0x32b8(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x32c0(%rip), %xmm1     # 0x19cc0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x86c0
mulsd 0x32b7(%rip), %xmm0     # 0x19cd0
callq 0x8090
cvttsd2si %xmm0, %eax
popq %rcx
retq
leaq 0x32c8(%rip), %rdi      # 0x19cf3
leaq 0x32e3(%rip), %rsi      # 0x19d15
leaq 0x32f0(%rip), %rcx      # 0x19d29
movl $0x1f, %edx
callq 0x8290
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc30c(%rip), %rdi      # 0x22fb0
callq 0x8420
movq %rax, %r14
leaq 0x30c7(%rip), %rsi      # 0x19d7a
movl $0x9, %edx
movq %rax, %rdi
callq 0x8420
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x85f0
cmpb $0x1, 0x2(%rbx)
jne 0x16d27
movq 0xc2d5(%rip), %r14      # 0x22fb0
leaq 0x308b(%rip), %rsi      # 0x19d6d
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 0x16d27
callq 0x8370
movq 0xc282(%rip), %rdi      # 0x22fb0
leaq 0x2f36(%rip), %rsi      # 0x19c6b
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 0x16d5f
callq 0x8370
movq %rbx, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16e2f
cmpl $0x80, %ebx
je 0x16e26
cmpl $0x100, %ebx            # imm = 0x100
jne 0x16e38
leaq 0x2ff4(%rip), %r15      # 0x19e18
jmp 0x16e3b
leaq 0x30eb(%rip), %r15      # 0x19f18
jmp 0x16e3b
leaq 0x31e2(%rip), %r15      # 0x1a018
jmp 0x16e3b
xorl %r15d, %r15d
movq %rsi, %xmm0
punpckldq 0x2e68(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x2e70(%rip), %xmm0     # 0x19cc0
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 0x16ebf
cmpb $0x1, (%r15,%r12)
jne 0x16ebf
movq %rax, %xmm2
punpckldq 0x2e2b(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x2e33(%rip), %xmm2     # 0x19cc0
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 0x16e68
cmpl $0x40, %ebx
je 0x16f08
cmpl $0x80, %ebx
je 0x16ef6
xorpd %xmm0, %xmm0
cmpl $0x100, %ebx            # imm = 0x100
jne 0x16f1c
andpd 0x2f04(%rip), %xmm1     # 0x19df0
mulsd 0x2f1c(%rip), %xmm1     # 0x19e10
jmp 0x16f18
andpd 0x2ef2(%rip), %xmm1     # 0x19df0
divsd 0x2f02(%rip), %xmm1     # 0x19e08
jmp 0x16f18
andpd 0x2ee0(%rip), %xmm1     # 0x19df0
divsd 0x2ee8(%rip), %xmm1     # 0x19e00
movapd %xmm1, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17908
movb %bpl, 0x30(%r14)
leaq 0x38(%r14), %rdi
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x8210
movq %r14, %rdi
callq 0x17968
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17218
callq 0x8370
movq %r14, %rdi
callq 0x86a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17bbf
cmpb $0x1, 0x30(%rbx)
jne 0x17b79
leaq 0x38(%rbx), %rdi
movq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
jmp 0x17bb9
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rdi,%rax)
je 0x17ba7
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 0x16df8
leaq 0x25c7(%rip), %rdi      # 0x1a18d
leaq 0x256e(%rip), %rsi      # 0x1a13b
leaq 0x25cd(%rip), %rcx      # 0x1a1a1
movl $0x79, %edx
callq 0x8290
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3332
movslq 0xc(%r15), %rax
movl 0x8(%r15), %ecx
imull %eax, %ecx
testl %ecx, %ecx
jle 0x2af0
cvtsi2ss %r14d, %xmm0
movq 0x38(%rsp), %rdx
movss %xmm0, (%rdx)
cmpl %ecx, %eax
jge 0x2af0
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movss %xmm0, (%rdx,%rax,4)
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x3332
movl 0x10(%rsp), %eax
imull 0x14(%rsp), %eax
testl %eax, %eax
jle 0x2af0
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 0x357c
leaq 0x605b(%rip), %rbx      # 0x8b18
movq %rbx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2ad1
callq 0x350c
movq %rbx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2ae5
callq 0x350c
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3583(%rip), %rdi      # 0x607a
leaq 0x359a(%rip), %rsi      # 0x6098
leaq 0x35ba(%rip), %rcx      # 0x60bf
movl $0x79, %edx
callq 0x20d0
movq %rax, %rbx
leaq 0x5fff(%rip), %rax      # 0x8b18
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2b32
callq 0x350c
jmp 0x2b32
movq %rax, %rbx
leaq 0x5fdf(%rip), %rax      # 0x8b18
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2b4d
callq 0x350c
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3332
movl 0x8(%r14), %ecx
testl %ecx, %ecx
jle 0x30f5
movl 0xc(%r14), %eax
xorl %ebp, %ebp
testl %eax, %eax
jle 0x30ef
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x4e84
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x33ce
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rax)
incl %r15d
movl 0xc(%r14), %eax
cmpl %eax, %r15d
jl 0x30b5
movl 0x8(%r14), %ecx
incl %ebp
cmpl %ecx, %ebp
jl 0x30ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x5a0b(%rip), %rax      # 0x8b18
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x311e
callq 0x350c
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31e8
movq %rsi, %r14
xorl %ebp, %ebp
leaq 0x313d(%rip), %r15      # 0x6285
movl 0xc(%r14), %ecx
imull %ecx, %eax
imull %ebp, %ecx
cmpl %eax, %ecx
jge 0x31f4
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 0x31b3
movl $0x1, %r12d
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x33ce
xorps %xmm0, %xmm0
cvtss2sd (%rax), %xmm0
movq %rbx, %rdi
callq 0x21d0
incl %r12d
cmpl 0xc(%r14), %r12d
jl 0x317e
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 0x3148
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e7f(%rip), %rdi      # 0x607a
leaq 0x2e96(%rip), %rsi      # 0x6098
leaq 0x2eb6(%rip), %rcx      # 0x60bf
movl $0x79, %edx
callq 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/theolepage[P]prophecy/src/layer_implem/dense_layer.hh
// Function: DenseLayer<float>::feedforward(Matrix<float> const&, bool)
Matrix<T> feedforward(const Matrix<T>& input, bool training)
    {
        auto z = Matrix<T>::dot(this->weights_, input);
        z += this->biases_;
        auto a = z.map(this->activation_.f_);

        if (training)
        {
            this->last_a_ = a;
            this->last_z_ = z;
        }

        if (this->next_ == nullptr)
            return a;
        return this->next_->feedforward(a, training);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x90, %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x2, %ecx
callq 0x4b88
leaq 0xb0(%r14), %rsi
movq %r15, %rdi
callq 0x49f0
leaq 0x110(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x4954
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x4ab0
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x41d4
leaq 0x48(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
testb %bpl, %bpl
je 0x421b
leaq 0x20(%rsp), %r15
movq -0x8(%r15), %rax
movq %rax, 0x20(%r14)
leaq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x38c6
movq -0x10(%r15), %rax
movq %rax, 0x18(%r14)
leaq 0x40(%rsp), %r15
movq -0x8(%r15), %rax
movq %rax, 0x40(%r14)
leaq 0x48(%r14), %rdi
movq %r15, %rsi
callq 0x38c6
movq -0x10(%r15), %rax
movq %rax, 0x38(%r14)
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0x423b
movq (%rsi), %rax
movzbl %bpl, %ecx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x426e
leaq 0x48d6(%rip), %rax      # 0x8b18
movq %rax, (%rbx)
leaq 0x18(%rbx), %rdi
movq $0x0, 0x18(%rbx)
leaq 0x20(%rsp), %r14
movq -0x8(%r14), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rsi
callq 0x38c6
movq -0x10(%r14), %rax
movq %rax, 0x8(%rbx)
leaq 0x48a3(%rip), %r14      # 0x8b18
movq %r14, 0x8(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4289
callq 0x350c
movq %r14, 0x28(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x429d
callq 0x350c
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x4863(%rip), %rax      # 0x8b18
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x42f8
callq 0x350c
jmp 0x42f8
jmp 0x42eb
movq %rax, %rbx
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x42f8
leaq 0x48(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x42f8
movq %rax, %rdi
callq 0x34a8
jmp 0x42f5
movq %rax, %rbx
leaq 0x4819(%rip), %rax      # 0x8b18
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4313
callq 0x350c
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/theolepage[P]prophecy/src/layer_implem/dense_layer.hh
// Function: DenseLayer<float>::update(float)
void update(T learning_rate)
    {
        // Update weights_ and biases_
        for (int i = 0; i < this->weights_.get_rows(); i++)
        {
            for (int j = 0; j < this->weights_.get_cols(); j++)
                this->weights_(i, j) -= learning_rate * this->delta_weights_(i, j);
            this->biases_(i, 0) -= learning_rate * this->delta_biases_(i, 0);
        }

        // Reset delta_weights_ and delta_biases_
        this->delta_weights_.fill(fill_type::ZERO);
        this->delta_biases_.fill(fill_type::ZERO);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x98(%rdi)
jle 0x4903
leaq 0x90(%rbx), %r14
leaq 0xd0(%rbx), %r15
xorps 0x17ed(%rip), %xmm0     # 0x6030
movl 0x9c(%rbx), %eax
xorl %ebp, %ebp
movaps %xmm0, 0x10(%rsp)
testl %eax, %eax
jle 0x489d
xorl %r12d, %r12d
movq %r15, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x33ce
movss (%rax), %xmm0
mulss 0x10(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x33ce
movss 0xc(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
incl %r12d
movl 0x9c(%rbx), %eax
cmpl %eax, %r12d
jl 0x4857
movaps 0x10(%rsp), %xmm0
movl 0xfc(%rbx), %edx
movl %edx, %ecx
imull %ebp, %ecx
imull 0xf8(%rbx), %edx
cmpl %edx, %ecx
jge 0x4934
movl 0xbc(%rbx), %esi
movl %esi, %edx
imull %ebp, %edx
imull 0xb8(%rbx), %esi
cmpl %esi, %edx
jge 0x4934
movq 0xc0(%rbx), %rsi
movq 0x100(%rbx), %rdi
movslq %ecx, %rcx
movslq %edx, %rdx
movss (%rdi,%rcx,4), %xmm1
mulss %xmm0, %xmm1
addss (%rsi,%rdx,4), %xmm1
movss %xmm1, (%rsi,%rdx,4)
incl %ebp
cmpl 0x98(%rbx), %ebp
jl 0x4850
leaq 0xd0(%rbx), %rdi
movl $0x2, %esi
callq 0x5080
addq $0xf0, %rbx
movq %rbx, %rdi
movl $0x2, %esi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5080
leaq 0x173f(%rip), %rdi      # 0x607a
leaq 0x1756(%rip), %rsi      # 0x6098
leaq 0x1776(%rip), %rcx      # 0x60bf
movl $0x79, %edx
callq 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::operator+=(Matrix<float> const&)
Matrix<T>& operator+=(const Matrix &right)
    {
        if (cols_ != right.cols_ || rows_ != right.rows_)
            throw std::invalid_argument("+ on Matrix need same width and height");
        for (int i = 0; i < rows_; ++i)
        {
            for (int j = 0; j < cols_; ++j)
                (*this)(i, j) += right(i, j);
        }
        return *this;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0x4a6a
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
cmpl 0x8(%rsi), %ecx
jne 0x4a6a
testl %ecx, %ecx
jle 0x4a5c
xorl %ebp, %ebp
testl %eax, %eax
jle 0x4a56
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x4e84
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x33ce
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
incl %r15d
movl 0xc(%rbx), %eax
cmpl %eax, %r15d
jl 0x4a1a
movl 0x8(%rbx), %ecx
incl %ebp
cmpl %ecx, %ebp
jl 0x4a13
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x16e0(%rip), %rsi      # 0x615e
movq %rax, %rdi
callq 0x2220
movq 0x4553(%rip), %rsi      # 0x8fe0
movq 0x453c(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x21f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O3/theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::multiply_inplace(Matrix<float> const&)
Matrix<T>& multiply_inplace(const Matrix& b)
    {
        if (rows_ != b.rows_ || cols_ != b.cols_)
            throw "Invalid matrix shape";

        for (int i = 0; i < rows_ * cols_; i++)
            data_[i] *= b.data_[i];

        return *this;
    }

// Assembly:
pushq %rax
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x505a
movl 0xc(%rdi), %edx
cmpl 0xc(%rsi), %edx
jne 0x505a
imull %eax, %edx
testl %edx, %edx
jle 0x5055
movq 0x10(%rsi), %rax
movq 0x10(%rdi), %rcx
movl %edx, %edx
xorl %esi, %esi
movss (%rax,%rsi,4), %xmm0
mulss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x503e
movq %rdi, %rax
popq %rcx
retq
movl $0x8, %edi
callq 0x20a0
leaq 0x11b8(%rip), %rcx      # 0x6223
movq %rcx, (%rax)
movq 0x3f3b(%rip), %rsi      # 0x8fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::fill(fill_type)
void fill(fill_type type)
    {
        assert(data_ != nullptr);
        switch(type)
        {
            case fill_type::RANDOM_FLOAT:
                for (int i = 0; i < rows_ * cols_; ++i)
                    data_[i] = get_random_float();
                break;
            case fill_type::SEQUENCE:
                for (int i = 0; i < rows_ * cols_; ++i)
                    data_[i] = i;
                break;
            case fill_type::ZERO:
                for (int i = 0; i < rows_ * cols_; ++i)
                    data_[i] = static_cast<T>(0);
                break;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x51cc
testl %esi, %esi
je 0x517c
cmpl $0x1, %esi
je 0x50cd
cmpl $0x2, %esi
jne 0x51c4
movl 0xc(%rbx), %eax
imull 0x8(%rbx), %eax
testl %eax, %eax
jle 0x51c4
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20c0
movl 0xc(%rbx), %eax
imull 0x8(%rbx), %eax
testl %eax, %eax
jle 0x51c4
movl %eax, %ecx
incl %eax
andl $-0x2, %eax
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0xf48(%rip), %xmm1      # 0x6040
xorl %ecx, %ecx
movdqa 0xf2e(%rip), %xmm2      # 0x6030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0xf3e(%rip), %xmm4      # 0x6050
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edx
notl %edx
testb $0x1, %dl
je 0x514f
xorps %xmm6, %xmm6
cvtsi2ss %ecx, %xmm6
movss %xmm6, (%rdi,%rcx,4)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x516d
leal 0x1(%rcx), %edx
xorps %xmm5, %xmm5
cvtsi2ss %edx, %xmm5
movss %xmm5, 0x4(%rdi,%rcx,4)
addq $0x2, %rcx
paddq %xmm4, %xmm1
cmpq %rcx, %rax
jne 0x5112
jmp 0x51c4
movl 0xc(%rbx), %eax
imull 0x8(%rbx), %eax
testl %eax, %eax
jle 0x51c4
xorl %r14d, %r14d
callq 0x2050
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0xe6e(%rip), %xmm0      # 0x600c
addss 0xe6a(%rip), %xmm0      # 0x6010
movq 0x10(%rbx), %rax
movss %xmm0, (%rax,%r14,4)
incq %r14
movslq 0x8(%rbx), %rax
movslq 0xc(%rbx), %rcx
imulq %rax, %rcx
cmpq %rcx, %r14
jl 0x518a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xfb2(%rip), %rdi       # 0x6185
leaq 0xebe(%rip), %rsi       # 0x6098
leaq 0x1057(%rip), %rcx      # 0x6238
movl $0x4e, %edx
callq 0x20d0