LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/brashi[P]PetFera/src/animal/anfibio/anfibio.cpp
// Function: Anfibio::setPata()
bool Anfibio::setPata() {
    string s;
    cout << endl << "Anfíbio possui pata? (S/N): " << endl;
    getline(cin, s);

    if(toupper(s[0]) == 'S')
        this->pata = true;
    else if(toupper(s[0]) == 'N')
        this->pata = false;
    else
        return false;

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0xd2fa(%rip), %rdi      # 0x2afd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %esi
movq 0xd2df(%rip), %rdi      # 0x2afd0
callq 0x5030
movq %rax, %rdi
callq 0x51c0
movq %rax, %r14
leaq 0x3c12(%rip), %rsi      # 0x2191a
movl $0x1d, %edx
movq %rax, %rdi
callq 0x5310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x51c0
movq 0xd29d(%rip), %rdi      # 0x2afe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x5280
movsbl %al, %edx
movq 0xd282(%rip), %rdi      # 0x2afe0
movq %rsp, %rsi
callq 0x5480
movq (%rsp), %r14
movsbl (%r14), %edi
callq 0x5490
cmpl $0x4e, %eax
je 0x1dd83
movb $0x1, %cl
cmpl $0x53, %eax
je 0x1dd85
xorl %ebx, %ebx
jmp 0x1dd8d
xorl %ecx, %ecx
movb %cl, 0x8a(%rbx)
movb $0x1, %bl
cmpq %r15, %r14
je 0x1dda2
movq 0x10(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x52b0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1ddc7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52b0
movq %rbx, %rdi
callq 0x5460
nop
// File: /workspace/github_cpp_makefile_star2_O3/rhoot[P]sp/tests/../include/sp.hpp
// Function: sp::StringWriter::write(unsigned long, void const*)
size_t write(size_t length, const void* data) override
        {
            if (m_length >= 0) {
                m_length += int32_t(length);

                if (m_size) {
                    const auto toCopy = std::min(size_t(m_size), length);
                    std::memcpy(m_buffer, data, toCopy);
                    m_buffer += toCopy;
                    m_size -= int32_t(toCopy);
                    return toCopy;
                }
            }

            return 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x14(%rdi), %eax
testl %eax, %eax
js 0xf1d4
movq %rsi, %rbx
movq %rdi, %r14
addl %ebx, %eax
movl %eax, 0x14(%rdi)
movslq 0x10(%rdi), %rax
testq %rax, %rax
je 0xf1d4
cmpq %rbx, %rax
cmovbq %rax, %rbx
movq 0x8(%r14), %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x1060
addq %rbx, 0x8(%r14)
subl %ebx, 0x10(%r14)
jmp 0xf1d6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rhoot[P]sp/tests/../include/sp.hpp
// Function: bool sp::format_index<char, int, char, int>(sp::IWriter&, sp::StringView const&, int, char&&, int&&, char&&, int&&)
bool format_index(IWriter& writer, const StringView& format, int32_t index, Arg&& arg, Rest&&... rest)
    {
        if (!index) {
            return format_value(writer, format, std::forward<Arg>(arg));
        } else {
            return format_index(writer, format, index - 1, std::forward<Rest>(rest)...);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testl %edx, %edx
je 0x103ab
movq 0x10(%rbp), %rax
decl %edx
movq %rbx, %rdi
movq %r8, %rcx
movq %r9, %r8
movq %rax, %r9
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1040c
movsbq (%rcx), %r14
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movb $0x0, 0xc(%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0xf81b
testb %al, %al
je 0x10401
cmpb $0x0, -0x14(%rbp)
jne 0x103e4
movb $0x63, -0x14(%rbp)
cmpb $0x0, -0x1f(%rbp)
jne 0x103ee
movb $0x3c, -0x1f(%rbp)
movl %r14d, %ecx
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xfa7d
jmp 0x10403
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rhoot[P]sp/tests/../include/sp.hpp
// Function: sp::format_value(sp::IWriter&, sp::StringView const&, sp::StringView const&)
inline bool format_value(IWriter& writer, const StringView& fmt, const StringView& value)
    {
        FormatFlags flags;

        return parse_format(fmt, &flags)
            ? format_string(writer, flags, value)
            : false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x48(%rbp), %rsi
movq %rcx, (%rsi)
movl $0xffffffff, 0x8(%rsi)  # imm = 0xFFFFFFFF
movb $0x0, 0xc(%rsi)
movq %rax, %rdi
callq 0xf81b
movl %eax, %r12d
testb %al, %al
je 0x10cf1
movl 0x8(%r15), %ecx
movl -0x44(%rbp), %eax
movl -0x40(%rbp), %edx
cmpl %edx, %ecx
movl %edx, %esi
cmovll %ecx, %esi
testl %edx, %edx
cmovsl %ecx, %esi
cmpl %esi, %eax
cmovlel %esi, %eax
movzbl -0x47(%rbp), %ecx
cmpl $0x3e, %ecx
je 0x10c54
cmpl $0x5e, %ecx
jne 0x10ca7
movq %r15, -0x38(%rbp)
movl %eax, %r15d
shrl $0x1f, %r15d
addl %eax, %r15d
sarl %r15d
leal 0x1(%rsi), %ecx
shrl $0x1f, %ecx
addl %esi, %ecx
incl %ecx
sarl %ecx
subl %ecx, %r15d
leal 0x1(%rax), %ecx
shrl $0x1f, %ecx
leal (%rax,%rcx), %r14d
incl %r14d
sarl %r14d
movl %esi, %ecx
shrl $0x1f, %ecx
addl %esi, %ecx
sarl %ecx
andl %esi, %eax
andl $0x1, %eax
addl %eax, %r15d
addl %ecx, %eax
subl %eax, %r14d
jmp 0x10c60
movq %r15, -0x38(%rbp)
subl %esi, %eax
xorl %r14d, %r14d
movl %eax, %r15d
movl -0x48(%rbp), %eax
testb %al, %al
movl $0x20, %r13d
cmovnel %eax, %r13d
testl %r15d, %r15d
je 0x10cbd
movq %rsi, -0x50(%rbp)
movb %r12b, -0x2a(%rbp)
leaq -0x29(%rbp), %r12
movb %r13b, -0x29(%rbp)
movq (%rbx), %rax
movl $0x1, %esi
movq %rbx, %rdi
movq %r12, %rdx
callq *(%rax)
decl %r15d
jne 0x10c80
movb -0x2a(%rbp), %r12b
movq -0x38(%rbp), %r15
movq -0x50(%rbp), %rsi
jmp 0x10cc1
subl %esi, %eax
movl -0x48(%rbp), %ecx
testb %cl, %cl
movl $0x20, %r13d
cmovnel %ecx, %r13d
movl %eax, %r14d
jmp 0x10cc1
movq -0x38(%rbp), %r15
movslq %esi, %rsi
movq (%r15), %rdx
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
testl %r14d, %r14d
je 0x10cf1
leaq -0x29(%rbp), %r15
movb %r13b, -0x29(%rbp)
movq (%rbx), %rax
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq *(%rax)
decl %r14d
jne 0x10cd8
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rhoot[P]sp/tests/../include/sp.hpp
// Function: sp::format_value(sp::IWriter&, sp::StringView const&, bool)
inline bool format_value(IWriter& writer, const StringView& fmt, bool value)
    {
        FormatFlags flags;

        if (parse_format(fmt, &flags)) {
            switch (flags.type) {
                case 'b':
                case 'c':
                case 'd':
                case 'o':
                case 'x':
                case 'X':
                    return format_int(writer, flags, false, (uint64_t)value);
                default:
                    return format_string(writer, flags, value ? "true" : "false");
            }
        }

        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movq %rsi, %rax
movq %rdi, %rbx
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x3c(%rbp), %rsi
movq %rcx, (%rsi)
movl $0xffffffff, 0x8(%rsi)  # imm = 0xFFFFFFFF
movb $0x0, 0xc(%rsi)
movq %rax, %rdi
callq 0xf81b
testb %al, %al
je 0x11e56
movzbl -0x30(%rbp), %eax
addl $-0x58, %eax
cmpl $0x20, %eax
ja 0x11e6b
movabsq $0x100801c01, %rcx      # imm = 0x100801C01
btq %rax, %rcx
jae 0x11e6b
movzbl %r15b, %ecx
leaq -0x3c(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xfa7d
movl %eax, %r14d
jmp 0x11e59
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7a32(%rip), %rax      # 0x198a4
leaq 0x8108(%rip), %rdx      # 0x19f81
testb %r15b, %r15b
cmovneq %rax, %rdx
movzbl %r15b, %ecx
xorl $0x5, %ecx
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %esi
cmpl %esi, %ecx
movl %esi, %edi
cmovll %ecx, %edi
testl %esi, %esi
cmovsl %ecx, %edi
cmpl %edi, %eax
cmovlel %edi, %eax
movzbl -0x3b(%rbp), %ecx
cmpl $0x3e, %ecx
je 0x11ef4
cmpl $0x5e, %ecx
jne 0x11f3f
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
leal 0x1(%rdi), %ecx
shrl $0x1f, %ecx
addl %edi, %ecx
incl %ecx
sarl %ecx
subl %ecx, %r14d
leal 0x1(%rax), %ecx
shrl $0x1f, %ecx
leal (%rax,%rcx), %r13d
incl %r13d
sarl %r13d
movl %edi, %ecx
shrl $0x1f, %ecx
addl %edi, %ecx
sarl %ecx
andl %edi, %eax
andl $0x1, %eax
addl %eax, %r14d
addl %ecx, %eax
subl %eax, %r13d
jmp 0x11efc
subl %edi, %eax
xorl %r13d, %r13d
movl %eax, %r14d
movl -0x3c(%rbp), %eax
testb %al, %al
movl $0x20, %r12d
cmovnel %eax, %r12d
testl %r14d, %r14d
je 0x11f53
movq %rdi, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x29(%rbp), %r15
movb %r12b, -0x29(%rbp)
movq (%rbx), %rax
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq *(%rax)
decl %r14d
jne 0x11f1c
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rdi
jmp 0x11f53
subl %edi, %eax
movl -0x3c(%rbp), %ecx
testb %cl, %cl
movl $0x20, %r12d
cmovnel %ecx, %r12d
movl %eax, %r13d
movslq %edi, %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movb $0x1, %r14b
testl %r13d, %r13d
je 0x11e59
leaq -0x29(%rbp), %r15
movb %r12b, -0x29(%rbp)
movq (%rbx), %rax
movl $0x1, %esi
movq %rbx, %rdi
movq %r15, %rdx
callq *(%rax)
decl %r13d
jne 0x11f6e
jmp 0x11e59
// File: /workspace/github_cpp_makefile_star2_O3/rhoot[P]sp/tests/../include/sp.hpp
// Function: bool sp::format_value<void>(sp::IWriter&, sp::StringView const&, void*)
bool format_value(IWriter& writer, const StringView& fmt, T* value)
    {
        FormatFlags flags;

        if (parse_format(fmt, &flags)) {
            if (!flags.type) {
                flags.type = 'x';
            }

            return format_int(writer, flags, false, uint64_t(value));
        }

        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
leaq -0x20(%rbp), %rsi
movq %rcx, (%rsi)
movl $0xffffffff, 0x8(%rsi)  # imm = 0xFFFFFFFF
movb $0x0, 0xc(%rsi)
movq %rax, %rdi
callq 0xf81b
testb %al, %al
je 0x164cf
cmpb $0x0, -0x14(%rbp)
jne 0x164bc
movb $0x78, -0x14(%rbp)
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xfa7d
jmp 0x164d1
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AlanReviews[P]Goblet-of-fire/Control.cc
// Function: Control::drawParticipant(std::vector<Participant, std::allocator<Participant>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Control::drawParticipant(vector<Participant> candidates, string school) {
    int candidateNum = rand() % candidates.size();
    while (candidates[candidateNum].getSchool() != school) {
        candidateNum = rand() % candidates.size();
    }
    candidates[candidateNum].displayInfo();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
callq 0x2040
cltq
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rdx, %rsi
xorl %edx, %edx
divq %rsi
leaq 0x8(%rsp), %r15
movslq %edx, %rax
leaq (%rax,%rax,8), %r12
leaq (%rcx,%r12,8), %rsi
movq %r15, %rdi
callq 0x3400
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x245e
movq 0x8(%rsp), %r13
testq %rdx, %rdx
je 0x2468
movq (%r14), %rsi
movq %r13, %rdi
callq 0x2170
testl %eax, %eax
setne %bpl
jmp 0x246a
movb $0x1, %bpl
movq 0x8(%rsp), %r13
jmp 0x246a
xorl %ebp, %ebp
leaq 0x18(%rsp), %rax
cmpq %rax, %r13
je 0x2484
movq 0x18(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x2160
testb %bpl, %bpl
je 0x24b6
callq 0x2040
cltq
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rdx, %rsi
xorl %edx, %edx
divq %rsi
jmp 0x2423
shlq $0x3, %r12
addq (%rbx), %r12
movq %r12, %rdi
callq 0x3424
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AlanReviews[P]Goblet-of-fire/View.cc
// Function: View::displayMenu(int&)
void View::displayMenu(int& choice)
{
  cout << "Welcome to the Goblet of Fire"<< endl;
  cout << "Remember, when you enter your name, you must participate in the Triwizard Tournament otherwise your magic will be gone" << endl;
  cout << "  1. Enter a participant:" << endl;
  cout << "  2. Draw out:" << endl;
  cout << "  0. Exit" << endl<<endl;

  cout << "Enter your selection: ";
  cin >> choice;
  if (choice == 0)
    return;

  while (choice < 0 || choice > 2) {
    cout << "Enter your selection: ";
    cin >> choice;
  }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x2a4a(%rip), %r14      # 0x5fd0
leaq 0xc24(%rip), %rsi       # 0x41b1
movl $0x1d, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0xc07(%rip), %rsi       # 0x41cf
movl $0x76, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0xc43(%rip), %rsi       # 0x4246
movl $0x19, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0xc22(%rip), %rsi       # 0x4260
movl $0xe, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0xbf6(%rip), %rsi       # 0x426f
movl $0x9, %edx
movq %r14, %rdi
callq 0x2180
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2140
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0xb9b(%rip), %rsi       # 0x4279
movl $0x16, %edx
movq %r14, %rdi
callq 0x2180
movq 0x28ee(%rip), %rdi      # 0x5fe0
movq %rbx, %rsi
callq 0x20b0
cmpl $0x3, (%rbx)
jb 0x3734
movq 0x28ca(%rip), %r14      # 0x5fd0
leaq 0xb6c(%rip), %r15       # 0x4279
movq 0x28cc(%rip), %r12      # 0x5fe0
movl $0x16, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq %r12, %rdi
movq %rbx, %rsi
callq 0x20b0
cmpl $0x2, (%rbx)
ja 0x3714
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::LoadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<unsigned char, std::allocator<unsigned char>>&)
bool LoadFile(const std::string* path, std::vector<unsigned char>& buffer) {
        std::ifstream file(path->c_str(), std::fstream::binary);

        if (file) {
            std::noskipws(file);

            file.seekg(0, file.end);
            uint64_t len = file.tellg();
            file.seekg(0, file.beg);

            buffer.resize(len, 0u);
            std::copy(std::istream_iterator<unsigned char>(file),
                      std::istream_iterator<unsigned char>(),
                      &buffer[0]);

            file.close();
            return true;
        }

        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x2340
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x40(%rsp,%rax), %ebp
testb $0x5, %bpl
jne 0x2792
andb $-0x11, 0x39(%rsp,%rax)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2270
leaq 0x20(%rsp), %rdi
callq 0x2310
movq %rax, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2270
movq %rsp, %rdx
movb $0x0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b24
leaq 0x10(%rsp), %rdi
movq %r15, (%rdi)
movb $0x1, 0x9(%rdi)
callq 0x492e
movq (%rbx), %r14
movq 0x10(%rsp), %rax
movb 0x18(%rsp), %cl
movb 0x19(%rsp), %dl
movq %rax, (%rsp)
movb %cl, 0x8(%rsp)
movb %dl, 0x9(%rsp)
testb %dl, %dl
je 0x2788
movq %rsp, %rbx
movb 0x8(%rsp), %al
movb %al, (%r14)
movq %rbx, %rdi
callq 0x492e
incq %r14
cmpb $0x0, 0x9(%rsp)
jne 0x276f
leaq 0x20(%rsp), %rdi
callq 0x2060
testb $0x5, %bpl
sete %bl
leaq 0x20(%rsp), %rdi
callq 0x2070
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27bb
jmp 0x27bb
jmp 0x27bb
jmp 0x27bb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./arith.h
// Function: arith::ComputeProbabilities(unsigned int*, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char)
void ComputeProbabilities(uint32_t* ProbabilityTable, std::vector<unsigned char>& UncompressedBuffer, uint8_t BitShift) {
        memset(ProbabilityTable, 0u, 256*4);
        uint8_t val;

        for (uint32_t i = 0; i < MIN(UncompressedBuffer.size() - 1, UINT32_MAX); i++) {
            val = ((uint8_t) UncompressedBuffer[i] << BitShift) +
                  ((uint8_t) UncompressedBuffer[i + 1] >> (8 - BitShift));
            ProbabilityTable[val]++;
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x400, %edx            # imm = 0x400
xorl %esi, %esi
callq 0x2110
movq (%r14), %rsi
movq %rsi, %rax
notq %rax
addq 0x8(%r14), %rax
je 0x28e9
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
cmpq %rdi, %rax
cmovbq %rax, %rdi
movzbl %bpl, %eax
movl $0x8, %edx
subl %eax, %edx
xorl %r8d, %r8d
movzbl (%rsi,%r8), %r9d
movl %eax, %ecx
shll %cl, %r9d
movzbl 0x1(%rsi,%r8), %r10d
movl %edx, %ecx
shrl %cl, %r10d
incq %r8
addl %r9d, %r10d
movzbl %r10b, %ecx
incl (%rbx,%rcx,4)
cmpq %r8, %rdi
jne 0x28c2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./arith.h
// Function: arith::StandardDeviation(unsigned int const*, unsigned long)
double ArithmeticMean(const uint32_t* Data, uint64_t Size) {
        double sum = 0;

        for (uint64_t i = 0; i < Size; i++) {
            sum += double(*(Data+i));
        }

        return sum / (double) Size;
    }

// Assembly:
testq %rsi, %rsi
je 0x29a4
xorpd %xmm1, %xmm1
xorl %eax, %eax
movl (%rdi,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
addsd %xmm0, %xmm1
incq %rax
cmpq %rax, %rsi
jne 0x2941
movq %rsi, %xmm0
punpckldq 0x66ab(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x66b3(%rip), %xmm0     # 0x9020
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
divsd %xmm2, %xmm1
xorpd %xmm0, %xmm0
xorl %eax, %eax
movl (%rdi,%rax,4), %ecx
xorps %xmm3, %xmm3
cvtsi2sd %rcx, %xmm3
subsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm0
incq %rax
cmpq %rax, %rsi
jne 0x2983
jmp 0x29ad
cvtsi2sd %rsi, %xmm2
xorpd %xmm0, %xmm0
addsd 0x668b(%rip), %xmm2     # 0x9040
divsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2180
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./arith.h
// Function: arith::CompressBuffer(std::vector<unsigned char, std::allocator<unsigned char>>&, buffer::CodecByteStream&)
CodecStatusCode CompressBuffer(std::vector<unsigned char>& UncompressedBuffer, buffer::CodecByteStream& CompressedBuffer) {
        std::cout << "Initializing Compressor..." << std::endl;
        CodecProbabilityTable ProbabilityTable;
        ProbabilityTable.GenerateTable(UncompressedBuffer);
        CompressBuffer(UncompressedBuffer, ProbabilityTable, CompressedBuffer);
        uint64_t UncompressedBufferSize = UncompressedBuffer.size();
        buffer::EncodeTypeToBuffer<uint64_t>(CompressedBuffer.GetBuffer(), 0, &UncompressedBufferSize);
        ProbabilityTable.EncodeToBuffer(CompressedBuffer.GetBuffer(), 8);
        return Success;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rsi, %rbx
movq %rdi, %r14
movq 0x9f1d(%rip), %r15      # 0xcfc8
leaq 0x5ff2(%rip), %rsi      # 0x90a4
movl $0x1a, %edx
movq %r15, %rdi
callq 0x2220
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq 0x10(%rsp), %r15
xorl %r12d, %r12d
movl $0x404, %edx            # imm = 0x404
movq %r15, %rdi
xorl %esi, %esi
callq 0x2110
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d5c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x29cc
movq 0x8(%r14), %rax
subq (%r14), %rax
movq %rax, 0x8(%rsp)
movb 0x8(%rsp,%r12), %al
movq (%rbx), %rcx
movb %al, (%rcx,%r12)
incq %r12
cmpq $0x8, %r12
jne 0x3122
movl $0x1, %eax
movl $0x8, %ecx
movl $0x4, %edx
movq %rcx, %rsi
movb 0xc(%rsp,%rsi), %dil
movq (%rbx), %r8
movb %dil, (%r8,%rsi)
incq %rsi
decq %rdx
jne 0x3149
incq %rax
addq $0x4, %rcx
cmpq $0x101, %rax            # imm = 0x101
jne 0x3141
xorl %eax, %eax
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./arith.h
// Function: arith::CompressFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CodecStatusCode CompressFile(const std::string& InFile, const std::string& OutFile) {
        std::vector<unsigned char> UncompressedBuffer;

        if (buffer::LoadFile(&InFile, UncompressedBuffer)) {
            buffer::CodecByteStream CompressedBuffer(256*4+8);
            arith::CompressBuffer(UncompressedBuffer, CompressedBuffer);
            if (buffer::SaveFile(CompressedBuffer.GetBuffer(), &OutFile)) {
                return Success;
            } else {
                std::cerr << "File Write Error." << std::endl;
                return FileWriteError;
            }
        } else {
            std::cerr << "File Read Error." << std::endl;
            return FileReadError;
        }
    }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x26bc
testb %al, %al
je 0x3307
leaq 0x20(%rsp), %rdi
movl $0x408, %esi            # imm = 0x408
callq 0x3ebe
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x3090
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x27d0
xorl %ebx, %ebx
testb %al, %al
jne 0x32f6
movq 0x9d36(%rip), %rbx      # 0xcfe8
leaq 0x5e23(%rip), %rsi      # 0x90dc
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x9d04(%rip), %rdi      # 0xcfe8
callq 0x2030
movl $0x2, %ebx
movq %rax, %rdi
callq 0x2140
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3352
callq 0x21c0
jmp 0x3352
movq 0x9cda(%rip), %rbx      # 0xcfe8
leaq 0x5dd9(%rip), %rsi      # 0x90ee
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x9ca8(%rip), %rdi      # 0xcfe8
callq 0x2030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x2140
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3360
callq 0x21c0
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x337e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3381
callq 0x21c0
jmp 0x3381
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x338f
callq 0x21c0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./arith.h
// Function: arith::UncompressFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CodecStatusCode UncompressFile(const std::string& InFile, const std::string& OutFile) {
        std::vector<unsigned char> CompressedBuffer;

        if (buffer::LoadFile(&InFile, CompressedBuffer)) {
            buffer::CodecByteStream UncompressedBuffer(0);
            try {
                arith::UncompressBuffer(UncompressedBuffer, CompressedBuffer);
            } catch (std::exception& e) {
                std::cerr << e.what() << std::endl;
                return BadCompressionStream;
            }

            if (buffer::SaveFile(UncompressedBuffer.GetBuffer(), &OutFile)) {
                return Success;
            } else {
                std::cerr << "File Write Error." << std::endl;
                return FileWriteError;
            }
        } else {
            std::cerr << "File Read Error." << std::endl;
            return FileReadError;
        }
    }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x26bc
testb %al, %al
je 0x3445
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x3ebe
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x317d
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x27d0
xorl %ebx, %ebx
testb %al, %al
jne 0x3434
movq 0x9bf8(%rip), %rbx      # 0xcfe8
leaq 0x5ce5(%rip), %rsi      # 0x90dc
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x9bc6(%rip), %rdi      # 0xcfe8
callq 0x2030
movl $0x2, %ebx
movq %rax, %rdi
callq 0x2140
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3490
callq 0x21c0
jmp 0x3490
movq 0x9b9c(%rip), %rbx      # 0xcfe8
leaq 0x5c9b(%rip), %rsi      # 0x90ee
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x9b6a(%rip), %rdi      # 0xcfe8
callq 0x2030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x2140
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x349e
callq 0x21c0
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x34fe
movq %rbx, %rdi
callq 0x20d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x9b22(%rip), %rdi      # 0xcfe8
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
callq 0x20e0
movl $0x3, %ebx
callq 0x22f0
jmp 0x3434
jmp 0x34fb
movq %rax, %rbx
callq 0x22f0
jmp 0x34fe
movq %rax, %rdi
callq 0x3f15
jmp 0x350f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3512
callq 0x21c0
jmp 0x3512
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3520
callq 0x21c0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./huffman.h
// Function: huffman::CompressFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CodecStatusCode CompressFile(const std::string& InFile, const std::string& OutFile) {
        std::vector<unsigned char> UncompressedBuffer;

        if (buffer::LoadFile(&InFile, UncompressedBuffer)) {
            buffer::CodecByteStream CompressedBuffer(2+8+256*(1+8));
            CompressBuffer<unsigned char, uint64_t>(UncompressedBuffer, CompressedBuffer);
            if (buffer::SaveFile(CompressedBuffer.GetBuffer(), &OutFile)) {
                return Success;
            } else {
                std::cerr << "File Write Error." << std::endl;
                return FileWriteError;
            }
        } else {
            std::cerr << "File Read Error." << std::endl;
            return FileReadError;
        }
    }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x26bc
testb %al, %al
je 0x35d9
leaq 0x20(%rsp), %rdi
movl $0x90a, %esi            # imm = 0x90A
callq 0x3ebe
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x3f20
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x27d0
xorl %ebx, %ebx
testb %al, %al
jne 0x35c8
movq 0x9a64(%rip), %rbx      # 0xcfe8
leaq 0x5b51(%rip), %rsi      # 0x90dc
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x9a32(%rip), %rdi      # 0xcfe8
callq 0x2030
movl $0x2, %ebx
movq %rax, %rdi
callq 0x2140
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3624
callq 0x21c0
jmp 0x3624
movq 0x9a08(%rip), %rbx      # 0xcfe8
leaq 0x5b07(%rip), %rsi      # 0x90ee
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x99d6(%rip), %rdi      # 0xcfe8
callq 0x2030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x2140
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3632
callq 0x21c0
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
retq
jmp 0x3650
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x3653
callq 0x21c0
jmp 0x3653
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3661
callq 0x21c0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./huffman.h
// Function: huffman::UncompressFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CodecStatusCode UncompressFile(const std::string& InFile, const std::string& OutFile) {
        std::vector<unsigned char> CompressedBuffer;
        std::vector<unsigned char> UncompressedBuffer;

        if (buffer::LoadFile(&InFile, CompressedBuffer)) {
            try {
                UncompressBuffer<unsigned char, uint64_t>(UncompressedBuffer, CompressedBuffer);
            } catch (std::exception& e) {
                std::cerr << e.what() << std::endl;
                return BadCompressionStream;
            }

            if (buffer::SaveFile(UncompressedBuffer, &OutFile)) {
                return Success;
            } else {
                std::cerr << "File Write Error." << std::endl;
                return FileWriteError;
            }
        } else {
            std::cerr << "File Read Error." << std::endl;
            return FileReadError;
        }
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movq %rax, 0x10(%rsp)
movaps %xmm0, (%rsp)
callq 0x26bc
testb %al, %al
je 0x3703
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x4173
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x27d0
xorl %ebx, %ebx
testb %al, %al
jne 0x374e
movq 0x992b(%rip), %rbx      # 0xcfe8
leaq 0x5a18(%rip), %rsi      # 0x90dc
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x98f9(%rip), %rdi      # 0xcfe8
callq 0x2030
movl $0x2, %ebx
movq %rax, %rdi
callq 0x2140
jmp 0x374e
movq 0x98de(%rip), %rbx      # 0xcfe8
leaq 0x59dd(%rip), %rsi      # 0x90ee
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2220
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0x98ac(%rip), %rdi      # 0xcfe8
callq 0x2030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x2140
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x375c
callq 0x21c0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x376b
callq 0x21c0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x37c6
movq %rbx, %rdi
callq 0x20d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x9855(%rip), %rdi      # 0xcfe8
movq %rax, %rsi
callq 0x21e0
movq %rax, %rdi
callq 0x20e0
movl $0x3, %ebx
callq 0x22f0
jmp 0x374e
jmp 0x37c3
movq %rax, %rbx
callq 0x22f0
jmp 0x37c6
movq %rax, %rdi
callq 0x3f15
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x37d4
callq 0x21c0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x37e3
callq 0x21c0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/codec.cpp
// Function: main
int main(int argc, char* argv[]) {
    if (argc != 6) {
        print_help();
    } else if (strcmp(argv[1], "--algorithm") != 0) {
        print_help();
    } else {
        if (strcmp(argv[3], "--encode") == 0) {
            if (strcmp(argv[2], "arith") == 0) {
                arith::CompressFile(std::string(argv[4]), std::string(argv[5]));
            } else if (strcmp(argv[2], "huffman") == 0) {
                huffman::CompressFile(std::string(argv[4]), std::string(argv[5]));
            } else {
                print_help();
            }
        } else {
            if (strcmp(argv[2], "arith") == 0) {
                arith::UncompressFile(std::string(argv[4]), std::string(argv[5]));
            } else if (strcmp(argv[2], "huffman") == 0) {
                huffman::UncompressFile(std::string(argv[4]), std::string(argv[5]));
            } else {
                print_help();
            }
        }
    }
    exit(0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpl $0x6, %edi
jne 0x3acb
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
leaq 0x5868(%rip), %rsi      # 0x91bf
callq 0x2280
testl %eax, %eax
jne 0x3acb
movq 0x18(%rbx), %rdi
leaq 0x585c(%rip), %rsi      # 0x91cb
callq 0x2280
movl %eax, %ebp
movq 0x10(%rbx), %r14
leaq 0x5853(%rip), %rsi      # 0x91d4
movq %r14, %rdi
callq 0x2280
testl %ebp, %ebp
jne 0x39cb
testl %eax, %eax
jne 0x3a0d
movq 0x20(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x20c0
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x20c0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3256
jmp 0x3aa3
testl %eax, %eax
jne 0x3a5b
movq 0x20(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x20c0
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x20c0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3397
jmp 0x3aa3
leaq 0x57c6(%rip), %rsi      # 0x91da
movq %r14, %rdi
callq 0x2280
testl %eax, %eax
jne 0x3acb
movq 0x20(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x20c0
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x20c0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3528
jmp 0x3aa3
leaq 0x5778(%rip), %rsi      # 0x91da
movq %r14, %rdi
callq 0x2280
testl %eax, %eax
jne 0x3acb
movq 0x20(%rbx), %rsi
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x20c0
movq 0x28(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x20c0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3669
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ab6
callq 0x21c0
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ad0
callq 0x21c0
jmp 0x3ad0
callq 0x37eb
xorl %edi, %edi
callq 0x2240
jmp 0x3ae1
jmp 0x3ae1
jmp 0x3aff
jmp 0x3aff
jmp 0x3ae1
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b02
callq 0x21c0
jmp 0x3b02
jmp 0x3b19
jmp 0x3b19
jmp 0x3aff
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b1c
callq 0x21c0
jmp 0x3b1c
jmp 0x3b19
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::CodecBufferWrapper::CodecBufferWrapper(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char)
CodecBufferWrapper(std::vector<unsigned char>& InBuffer, uint8_t Shift) {
            Buffer = InBuffer;
            BitShift = Shift;
            IBitShift = 8u-Shift;
            EffectiveSize = Buffer.size() - (Shift == 0 ? 0 : 1); // If a shift is used, the buffer size effectively decreases by one
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x442e
movb %bpl, 0x18(%rbx)
movb $0x8, %al
subb %bpl, %al
movb %al, 0x19(%rbx)
movq 0x8(%rbx), %rax
cmpb $0x1, %bpl
adcq $-0x1, %rax
subq (%rbx), %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3ba2
callq 0x21c0
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::CodecByteStream::WriteBitBuffered(unsigned char)
void WriteBitBuffered(uint8_t Bit) {
            WriteBit(Bit);
            Bit ^= 1u;
            while (PendingBits > 0) {
                WriteBit(Bit);
                PendingBits--;
            }
        }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x3c84
cmpl $0x0, 0x28(%rbx)
jle 0x3c31
xorb $0x1, %bpl
movzbl %bpl, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3c84
movl 0x28(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x28(%rbx)
cmpl $0x1, %eax
jg 0x3c19
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::CodecByteStream::WriteBit(unsigned char)
void WriteBit(uint8_t Bit) {
            Data[ByteIndex] |= Bit<<IBitIndex;
            if (IBitIndex == 0) {
                ByteIndex++;
                Data.push_back(0u);
                IBitIndex = 7u;
            } else {
                IBitIndex--;
            }
        }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb 0x18(%rdi), %cl
shll %cl, %esi
movq 0x20(%rdi), %rax
movq (%rdi), %rcx
orb %sil, (%rcx,%rax)
movb 0x18(%rdi), %al
testb %al, %al
je 0x3ca7
decb %al
jmp 0x3cd2
incq 0x20(%rbx)
movb $0x0, 0xf(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3cc3
movb $0x0, (%rsi)
incq 0x8(%rbx)
jmp 0x3cd0
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x4530
movb $0x7, %al
movb %al, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./arith.h
// Function: arith::CodecProbabilityTable::DecodeFromCount(unsigned long)
std::tuple<uint32_t, uint32_t, uint8_t> DecodeFromCount(uint64_t count) {
            for (uint16_t i = 0; i < 256; i++) {
                if (Frequencies[i+1] > count) {
                    return std::make_tuple(Frequencies[i], Frequencies[i+1], i);
                }
            }
            throw std::runtime_error("Bad Value Encountered In Decode.");
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq $-0x1, %rax
cmpq $0xff, %rax
je 0x3d17
movl 0x8(%rsi,%rax,4), %ecx
incq %rax
cmpq %rdx, %rcx
jbe 0x3ce7
movb %al, (%rdi)
movq (%rsi,%rax,4), %xmm0
pshufd $0xe1, %xmm0, %xmm0     # xmm0 = xmm0[1,0,2,3]
movq %xmm0, 0x4(%rdi)
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %rbx
leaq 0x54d1(%rip), %rsi      # 0x91fc
movq %rax, %rdi
callq 0x20b0
movq 0x92b6(%rip), %rsi      # 0xcff0
movq 0x927f(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x2300
movq %rax, %r14
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./arith.h
// Function: arith::CodecProbabilityTable::GenerateTable(std::vector<unsigned char, std::allocator<unsigned char>>&)
void GenerateTable(std::vector<unsigned char>& UncompressedBuffer) {
            uint32_t tables[256*8] = {0};
            double deviations[8] = {0};

            for (uint16_t i = 0; i < 8; i++) {
                ComputeProbabilities(&tables[i*256], UncompressedBuffer, (uint8_t) i);
                deviations[i] = StandardDeviation(&tables[i*256], 256);
            }

            uint16_t max = 0u;
            double pmax = 0;

            for (uint16_t i = 0; i < 8; i++) {
                if (deviations[i] > pmax) {
                    pmax = deviations[i];
                    max = i;
                }
            }

            std::copy(tables+256*max, tables+256*(max+1), Frequencies + 1);

            for (uint16_t i = 1; i < 257; i++) {
                Frequencies[i] += Frequencies[i-1];
            }

            BitShift = max;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2040, %rsp           # imm = 0x2040
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
xorl %r12d, %r12d
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rdi
xorl %esi, %esi
callq 0x2110
xorpd %xmm0, %xmm0
movapd %xmm0, 0x30(%rsp)
movapd %xmm0, 0x20(%rsp)
movapd %xmm0, 0x10(%rsp)
movapd %xmm0, (%rsp)
movq %r12, %rax
shlq $0xa, %rax
leaq (%rsp,%rax), %rdi
addq $0x40, %rdi
movzbl %r12b, %edx
movq %r14, %rsi
callq 0x2881
xorl %eax, %eax
xorpd %xmm1, %xmm1
movl (%r15,%rax,4), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
addsd %xmm0, %xmm1
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x3dc4
mulsd 0x5269(%rip), %xmm1     # 0x9050
xorpd %xmm0, %xmm0
xorl %eax, %eax
movl (%r15,%rax,4), %ecx
xorps %xmm2, %xmm2
cvtsi2sd %rcx, %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x3ded
divsd 0x5240(%rip), %xmm0     # 0x9058
ucomisd 0x5240(%rip), %xmm0     # 0x9060
jb 0x3e28
sqrtsd %xmm0, %xmm0
jmp 0x3e2d
callq 0x2180
movsd %xmm0, (%rsp,%r12,8)
incq %r12
addq $0x400, %r15            # imm = 0x400
cmpq $0x8, %r12
jne 0x3da3
xorpd %xmm0, %xmm0
xorl %eax, %eax
xorl %ebp, %ebp
movsd (%rsp,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
movl %eax, %ecx
cmovbel %ebp, %ecx
movl %ecx, %ebp
maxsd %xmm0, %xmm1
incq %rax
movapd %xmm1, %xmm0
cmpq $0x8, %rax
jne 0x3e4f
movzwl %bp, %eax
shll $0xa, %eax
leaq (%rsp,%rax), %rsi
addq $0x40, %rsi
leaq 0x4(%rbx), %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
callq 0x2190
movl (%rbx), %eax
xorl %ecx, %ecx
addl (%r14,%rcx,4), %eax
movl %eax, (%r14,%rcx,4)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x3e93
movb %bpl, 0x404(%rbx)
addq $0x2040, %rsp           # imm = 0x2040
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./huffman.h
// Function: huffman::HuffmanTree<unsigned char, unsigned long>::ConstructSymbolTable()
void ConstructSymbolTable() {
            RootNodeIterator<SymbolType, ValueType> RootIterator(this);
            HuffmanNode<SymbolType, ValueType>* RootNode;
            do {
                RootNode = &RootIterator.GetCurrentRootNode();
                //std::cout << "Symbol: " << (int) RootNode->GetSymbol() << std::endl;
                SymbolTable[RootNode->GetSymbol()] = RootIterator.GetCurrentIndex();
            } while (RootIterator++);

        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x71fe
leaq 0x18(%rsp), %r15
addq $0x8, %rbx
xorl %r14d, %r14d
leaq 0x40(%rsp), %r12
leaq 0xf(%rsp), %r13
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movl 0x30(%rsp), %edx
movq (%rsi), %rbp
cmpq %rcx, %rax
setne %sil
testl %edx, %edx
setne %dil
orb %sil, %dil
cmpb $0x1, %dil
jne 0x4ecd
xorl %esi, %esi
movq (%rax), %rdi
xorl %r8d, %r8d
btq %rsi, %rdi
setb %r8b
xorl %edi, %edi
cmpl $0x3f, %esi
leal 0x1(%rsi), %esi
sete %dil
cmovel %r14d, %esi
leaq (%rax,%rdi,8), %rax
movq (%rbp,%r8,8), %rbp
cmpq %rcx, %rax
setne %dil
cmpl %edx, %esi
setne %r8b
orb %dil, %r8b
jne 0x4e94
movq %r12, %rdi
movq %r15, %rsi
callq 0x7854
movb 0x11(%rbp), %al
movb %al, 0xf(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x725e
movq %rax, %rbp
movq %rax, %rdi
callq 0x765c
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rbp)
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rbp)
movups %xmm0, (%rbp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x72c4
testb %al, %al
jne 0x4e66
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4f33
callq 0x21c0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f60
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4f63
callq 0x21c0
jmp 0x4f63
movq %rax, %rdi
callq 0x3f15
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4f72
callq 0x21c0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./huffman.h
// Function: huffman::RootNodeIterator<unsigned char, unsigned long>::RootNodeIterator(huffman::HuffmanTree<unsigned char, unsigned long>*)
explicit RootNodeIterator(HuffmanTree<SymbolType, ValueType>* ITree) {
            Tree = ITree;
            do {
                Index.push_back(0);
            } while (!(*Tree)[Index].IsRoot());
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movl %eax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rsi, (%rdi)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x73ee
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x743c
cmpb $0x1, 0x10(%rax)
jne 0x7220
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x765c
movq %r14, %rdi
callq 0x2320
movq %rax, %rdi
callq 0x3f15
// File: /workspace/github_cpp_makefile_star2_O3/cristian-bicheru[P]arith/./huffman.h
// Function: huffman::RootNodeIterator<unsigned char, unsigned long>::operator++(int)
bool operator++(int) {
            auto LastLeftBranch = std::find(Index.rbegin(), Index.rend(), false);
            if (LastLeftBranch != Index.rend()) {
                uint64_t LeftBranch = Index.size()-1ull-(LastLeftBranch-Index.rbegin());
                Index.resize(LeftBranch+1ull);
                Index[LeftBranch] = 1;
                while (!(*Tree)[Index].IsRoot()) {
                    Index.push_back(0);
                }
                //this->DumpIndex();
                return true;
            } else {
                return false;
            }

        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rdx
movl 0x20(%rdi), %edi
leaq 0x7(%rsp), %rcx
movb $0x0, (%rcx)
leaq 0x28(%rsp), %rsi
movq %rdx, (%rsi)
movl %edi, 0x8(%rsi)
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movl $0x0, 0x8(%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7c07
movq 0x8(%rbx), %rcx
movq (%r14), %rax
movl 0x8(%r14), %edx
cmpq %rcx, %rax
setne %sil
testl %edx, %edx
setne %bpl
orb %sil, %bpl
cmpb $0x1, %bpl
jne 0x73dd
leaq 0x8(%rbx), %r14
movl %edx, %edx
movq 0x18(%rbx), %rsi
movl 0x20(%rbx), %edi
movq %rsi, %r8
subq %rcx, %r8
leaq (%rdi,%r8,8), %r12
subq %rax, %rsi
subq %rdx, %rdi
leaq (%rdi,%rsi,8), %r13
movq %r12, %rsi
subq %r13, %rsi
notq %r13
leaq (%r12,%r13), %r15
movq %r14, %rdi
xorl %edx, %edx
callq 0x7b9a
leaq (%r12,%r13), %rax
addq $0x3f, %rax
testq %r15, %r15
cmovnsq %r15, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x8(%rbx), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
leaq 0x3f(%rcx), %rdx
andq %r15, %rdx
xorl %esi, %esi
cmpq %rcx, %rdx
setbe %sil
movl $0x1, %edx
movl %r15d, %ecx
shlq %cl, %rdx
orq %rdx, -0x8(%rax,%rsi,8)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x743c
cmpb $0x0, 0x10(%rax)
jne 0x73dd
movq %r14, %rdi
xorl %esi, %esi
callq 0x73ee
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x743c
cmpb $0x1, 0x10(%rax)
jne 0x73c2
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq