LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x10
popq %rdx
callq 0x3310
movq 0x18(%rbx), %r14
movq %rbx, -0x30(%rbp)
leaq 0x8(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq -0x60(%rbp), %r15
cmpq -0x38(%rbp), %r14
je 0x4a29
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x3260
movq %r14, -0x40(%rbp)
leaq -0x260(%rbp), %rdi
movq %r15, %rsi
callq 0x31b0
movq -0x30(%rbp), %rax
movq 0x30(%rax), %r14
movq 0x38(%rax), %r13
cmpq %r13, %r14
je 0x49fd
movq (%r14), %r12
leaq -0x260(%rbp), %rdi
leaq 0x283e(%rip), %rsi      # 0x7215
callq 0x31d0
movq %rax, %rbx
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x8(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3170
addq $0x8, %r14
jmp 0x49c1
leaq -0x260(%rbp), %rdi
leaq 0x280c(%rip), %rsi      # 0x7217
callq 0x31d0
movq %r15, %rdi
callq 0x3120
movq -0x40(%rbp), %rdi
callq 0x3210
movq %rax, %r14
jmp 0x498c
leaq -0x260(%rbp), %rdi
callq 0x32a0
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4a5a
jmp 0x4a4e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3120
leaq -0x260(%rbp), %rdi
callq 0x32a0
movq %rbx, %rdi
callq 0x32f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x3260
movq (%r14), %r14
addq $0x8, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4e6c
movq %rax, %rcx
testq %rax, %rax
je 0x4e18
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 0x4e2c
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x4fa2
andq $0x0, (%rax)
addq $0x8, %rax
movq %r14, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x3120
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4e45
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x32f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26e5
movq 0x3927(%rip), %rdi      # 0x5ff0
leaq 0x1974(%rip), %rsi      # 0x4044
callq 0x2180
movq %rax, %rdi
callq 0x20e0
pushq $0x1
popq %rbx
jmp 0x27c6
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rdx
callq 0x28a8
movq 0x10(%rbx), %rdi
callq 0x2220
movl %eax, 0xc(%rsp)
movq 0x18(%rbx), %rdi
callq 0x2220
movl %eax, 0x8(%rsp)
movq 0x20(%rbx), %rdi
callq 0x2220
movl %eax, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movslq %eax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x28e4
xorl %ebx, %ebx
testl %ebp, %ebp
cmovgl %ebp, %ebx
leaq 0x30(%rsp), %r14
leaq 0x38(%rsp), %r15
leaq 0xc(%rsp), %r12
leaq 0x28(%rsp), %r13
leaq 0x10(%rsp), %rbp
subl $0x1, %ebx
jb 0x2798
leaq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r14, %rdi
leaq -0x27c(%rip), %rsi      # 0x24f9
movq %r15, %rdx
movq %r12, %rcx
movq %r13, %r8
callq 0x2976
movq %rbp, %rdi
movq %r14, %rsi
callq 0x3042
movq %r14, %rdi
callq 0x2a0c
jmp 0x275c
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x3827(%rip), %rdx      # 0x5fd0
xorl %ebx, %ebx
xorl %ecx, %ecx
callq 0x2a19
leaq 0x10(%rsp), %rdi
callq 0x2a62
leaq 0x38(%rsp), %rdi
callq 0x20c0
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27d9
movq %rax, %rbx
jmp 0x27eb
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2a0c
leaq 0x10(%rsp), %rdi
callq 0x2a62
leaq 0x38(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
ucomisd 0xc65c(%rip), %xmm0     # 0x15008
jbe 0x89bc
leaq 0xc67b(%rip), %rsi      # 0x15030
leaq 0xf(%rsp), %rdx
jmp 0x8a28
ucomisd 0xc64c(%rip), %xmm0     # 0x15010
jbe 0x89d4
leaq 0xc67f(%rip), %rsi      # 0x1504c
leaq 0xe(%rsp), %rdx
jmp 0x8a28
ucomisd 0xc63c(%rip), %xmm0     # 0x15018
jbe 0x89ec
leaq 0xc682(%rip), %rsi      # 0x15067
leaq 0xd(%rsp), %rdx
jmp 0x8a28
ucomisd 0xc62c(%rip), %xmm0     # 0x15020
jbe 0x8a04
leaq 0xc683(%rip), %rsi      # 0x15080
leaq 0xc(%rsp), %rdx
jmp 0x8a28
ucomisd 0xc61c(%rip), %xmm0     # 0x15028
jbe 0x8a1c
leaq 0xc670(%rip), %rsi      # 0x15085
leaq 0xb(%rsp), %rdx
jmp 0x8a28
leaq 0xc67a(%rip), %rsi      # 0x1509d
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x8150
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x87d8
leaq 0xc7ed(%rip), %rsi      # 0x1524b
movq %rbx, %rdi
callq 0x965e
testb %al, %al
je 0x8a88
leaq 0xc7db(%rip), %rsi      # 0x1524c
movq %rsp, %rdi
callq 0x965e
testb %al, %al
je 0x8a88
movq (%rsp), %rcx
movb $0x1, %al
cmpb $0x2e, (%rcx)
je 0x8a8a
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x9668
movq %rax, %rbx
movq (%r14), %rax
movq 0x8(%r14), %rcx
movsbl -0x1(%rax,%rcx), %edi
callq 0x85c0
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x8ac8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x62, %eax
je 0x8abd
cmpl $0x6d, %eax
je 0x8ae5
cmpl $0x6b, %eax
je 0x8aeb
cmpl $0x67, %eax
jne 0x8af1
imulq $0x7de00000, %rbx, %rbx # imm = 0x7DE00000
jmp 0x8abd
shlq $0x14, %rbx
jmp 0x8abd
shlq $0xa, %rbx
jmp 0x8abd
movq 0x194f0(%rip), %rdi     # 0x21fe8
leaq 0xc70d(%rip), %rsi      # 0x1520c
callq 0x83b0
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movsbl -0x1(%rcx,%rdx), %esi
movq %rax, %rdi
callq 0x8470
leaq 0xc6fe(%rip), %rsi      # 0x1521d
movq %rax, %rdi
callq 0x83b0
movq %rax, %rdi
callq 0x81c0
jmp 0x8abd
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rsi
callq 0x84c0
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x87b0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xeecc
leaq 0x28(%rsp), %rdi
callq 0x8590
leaq 0x6753(%rip), %rsi      # 0x154fc
leaq 0x8(%rsp), %rdi
callq 0xa85b
movl $0x100, %ecx            # imm = 0x100
testb %al, %al
jne 0xedee
leaq 0x62bd(%rip), %rsi      # 0x15080
leaq 0x8(%rsp), %rdi
callq 0xa85b
movl $0x80, %ecx
testb %al, %al
jne 0xedee
leaq 0x6cb5(%rip), %rsi      # 0x15a92
leaq 0x8(%rsp), %rdi
callq 0xa85b
testb %al, %al
je 0xee09
pushq $0x40
popq %rcx
movl %ecx, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x87d8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xc0, %edi
callq 0x81d0
movq %rax, %rbx
leaq 0x6c7c(%rip), %rsi      # 0x15a99
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8150
leaq 0x7fdf(%rip), %rsi      # 0x16e12
leaq 0x48(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x8150
movb $0x1, %bpl
pushq $0x22
popq %rsi
leaq 0x28(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xd67a
xorl %ebp, %ebp
leaq 0x12182(%rip), %rsi     # 0x20fe8
leaq -0x367f(%rip), %rdx     # 0xb7ee
movq %rbx, %rdi
callq 0x86c0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x87d8
jmp 0xee8a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x87d8
testb %bpl, %bpl
jne 0xee9e
jmp 0xeeba
movq %rax, %r14
movq %rbx, %rdi
callq 0x82f0
jmp 0xeeba
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8590
jmp 0xeeba
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x87d8
movq %r14, %rdi
callq 0x86f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rsi
callq 0x84c0
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x87b0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xeecc
leaq 0x28(%rsp), %rdi
callq 0x8590
leaq 0x397a(%rip), %rsi      # 0x16e80
leaq 0x8(%rsp), %rdi
callq 0xa85b
xorl %ecx, %ecx
testb %al, %al
jne 0x1352e
leaq 0x1f29(%rip), %rsi      # 0x15446
leaq 0x8(%rsp), %rdi
callq 0xa85b
testb %al, %al
je 0x13549
pushq $0x1
popq %rcx
movl %ecx, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x87d8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xc0, %edi
callq 0x81d0
movq %rax, %rbx
leaq 0x3927(%rip), %rsi      # 0x16e84
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8150
leaq 0x389f(%rip), %rsi      # 0x16e12
leaq 0x48(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x8150
movb $0x1, %bpl
pushq $0x22
popq %rsi
leaq 0x28(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xd67a
xorl %ebp, %ebp
leaq 0xda42(%rip), %rsi      # 0x20fe8
leaq -0x7dbf(%rip), %rdx     # 0xb7ee
movq %rbx, %rdi
callq 0x86c0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x87d8
jmp 0x135ca
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x87d8
testb %bpl, %bpl
jne 0x135de
jmp 0x135fa
movq %rax, %r14
movq %rbx, %rdi
callq 0x82f0
jmp 0x135fa
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8590
jmp 0x135fa
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x87d8
movq %r14, %rdi
callq 0x86f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13620
testl %edi, %edi
jne 0x1363b
movq %rsi, %rdi
callq 0x13835
jmp 0x13630
movq %rsi, %rdi
callq 0x1385b
mulsd 0x3820(%rip), %xmm0     # 0x16e50
callq 0x8080
cvttsd2si %xmm0, %eax
popq %rcx
retq
leaq 0x3859(%rip), %rdi      # 0x16e9b
leaq 0x3874(%rip), %rsi      # 0x16ebd
leaq 0x3881(%rip), %rcx      # 0x16ed1
pushq $0x1f
popq %rdx
callq 0x82b0
// File: /workspace/github_cpp_makefile_star2_O2/ALSchwalm[P]entrospy/entrospy/output.cpp
// Function: print_score(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long, double, PrintingPolicy const&)
void print_score(const std::string& path, uint64_t address,
                 uint64_t address_width, double score,
                 const PrintingPolicy& policy) {
    auto out = boost::format("%1%: %2%: score: %3%");
    out % path;
    out % boost::io::group(address_format_modifier(policy.addr_format),
                           std::setw(address_width), std::setfill('0'),
                           address);
    out % score;
    std::cout << out;
    if (policy.categorize) {
        std::cout << ": category: " << categorize(score, policy);
    }
    std::cout << "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
leaq 0x387f(%rip), %rsi      # 0x16f00
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x99b6
movq %r12, %rdi
movq %r15, %rsi
callq 0x1156b
movl 0x18(%rbx), %edi
callq 0x13881
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movl %r14d, 0x8(%rsi)
movb $0x30, 0xc(%rsi)
leaq 0x10(%rsp), %rax
movq %rax, 0x10(%rsi)
leaq 0x38(%rsp), %rdi
callq 0x138d8
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x13996
movq 0xe8d6(%rip), %rdi      # 0x21fb0
leaq 0x38(%rsp), %rsi
callq 0x12d49
cmpb $0x1, 0x2(%rbx)
jne 0x1372a
movq 0xe8bf(%rip), %rdi      # 0x21fb0
leaq 0x381d(%rip), %rsi      # 0x16f15
callq 0x83b0
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x899c
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x8360
leaq 0x18(%rsp), %rdi
callq 0x87d8
movq 0xe87f(%rip), %rdi      # 0x21fb0
leaq 0x36d9(%rip), %rsi      # 0x16e11
callq 0x83b0
leaq 0x38(%rsp), %rdi
callq 0x9c02
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x87d8
jmp 0x1376c
jmp 0x13769
jmp 0x13769
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x9c02
movq %rbx, %rdi
callq 0x86f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe816(%rip), %rdi      # 0x21fb0
callq 0x8360
leaq 0x377c(%rip), %rsi      # 0x16f22
movq %rax, %rdi
callq 0x83b0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x8630
cmpb $0x1, 0x2(%rbx)
jne 0x13803
movq 0xe7e7(%rip), %rdi      # 0x21fb0
leaq 0x3745(%rip), %rsi      # 0x16f15
callq 0x83b0
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
callq 0x899c
movq %r14, %rdi
movq %r15, %rsi
callq 0x8360
leaq 0x10(%rsp), %rdi
callq 0x87d8
movq 0xe7a6(%rip), %rdi      # 0x21fb0
leaq 0x3600(%rip), %rsi      # 0x16e11
callq 0x83b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x87d8
movq %rbx, %rdi
callq 0x86f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13a0b
cmpl $0x80, %ebx
je 0x13a02
cmpl $0x100, %ebx            # imm = 0x100
jne 0x13a14
leaq 0x35b8(%rip), %r15      # 0x16fb8
jmp 0x13a17
leaq 0x36af(%rip), %r15      # 0x170b8
jmp 0x13a17
leaq 0x37a6(%rip), %r15      # 0x171b8
jmp 0x13a17
xorl %r15d, %r15d
movq %rsi, %xmm0
punpckldq 0x343c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x3444(%rip), %xmm0     # 0x16e70
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
xorpd %xmm1, %xmm1
xorl %r12d, %r12d
cmpq $0x100, %r12            # imm = 0x100
je 0x13aa9
movq (%r14,%r12,8), %rax
testq %rax, %rax
je 0x13aa4
cmpb $0x1, (%r15,%r12)
jne 0x13aa4
movq %rax, %xmm2
punpckldq 0x33f6(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x33fe(%rip), %xmm2     # 0x16e70
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 0x8710
movapd 0x20(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm1
incq %r12
jmp 0x13a44
cmpl $0x40, %ebx
je 0x13ae6
cmpl $0x80, %ebx
je 0x13ad4
xorpd %xmm0, %xmm0
cmpl $0x100, %ebx            # imm = 0x100
jne 0x13afa
andpd 0x34c6(%rip), %xmm1     # 0x16f90
mulsd 0x34de(%rip), %xmm1     # 0x16fb0
jmp 0x13af6
andpd 0x34b4(%rip), %xmm1     # 0x16f90
divsd 0x34c4(%rip), %xmm1     # 0x16fa8
jmp 0x13af6
andpd 0x34a2(%rip), %xmm1     # 0x16f90
divsd 0x34aa(%rip), %xmm1     # 0x16fa0
movapd %xmm1, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14188
movb %bpl, 0x30(%r14)
leaq 0x38(%r14), %rdi
movl $0x800, %edx            # imm = 0x800
xorl %esi, %esi
callq 0x8220
movq %r14, %rdi
callq 0x141da
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x142b4
movq %r14, %rdi
callq 0x86f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14513
cmpb $0x1, 0x30(%rbx)
jne 0x144cf
leaq 0x38(%rbx), %rdi
movq 0x10(%rbx), %rsi
movl 0x8(%rbx), %edx
jmp 0x1450d
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rdi,%rax)
je 0x144fb
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x8530
movq (%rbx), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
xorl %esi, %esi
callq 0x86b0
movq (%rbx), %rdi
callq 0x86d0
movl 0x8(%rbx), %edx
addq $0x38, %rbx
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x139d4
leaq 0x2e13(%rip), %rdi      # 0x1732d
leaq 0x2dba(%rip), %rsi      # 0x172db
leaq 0x2e19(%rip), %rcx      # 0x17341
pushq $0x79
popq %rdx
callq 0x82b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x2e1a
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2e9c
cvtsi2ss %r14d, %xmm0
movss %xmm0, (%rax)
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2e9c
cvtsi2ss %ebp, %xmm0
movss %xmm0, (%rax)
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0x2e1a
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2e9c
xorl %r14d, %ebp
cvtsi2ss %ebp, %xmm0
movss %xmm0, (%rax)
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3122
leaq 0x8(%rsp), %rdi
callq 0x2d7e
leaq 0x28(%rsp), %rdi
callq 0x2d7e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27c1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2d7e
jmp 0x27c4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2d7e
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/theolepage[P]prophecy/src/model/model.hh
// Function: Model<float>::compile(float)
void compile(T learning_rate)
    {
        learning_rate_ = learning_rate;
        compiled_ = true;

        if (layers_.size() >= 2)
        {
            int last = layers_.size() - 1;
            layers_[0]->compile(std::weak_ptr<Layer<T>>(), layers_[1]);
            layers_[last]->compile(layers_[last - 1], nullptr);
        }
        for (size_t i = 1; i < layers_.size() - 1; i++)
            layers_[i]->compile(layers_[i - 1], layers_[i + 1]);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movss %xmm0, 0xc(%rdi)
movb $0x1, 0x8(%rdi)
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %r13
subq %rsi, %r13
cmpq $0x11, %r13
jb 0x296f
movq (%rsi), %r14
addq $0x10, %rsi
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x493e
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x20(%rax)
leaq 0x70(%rsp), %rdi
callq 0x30a6
leaq 0x28(%rsp), %rdi
callq 0x3a38
shlq $0x1c, %r13
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
addq %r13, %rax
movq 0x10(%rbx), %rcx
sarq $0x1c, %rax
movq (%rcx,%rax), %r14
movabsq $-0x200000000, %rsi     # imm = 0xFFFFFFFE00000000
addq %r13, %rsi
sarq $0x1c, %rsi
addq %rcx, %rsi
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq 0x4952
leaq 0x10(%rsp), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x20(%rax)
leaq 0x18(%rsp), %rdi
callq 0x30a6
leaq 0x60(%rsp), %rdi
callq 0x3a38
pushq $0x1
popq %r15
pushq $0x20
popq %r14
leaq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %r12
leaq 0x38(%rsp), %r13
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
decq %rcx
cmpq %rcx, %r15
jae 0x29f2
leaq (%rax,%r14), %rsi
addq $-0x20, %rsi
movq 0x10(%rsi), %rbp
movq %r12, %rdi
callq 0x4952
movq 0x10(%rbx), %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x493e
movq (%rbp), %rax
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x20(%rax)
leaq 0x40(%rsp), %rdi
callq 0x30a6
leaq 0x50(%rsp), %rdi
callq 0x3a38
addq $0x10, %r14
incq %r15
jmp 0x298b
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x30a6
leaq 0x60(%rsp), %rax
jmp 0x2a27
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x30a6
leaq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2a3b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30a6
movq 0x8(%rsp), %rdi
callq 0x3a38
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2e1a
xorl %ebp, %ebp
cmpl 0x8(%r14), %ebp
jge 0x2cd0
xorl %r15d, %r15d
cmpl 0xc(%r14), %r15d
jge 0x2ccc
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x45a6
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2e9c
movss 0x4(%rsp), %xmm0
movss %xmm0, (%rax)
incl %r15d
jmp 0x2c97
incl %ebp
jmp 0x2c8e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2d7e
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x25a4(%rip), %r15      # 0x52af
cmpl 0x8(%r14), %ebp
jge 0x2d6b
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2e9c
movss (%rax), %xmm0
movq %rbx, %rdi
callq 0x20e0
pushq $0x1
popq %r12
cmpl 0xc(%r14), %r12d
jge 0x2d5f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2130
movq %rax, %r13
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x2e9c
movss (%rax), %xmm0
movq %r13, %rdi
callq 0x20e0
incl %r12d
jmp 0x2d2d
movq %rbx, %rdi
callq 0x2090
incl %ebp
jmp 0x2d0b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/theolepage[P]prophecy/src/model/../layer/../matrix/matrix.hh
// Function: Matrix<float>::operator=(Matrix<float> const&)
Matrix& operator=(const Matrix<T>& m)
    {
        data_ = m.data_;
        rows_ = m.rows_;
        cols_ = m.cols_;
        return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x340a
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x41fa
leaq 0xb0(%r14), %rsi
movq %r15, %rdi
callq 0x420c
leaq 0x110(%r14), %rsi
leaq 0x48(%rsp), %rdi
callq 0x419e
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x42c6
leaq 0x48(%rsp), %rdi
callq 0x335c
testb %bpl, %bpl
je 0x3cb5
leaq 0x10(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3a72
leaq 0x30(%r14), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3a72
movq 0x80(%r14), %rsi
testq %rsi, %rsi
je 0x3cd5
movq (%rsi), %rax
movzbl %bpl, %ecx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x3ce2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2c3a
leaq 0x8(%rsp), %rdi
callq 0x2d7e
leaq 0x28(%rsp), %rdi
callq 0x2d7e
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2d7e
jmp 0x3d27
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x335c
jmp 0x3d27
jmp 0x3d24
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2d7e
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/theolepage[P]prophecy/src/layer_implem/dense_layer.hh
// Function: DenseLayer<float>::compile(std::weak_ptr<Layer<float>>, std::shared_ptr<Layer<float>>)
void compile(std::weak_ptr<Layer<T>> prev,
                 std::shared_ptr<Layer<T>> next)
    {
        // Initialize weights and biases
        this->weights_ = Matrix<T>(this->nb_neurons_, prev.lock()->get_nb_neurons());
        this->biases_ = Matrix<T>(this->nb_neurons_, 1);
        this->weights_.fill(fill_type::RANDOM_FLOAT);
        this->biases_.fill(fill_type::RANDOM_FLOAT);

        // Initialize delta_weights_ and delta_biases_
        this->delta_weights_ = Matrix<T>(this->nb_neurons_, prev.lock()->get_nb_neurons());
        this->delta_biases_ = Matrix<T>(this->nb_neurons_, 1);

        this->compiled_ = true;
        this->prev_ = prev;
        this->next_ = next;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0xc(%rdi), %ebp
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x47e0
movq (%r12), %rax
movl 0xc(%rax), %edx
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
callq 0x2e1a
leaq 0x90(%r14), %r12
leaq 0x18(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3a72
movq %r13, %rdi
callq 0x2d7e
leaq 0x10(%rsp), %rdi
callq 0x30a6
movl 0xc(%r14), %esi
leaq 0x18(%rsp), %r13
pushq $0x1
popq %rdx
movq %r13, %rdi
callq 0x2e1a
leaq 0xb0(%r14), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3a72
movq %r13, %rdi
callq 0x2d7e
movq %r12, %rdi
xorl %esi, %esi
callq 0x4854
movq %rbp, %rdi
xorl %esi, %esi
callq 0x4854
movl 0xc(%r14), %ebp
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x47e0
movq (%r12), %rax
movl 0xc(%rax), %edx
leaq 0x18(%rsp), %rdi
movl %ebp, %esi
callq 0x2e1a
leaq 0xd0(%r14), %rdi
leaq 0x18(%rsp), %r12
movq %r12, %rsi
callq 0x3a72
movq %r12, %rdi
callq 0x2d7e
leaq 0x10(%rsp), %rdi
callq 0x30a6
movl 0xc(%r14), %esi
leaq 0x18(%rsp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x2e1a
leaq 0xf0(%r14), %rdi
movq %r12, %rsi
callq 0x3a72
movq %r12, %rdi
callq 0x2d7e
movb $0x1, 0x8(%r14)
leaq 0x70(%r14), %rdi
movq %r15, %rsi
callq 0x3a9c
subq $-0x80, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3afa
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4050
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30a6
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x90(%rdi), %r15
xorps 0xfab(%rip), %xmm0      # 0x5030
movaps %xmm0, 0x10(%rsp)
leaq 0xd0(%rdi), %r12
leaq 0xf0(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0xb0(%rdi), %r13
xorl %ebp, %ebp
cmpl 0x98(%rbx), %ebp
jge 0x413a
xorl %r14d, %r14d
cmpl 0x9c(%rbx), %r14d
jge 0x40fb
movq %r12, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2e9c
movss (%rax), %xmm0
mulss 0x10(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq %r15, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x2e9c
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
incl %r14d
jmp 0x40b5
movq 0x8(%rsp), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2e9c
movss (%rax), %xmm0
mulss 0x10(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq %r13, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2e9c
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
incl %ebp
jmp 0x40a6
pushq $0x2
popq %rbx
movq %r12, %rdi
movl %ebx, %esi
callq 0x4854
movq 0x8(%rsp), %rdi
movl %ebx, %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4854
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4282
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
cmpl 0x8(%rsi), %ecx
jne 0x4282
xorl %ebp, %ebp
cmpl %ecx, %ebp
jge 0x4274
xorl %r15d, %r15d
cmpl %eax, %r15d
jge 0x426d
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x45a6
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x2e9c
movss 0x4(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
incl %r15d
movl 0xc(%rbx), %eax
jmp 0x4232
incl %ebp
movl 0x8(%rbx), %ecx
jmp 0x422b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0xeaa(%rip), %rsi       # 0x513e
movq %rax, %rdi
callq 0x2200
movq 0x4d3d(%rip), %rsi      # 0x8fe0
movq 0x4d26(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %ecx
cmpl 0x8(%rsi), %ecx
jne 0x479d
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0x479d
imull %ecx, %eax
movq 0x10(%rsi), %rcx
movq 0x10(%rdi), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpq %rsi, %rax
je 0x4798
movss (%rcx,%rsi,4), %xmm0
mulss (%rdx,%rsi,4), %xmm0
movss %xmm0, (%rdx,%rsi,4)
incq %rsi
jmp 0x477f
movq %rdi, %rax
popq %rcx
retq
pushq $0x8
popq %rdi
callq 0x20a0
leaq 0xa57(%rip), %rcx       # 0x5203
movq %rcx, (%rax)
movq 0x47fa(%rip), %rsi      # 0x8fb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/WojciechMula[P]utf16utf8/benchmarks/benchmark_from_utf16.cpp
// Function: main
int main() {
    // todo: Daniel finds the endless stream of numbers too much
    // Because some schemes use branching, you need to have a sizeable input if you
    // want fair results, given that we repeat the tests many times (we need to account
    // for branch predictors learning the branches).
    std::vector<size_t> input_size{16384};
    for (const size_t size: input_size) {
        Benchmark bench(size);
        bench.run_from_utf16();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x13b8, %rsp           # imm = 0x13B8
leaq 0x28(%rsp), %rbx
leaq 0x10(%rsp), %r14
movq $0x4000, (%rbx)         # imm = 0x4000
pushq $0x1
popq %rdx
leaq 0xf(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4640
movq (%r14), %r15
movq 0x8(%r14), %r12
leaq 0x30(%rsp), %r14
cmpq %r12, %r15
je 0x458d
movq (%r15), %rax
movq %rax, 0x28(%rsp)
movq %r14, %rdi
callq 0x4924
movq %rbx, %rdi
callq 0x4678
movq %r14, %rdi
callq 0x61d0
addq $0x8, %r15
jmp 0x4562
leaq 0x10(%rsp), %rdi
callq 0x623c
xorl %eax, %eax
addq $0x13b8, %rsp           # imm = 0x13B8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x45b8
movq %r14, %rdi
movq %rax, %rbx
callq 0x61d0
leaq 0x10(%rsp), %rdi
callq 0x623c
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/WojciechMula[P]utf16utf8/dependencies/utf8_v2_3_4/source/utf8/checked.h
// Function: std::back_insert_iterator<std::vector<unsigned char, std::allocator<unsigned char>>> utf8::utf16to8<__gnu_cxx::__normal_iterator<unsigned short const*, std::vector<unsigned short, std::allocator<unsigned short>>>, std::back_insert_iterator<std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned short const*, std::vector<unsigned short, std::allocator<unsigned short>>>, __gnu_cxx::__normal_iterator<unsigned short const*, std::vector<unsigned short, std::allocator<unsigned short>>>, std::back_insert_iterator<std::vector<unsigned char, std::allocator<unsigned char>>>)
octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
    {
        while (start != end) {
            uint32_t cp = utf8::internal::mask16(*start++);
            // Take care of surrogate pairs first
            if (utf8::internal::is_lead_surrogate(cp)) {
                if (start != end) {
                    uint32_t trail_surrogate = utf8::internal::mask16(*start++);
                    if (utf8::internal::is_trail_surrogate(trail_surrogate))
                        cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
                    else
                        throw invalid_utf16(static_cast<uint16_t>(trail_surrogate));
                }
                else
                    throw invalid_utf16(static_cast<uint16_t>(cp));

            }
            // Lone trail surrogate
            else if (utf8::internal::is_trail_surrogate(cp))
                throw invalid_utf16(static_cast<uint16_t>(cp));

            result = utf8::append(cp, result);
        }
        return result;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rax
movq %rsi, %rbx
cmpq %rbx, %rdi
je 0x6019
movzwl (%rdi), %ebp
leaq 0x2(%rdi), %r14
movzwl %bp, %ecx
movl %ecx, %edx
andl $0xfc00, %edx           # imm = 0xFC00
cmpl $0xd800, %edx           # imm = 0xD800
je 0x5fdd
cmpl $0xdc00, %edx           # imm = 0xDC00
jne 0x600a
jmp 0x601e
cmpq %rbx, %r14
je 0x601e
movzwl (%r14), %ebp
movzwl %bp, %edx
movl %edx, %esi
andl $0xfc00, %esi           # imm = 0xFC00
cmpl $0xdc00, %esi           # imm = 0xDC00
jne 0x601e
shll $0xa, %ecx
addq $0x4, %rdi
leal -0x35fdc00(%rcx,%rdx), %ecx
movq %rdi, %r14
movl %ecx, %edi
movq %rax, %rsi
callq 0x604a
movq %r14, %rdi
jmp 0x5fb4
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq 0x9fab(%rip), %rdx      # 0xffd8
leaq 0x9d1c(%rip), %rcx      # 0xfd50
leaq 0x9ced(%rip), %rsi      # 0xfd28
movq %rax, %rdi
movq %rcx, (%rax)
movw %bp, 0x8(%rax)
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/cpottamus[P]btree_lab/makedisk.cc
// Function: main
int main(int argc, char *argv[])
{
  if (argc<10) { 
    usage();
    exit(-1);
  }

  DiskSystem disk(argv[1],
		  true,
		  0,
		  atoi(argv[2]),
		  atoi(argv[3]),
		  atoi(argv[4]),
		  atoi(argv[5]),
		  atoi(argv[6]),
		  atof(argv[7]),
		  atof(argv[8]),
		  atof(argv[9]));
  
  
  cerr << "Disk is as follows.\n" << disk << "\n";

  cerr << "Done.\n";

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
cmpl $0x9, %edi
jle 0x2622
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2658
movq 0x10(%rbx), %rdi
callq 0x22c0
movl %eax, %ebp
movq 0x18(%rbx), %rdi
callq 0x22c0
movl %eax, %r15d
movq 0x20(%rbx), %rdi
callq 0x22c0
movl %eax, %r14d
movq 0x28(%rbx), %rdi
callq 0x22c0
movl %eax, %r12d
movq 0x30(%rbx), %rdi
callq 0x22c0
movl %eax, %r13d
movq 0x38(%rbx), %rdi
callq 0x2230
movsd %xmm0, 0x10(%rsp)
movq 0x40(%rbx), %rdi
callq 0x2230
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rbx), %rdi
callq 0x2230
movaps %xmm0, %xmm2
subq $0x8, %rsp
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x1
popq %rdx
xorl %ecx, %ecx
movl %ebp, %r8d
movl %r15d, %r9d
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
pushq %r13
pushq %r12
pushq %r14
callq 0x272c
addq $0x20, %rsp
leaq 0x18(%rsp), %rdi
callq 0x20a0
movq 0x4a27(%rip), %rdi      # 0x6ff0
leaq 0x1a94(%rip), %rsi      # 0x4064
callq 0x2170
leaq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x374a
leaq 0x1c53(%rip), %rsi      # 0x423c
movq %rax, %rdi
callq 0x2170
movq 0x49f8(%rip), %rdi      # 0x6ff0
leaq 0x1a7a(%rip), %rsi      # 0x4079
callq 0x2170
leaq 0x38(%rsp), %rdi
callq 0x2b3a
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24dc
pushq $-0x1
popq %rdi
callq 0x2210
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20a0
jmp 0x2650
movq %rax, %rbx
jmp 0x2650
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2b3a
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/tokuhirom[P]nanouri/t/02_escape.cc
// Function: main
int main() {
    std::string src;

    src = "hello\x01\x02";
    is(nanouri::escape_uri(src), std::string("hello%01%02"), "escape");

    src = "hi\xff";
    is(nanouri::escape_uri(src), std::string("hi%ff"), "escape");

    done_testing();
}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x785(%rip), %rsi       # 0x3058
leaq 0x10(%rsp), %rdi
callq 0x21e0
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x231c
leaq 0x76a(%rip), %rsi       # 0x3060
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x29ea
leaq 0x760(%rip), %rdx       # 0x306c
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2600
leaq 0x70(%rsp), %rdi
callq 0x2090
leaq 0x90(%rsp), %rdi
callq 0x2090
leaq 0x737(%rip), %rsi       # 0x3073
leaq 0x10(%rsp), %rdi
callq 0x21e0
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x231c
leaq 0x71b(%rip), %rsi       # 0x3077
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x29ea
leaq 0x6fa(%rip), %rdx       # 0x306c
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2600
leaq 0x30(%rsp), %rdi
callq 0x2090
leaq 0x50(%rsp), %rdi
callq 0x2090
callq 0x255e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2090
jmp 0x29ac
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x29cd
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2090
jmp 0x29c5
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x2090
jmp 0x29d7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtmidi_build/RtMidi.cpp
// Function: MidiInAlsa::~MidiInAlsa()
MidiInAlsa :: ~MidiInAlsa()
{
  // Close a connection if it exists.
  closePort();

  // Shutdown the input thread.
  AlsaMidiData *data = static_cast<AlsaMidiData *> (apiData_);
  if ( inputData_.doInput ) {
    inputData_.doInput = false;
    int res = write( data->trigger_fds[1], &inputData_.doInput, sizeof(inputData_.doInput) );
    (void) res;
    if ( !pthread_equal(data->thread, data->dummy_thread_id) )
      pthread_join( data->thread, NULL );
  }

  // Cleanup.
  close ( data->trigger_fds[0] );
  close ( data->trigger_fds[1] );
  if ( data->vport >= 0 ) snd_seq_delete_port( data->seq, data->vport );
#ifndef AVOID_TIMESTAMPING
  snd_seq_free_queue( data->seq, data->queue_id );
#endif
  snd_seq_close( data->seq );
  delete data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x88e7(%rip), %rax      # 0x10fb0
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x7840
movq 0x8(%rbx), %r14
cmpb $0x1, 0x89(%rbx)
jne 0x8716
leaq 0x89(%rbx), %rsi
movb $0x0, (%rsi)
movl 0x50(%r14), %edi
pushq $0x1
popq %rdx
callq 0x70f0
movq 0x30(%r14), %r15
movq 0x38(%r14), %rsi
movq %r15, %rdi
callq 0x79d0
testl %eax, %eax
jne 0x8716
movq %r15, %rdi
xorl %esi, %esi
callq 0x73e0
movl 0x4c(%r14), %edi
callq 0x7b20
movl 0x50(%r14), %edi
callq 0x7b20
movl 0xc(%r14), %esi
testl %esi, %esi
js 0x8738
movq (%r14), %rdi
callq 0x75c0
movq (%r14), %rdi
movl 0x48(%r14), %esi
callq 0x7250
movq (%r14), %rdi
callq 0x7760
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x7490
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x7670
movq %rax, %rdi
callq 0xa2d3