LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlReporter::test_case_exception(doctest::TestCaseException const&)
void test_case_exception(const TestCaseException& e) override {
            std::lock_guard<std::mutex> lock(mutex);

            xml.scopedElement("Exception")
                    .writeAttribute("crash", e.is_crash)
                    .writeText(e.error_string.c_str());
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x14190
leaq 0xae2c(%rip), %rsi      # 0x18092
leaq 0x50(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x12d1a
addq $0x8, %r15
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r15, %rsi
callq 0xdc4c
leaq 0xadd1(%rip), %rsi      # 0x18063
leaq 0x30(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x12d1a
leaq 0x18(%r14), %rdx
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xdcbe
cmpb $0x0, 0x17(%r14)
jns 0xd2be
movq (%r14), %r14
leaq 0x10(%rsp), %rdi
leaq 0x5(%rsp), %rdx
movq %r14, %rsi
callq 0x12d1a
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0xe840
leaq 0x10(%rsp), %rdi
callq 0x51a0
leaq 0x30(%rsp), %rdi
callq 0x51a0
leaq 0x8(%rsp), %rdi
callq 0xdc80
leaq 0x50(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x5300
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x51a0
jmp 0xd330
jmp 0xd32d
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x51a0
jmp 0xd33f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xdc80
jmp 0xd34e
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x5670
movq %rax, %r14
jmp 0xd358
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlReporter::subcase_start(doctest::SubcaseSignature const&)
void subcase_start(const SubcaseSignature& in) override {
            xml.startElement("SubCase")
                    .writeAttribute("name", in.m_name)
                    .writeAttribute("filename", skipPathFromFilename(in.m_file))
                    .writeAttribute("line", line(in.m_line));
            xml.ensureTagClosed();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
leaq 0xacdc(%rip), %rsi      # 0x18069
leaq 0x68(%rsp), %r12
leaq 0x3(%rsp), %rdx
movq %r12, %rdi
callq 0x12d1a
movq %rbx, %rdi
movq %r12, %rsi
callq 0xdd82
leaq 0xab5b(%rip), %rsi      # 0x17f0c
leaq 0x48(%rsp), %rdi
leaq 0x2(%rsp), %rdx
callq 0x12d1a
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe226
leaq 0xab31(%rip), %rsi      # 0x17f08
leaq 0x28(%rsp), %rdi
leaq 0x1(%rsp), %rdx
callq 0x12d1a
movq 0x18(%r14), %rdi
callq 0x66c2
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xe2bc
leaq 0xa605(%rip), %rsi      # 0x17a0b
leaq 0x8(%rsp), %rdi
movq %rsp, %rdx
callq 0x12d1a
movq 0x78(%r15), %rcx
xorl %eax, %eax
cmpb $0x0, 0x7d(%rcx)
jne 0xd423
movl 0x20(%r14), %eax
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xe39a
leaq 0x8(%rsp), %rdi
callq 0x51a0
leaq 0x28(%rsp), %rdi
callq 0x51a0
leaq 0x48(%rsp), %rdi
callq 0x51a0
leaq 0x68(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0xdde8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51a0
jmp 0xd48a
jmp 0xd487
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x51a0
jmp 0xd49b
jmp 0xd498
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x51a0
jmp 0xd4ac
jmp 0xd4a9
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlReporter::log_message(doctest::MessageData const&)
void log_message(const MessageData& mb) override {
            std::lock_guard<std::mutex> lock(mutex);

            xml.startElement("Message")
                    .writeAttribute("type", failureString(mb.m_severity))
                    .writeAttribute("filename", skipPathFromFilename(mb.m_file))
                    .writeAttribute("line", line(mb.m_line));

            xml.scopedElement("Text").writeText(mb.m_string.c_str());

            log_contexts();

            xml.endElement();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r12
movq %rdi, %r14
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x14190
leaq 0xa711(%rip), %rsi      # 0x180c2
leaq 0x48(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x12d1a
leaq 0x8(%r14), %r15
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0xdd82
leaq 0xa6a4(%rip), %rsi      # 0x1807c
leaq 0x28(%rsp), %rdi
leaq 0x2(%rsp), %rdx
callq 0x12d1a
movl 0x24(%r12), %edi
callq 0x668f
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0xe2bc
leaq 0xa500(%rip), %rsi      # 0x17f08
leaq 0x8(%rsp), %rdi
leaq 0x1(%rsp), %rdx
callq 0x12d1a
movq 0x18(%r12), %rdi
callq 0x66c2
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0xe2bc
leaq 0x9fd3(%rip), %rsi      # 0x17a0b
leaq 0x68(%rsp), %rdi
movq %rsp, %rdx
callq 0x12d1a
movq 0x78(%r14), %rcx
xorl %eax, %eax
cmpb $0x0, 0x7d(%rcx)
jne 0xda56
movl 0x20(%r12), %eax
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x68(%rsp), %rsi
movq %r15, %rdi
callq 0xe39a
leaq 0x68(%rsp), %rdi
callq 0x51a0
leaq 0x8(%rsp), %rdi
callq 0x51a0
leaq 0x28(%rsp), %rdi
callq 0x51a0
leaq 0x48(%rsp), %rdi
callq 0x51a0
leaq 0xa631(%rip), %rsi      # 0x180ca
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0x12d1a
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r15, %rsi
callq 0xdc4c
cmpb $0x0, 0x17(%r12)
jns 0xdac6
movq (%r12), %r12
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r12, %rsi
callq 0x12d1a
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0xe840
leaq 0x28(%rsp), %rdi
callq 0x51a0
leaq 0x8(%rsp), %rdi
callq 0xdc80
leaq 0x48(%rsp), %rdi
callq 0x51a0
movq %r14, %rdi
callq 0xe8d2
movq %r15, %rdi
callq 0xdcd2
movq %rbx, %rdi
callq 0x5300
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x51a0
jmp 0xdb41
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xdc80
jmp 0xdb87
jmp 0xdb84
jmp 0xdb95
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x51a0
jmp 0xdb65
jmp 0xdb62
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x51a0
jmp 0xdb76
jmp 0xdb73
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x51a0
jmp 0xdb87
jmp 0xdb84
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x51a0
jmp 0xdb98
jmp 0xdb95
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlReporter::test_case_skipped(doctest::TestCaseData const&)
void test_case_skipped(const TestCaseData& in) override {
            if(opt.no_skipped_summary == false) {
                test_case_start_impl(in);
                xml.writeAttribute("skipped", "true");
                xml.endElement();
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x78(%rdi), %rax
cmpb $0x0, 0x7f(%rax)
jne 0xdc02
movq %rdi, %rbx
callq 0xe492
addq $0x8, %rbx
leaq 0xb63b(%rip), %rsi      # 0x19207
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x12d1a
leaq 0x9959(%rip), %rdx      # 0x1753e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe2bc
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0xdcd2
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlWriter::endElement()
XmlWriter& XmlWriter::endElement() {
        newlineIfNecessary();
        m_indent = m_indent.substr( 0, m_indent.size()-2 );
        if( m_tagIsOpen ) {
            m_os << "/>";
            m_tagIsOpen = false;
        }
        else {
            m_os << m_indent << "</" << m_tags.back() << ">";
        }
        m_os << std::endl;
        m_tags.pop_back();
        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0xde0e
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rcx
addq $-0x2, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5410
movq %r14, %rdi
movq %r15, %rsi
callq 0x5480
movq %r15, %rdi
callq 0x51a0
movq 0x40(%rbx), %rdi
cmpb $0x1, (%rbx)
jne 0xdd2c
leaq 0xa251(%rip), %rsi      # 0x17f73
callq 0x53d0
movb $0x0, (%rbx)
jmp 0xdd62
movq %r14, %rsi
callq 0x5360
leaq 0xa23b(%rip), %rsi      # 0x17f76
movq %rax, %rdi
callq 0x53d0
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
movq %rax, %rdi
callq 0x5360
leaq 0xa21a(%rip), %rsi      # 0x17f74
movq %rax, %rdi
callq 0x53d0
movq 0x40(%rbx), %rdi
callq 0x51d0
leaq 0x8(%rbx), %rdi
callq 0x14426
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlWriter::startElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
XmlWriter& XmlWriter::startElement( std::string const& name ) {
        ensureTagClosed();
        newlineIfNecessary();
        m_os << m_indent << '<' << name;
        m_tags.push_back( name );
        m_indent += "  ";
        m_tagIsOpen = true;
        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xdde8
movq %rbx, %rdi
callq 0xde0e
movq 0x40(%rbx), %rdi
leaq 0x20(%rbx), %r15
movq %r15, %rsi
callq 0x5360
pushq $0x3c
popq %rsi
movq %rax, %rdi
callq 0x5450
movq %rax, %rdi
movq %r14, %rsi
callq 0x5360
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x14220
leaq 0xa6fb(%rip), %rsi      # 0x184ce
movq %r15, %rdi
callq 0x56d0
movb $0x1, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlReporter::log_contexts()
void log_contexts() {
            int num_contexts = get_num_active_contexts();
            if(num_contexts) {
                auto              contexts = get_active_contexts();
                std::stringstream ss;
                for(int i = 0; i < num_contexts; ++i) {
                    contexts[i]->stringify(&ss);
                    xml.scopedElement("Info").writeText(ss.str());
                    ss.str("");
                }
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, %rbx
callq 0xa9bc
testl %eax, %eax
je 0xe9da
movl %eax, %r14d
callq 0xa9da
movq %rax, 0x10(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x52b0
addq $0x8, %rbx
movq %rbx, 0x8(%rsp)
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
leaq 0x78(%rsp), %r13
leaq 0x20(%rsp), %r12
leaq 0x18(%rsp), %rbp
leaq 0x40(%rsp), %rbx
cmpq %r15, %r14
je 0xe9d0
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
leaq 0x70(%rsp), %rsi
callq *0x10(%rax)
movq %r12, %rdi
leaq 0x9765(%rip), %rsi      # 0x180bd
leaq 0x7(%rsp), %rdx
callq 0x12d1a
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0xdc4c
movq %rbx, %rdi
movq %r13, %rsi
callq 0x55b0
movq %rbp, %rdi
movq %rbx, %rsi
pushq $0x1
popq %rdx
callq 0xe840
movq %rbx, %rdi
callq 0x51a0
movq %rbp, %rdi
callq 0xdc80
movq %r12, %rdi
callq 0x51a0
movq %r12, %rdi
leaq 0x8c74(%rip), %rsi      # 0x17621
movq %rbx, %rdx
callq 0x12d1a
movq %r13, %rdi
movq %r12, %rsi
callq 0x5570
movq %r12, %rdi
callq 0x51a0
incq %r15
jmp 0xe931
leaq 0x60(%rsp), %rdi
callq 0x52f0
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xe9fe
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x51a0
leaq 0x18(%rsp), %rdi
callq 0xdc80
jmp 0xea18
jmp 0xea10
jmp 0xea15
jmp 0xea10
movq %rax, %rbx
jmp 0xea22
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x51a0
leaq 0x60(%rsp), %rdi
callq 0x52f0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::JUnitReporter::test_case_reenter(doctest::TestCaseData const&)
void test_case_reenter(const TestCaseData& in) override {
            testCaseData.addTime(timer.getElapsedSeconds());
            testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
            deepestSubcaseStackNames.clear();

            timer.start();
            testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x98(%rdi), %rbx
leaq 0x78(%rdi), %r15
movq %r15, %rdi
callq 0x12ef4
movapd %xmm0, %xmm1
cmpltsd 0x8027(%rip), %xmm1     # 0x172e8
andnpd %xmm0, %xmm1
movq 0xa0(%r12), %rax
movlpd %xmm1, -0x38(%rax)
movsd 0xb0(%r12), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xb0(%r12)
subq $-0x80, %r12
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x1446a
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfd52
leaq 0x48(%rsp), %rdi
callq 0x12b42
movq %r12, %rdi
callq 0x124b6
callq 0x5de0
movq %rax, (%r15)
cmpb $0x0, 0x17(%r14)
movq %r14, %rdi
jns 0xf330
movq (%r14), %rdi
callq 0x66c2
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x12d1a
movq 0x20(%r14), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x12d1a
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xfa28
leaq 0x8(%rsp), %rdi
callq 0x51a0
leaq 0x28(%rsp), %rdi
callq 0x51a0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51a0
jmp 0xf3a0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x51a0
jmp 0xf3be
movq %rax, %rbx
jmp 0xf3be
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x12b42
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::test_case_start(doctest::TestCaseData const&)
void test_case_start(const TestCaseData& in) override {
            hasLoggedCurrentTestStart = false;
            tc                        = &in;
            subcasesStack.clear();
            currentSubcaseLevel = 0;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
movq %rsi, 0x68(%rdi)
addq $0x18, %rdi
callq 0x1258c
andq $0x0, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::log_assert(doctest::AssertData const&)
void log_assert(const AssertData& rb) override {
            if((!rb.m_failed && !opt.success) || tc->m_no_output)
                return;

            std::lock_guard<std::mutex> lock(mutex);

            logTestStart();

            file_line_to_stream(rb.m_file, rb.m_line, " ");
            successOrFailColoredStringToStream(!rb.m_failed, rb.m_at);

            fulltext_log_assert_to_stream(s, rb);

            log_contexts();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x0, 0x28(%rsi)
jne 0x11a77
movq 0x60(%rbx), %rax
cmpb $0x1, 0x6c(%rax)
jne 0x11a81
movq 0x68(%rbx), %rax
cmpb $0x0, 0x3a(%rax)
je 0x11a87
popq %rbx
popq %r14
popq %r15
retq
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x14190
movq %rbx, %rdi
callq 0x11e5c
movq 0x10(%r15), %rsi
movl 0x18(%r15), %edx
movq (%rbx), %rax
leaq 0x6a22(%rip), %rcx      # 0x184cf
movq %rbx, %rdi
callq *0x70(%rax)
movzbl 0x28(%r15), %esi
movl 0x8(%r15), %edx
xorl $0x1, %esi
movq %rbx, %rdi
callq 0x120e4
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0xff57
movq %rbx, %rdi
callq 0x12140
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5300
movq %rax, %rbx
movq %r14, %rdi
callq 0x5300
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::log_message(doctest::MessageData const&)
void log_message(const MessageData& mb) override {
            if(tc->m_no_output)
                return;

            std::lock_guard<std::mutex> lock(mutex);

            logTestStart();

            file_line_to_stream(mb.m_file, mb.m_line, " ");
            s << getSuccessOrFailColor(false, mb.m_severity)
              << getSuccessOrFailString(mb.m_severity & assertType::is_warn, mb.m_severity,
                                        "MESSAGE") << ": ";
            s << Color::None << mb.m_string << "\n";
            log_contexts();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rax
cmpb $0x0, 0x3a(%rax)
je 0x11b1a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsi, %r15
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x14190
movq %r14, %rdi
callq 0x11e5c
movq 0x18(%r15), %rsi
movl 0x20(%r15), %edx
movq (%r14), %rax
leaq 0x6989(%rip), %rcx      # 0x184cf
movq %r14, %rdi
callq *0x70(%rax)
movq 0x8(%r14), %r12
movl 0x24(%r15), %eax
andl $0x1, %eax
leal 0x2(,%rax,4), %esi
movq %r12, %rdi
callq 0x62de
movl 0x24(%r15), %edi
testb $0x1, %dil
jne 0x11b7a
callq 0x668f
movq %rax, %rsi
jmp 0x11b81
leaq 0x78be(%rip), %rsi      # 0x1943f
movq %r12, %rdi
callq 0x53d0
leaq 0x7890(%rip), %rsi      # 0x19420
movq %rax, %rdi
callq 0x53d0
movq 0x8(%r14), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x62de
movq %r12, %rdi
movq %r15, %rsi
callq 0x62cc
leaq 0x6fe2(%rip), %rsi      # 0x18b9a
movq %rax, %rdi
callq 0x53d0
movq %r14, %rdi
callq 0x12140
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5300
movq %rax, %r14
movq %rbx, %rdi
callq 0x5300
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::log_contexts()
void log_contexts() {
            int num_contexts = get_num_active_contexts();
            if(num_contexts) {
                auto contexts = get_active_contexts();

                s << Color::None << "  logged: ";
                for(int i = 0; i < num_contexts; ++i) {
                    s << (i == 0 ? "" : "          ");
                    contexts[i]->stringify(&s);
                    s << "\n";
                }
            }

            s << "\n";
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa9bc
testl %eax, %eax
je 0x121d5
movl %eax, %r14d
callq 0xa9da
movq %rax, %r15
movq 0x8(%rbx), %r12
xorl %r13d, %r13d
movq %r12, %rdi
xorl %esi, %esi
callq 0x62de
leaq 0x60b0(%rip), %rsi      # 0x1822a
movq %r12, %rdi
callq 0x53d0
testl %r14d, %r14d
cmovlel %r13d, %r14d
leaq 0x6336(%rip), %rbp      # 0x184c6
leaq 0x6a03(%rip), %r12      # 0x18b9a
cmpq %r13, %r14
je 0x121d5
movq 0x8(%rbx), %rdi
testq %r13, %r13
movq %rbp, %rsi
leaq 0x5474(%rip), %rax      # 0x17621
cmoveq %rax, %rsi
callq 0x53d0
movq (%r15,%r13,8), %rdi
movq 0x8(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x53d0
incq %r13
jmp 0x12197
movq 0x8(%rbx), %rdi
leaq 0x69ba(%rip), %rsi      # 0x18b9a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x53d0
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::MultiLaneAtomic<int>::myAtomic()
std::atomic<T>& myAtomic() DOCTEST_NOEXCEPT {
            static std::atomic<size_t> laneCounter;
            DOCTEST_THREAD_LOCAL size_t tlsLaneIdx =
                    laneCounter++ % DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES;

            return m_atomics[tlsLaneIdx].atomic;
        }

// Assembly:
movq %rdi, %rax
cmpb $0x0, %fs:-0x8
je 0x12969
movq %fs:-0x10, %rcx
shlq $0x6, %rcx
addq %rcx, %rax
retq
pushq $0x1
popq %rcx
lock
xaddq %rcx, 0x1248b(%rip)     # 0x24e00
andl $0x1f, %ecx
movq %rcx, %fs:-0x10
movb $0x1, %fs:-0x8
jmp 0x12958
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::MultiLaneAtomic<int>::load(std::memory_order) const
T load(std::memory_order order = std::memory_order_seq_cst) const DOCTEST_NOEXCEPT {
            auto result = T();
            for(auto const& c : m_atomics) {
                result += c.atomic.load(order);
            }
            return result;
        }

// Assembly:
xorl %ecx, %ecx
leal -0x1(%rsi), %edx
xorl %eax, %eax
cmpq $0x800, %rcx            # imm = 0x800
je 0x13381
cmpl $0x2, %edx
jb 0x13374
cmpl $0x5, %esi
movl (%rdi,%rcx), %r8d
addl %r8d, %eax
addq $0x40, %rcx
jmp 0x13363
retq
// File: /workspace/github_cpp_makefile_star2_O2/ekinakyurek[P]bilsoz/src/main.cpp
// Function: join(char**, int, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string join(char* arr[], int n, char c, string s) {
   for (int i = 1; i < n; ++i) {
      s += arr[i];
      if (i < n-1)
         s += c;
   }
   transform(s.begin(), s.end(), s.begin(), ::tolower);
   return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rsi, %r15
movq %rdi, (%rsp)
movslq %edx, %r12
decl %edx
movslq %edx, %r13
pushq $0x1
popq %r14
movsbl %cl, %ebp
cmpq %r12, %r14
jge 0x25bf1
movq (%r15,%r14,8), %rsi
movq %rbx, %rdi
callq 0x21f0
cmpq %r13, %r14
jge 0x25bec
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2100
incq %r14
jmp 0x25bcc
movq (%rbx), %r14
movq 0x8(%rbx), %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x25c13
movsbl (%r14,%r12), %edi
callq 0x2190
movb %al, (%r14,%r12)
incq %r12
jmp 0x25bfb
movq (%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2160
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ekinakyurek[P]bilsoz/src/main.cpp
// Function: main
int main(int argc, char *argv[]){
  if (argc > 1)
  {
    unordered_map<string, string>::iterator iter = BilSoz::dict.find(join(argv,argc,' ',""));
    if (iter != BilSoz::dict.end())
    {
      cout << iter->second << endl;
    }else{
      cout << "bu kelime sözlükte bulunamadı." << endl;
    }
    return 0;
  }
  cout << "lütfen aramak istediğiniz kelimeyi yazıp tekrar çalıştırın." << endl;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpl $0x2, %edi
jl 0x25cb7
movq %rsi, %r14
movl %edi, %ebx
leaq 0xe05f(%rip), %rsi      # 0x33cad
leaq 0x30(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x254a8
leaq 0x10(%rsp), %rdi
pushq $0x20
popq %rcx
movq %r14, %rsi
movl %ebx, %edx
movq %r15, %r8
callq 0x25ba8
leaq 0x204a4(%rip), %rdi     # 0x46120
leaq 0x10(%rsp), %rsi
callq 0x25d12
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2090
leaq 0x30(%rsp), %rdi
callq 0x2090
testq %rbx, %rbx
je 0x25cc7
addq $0x28, %rbx
movq 0x2032b(%rip), %rdi     # 0x45fd8
movq %rbx, %rsi
callq 0x2120
jmp 0x25cda
movq 0x2031a(%rip), %rdi     # 0x45fd8
leaq 0x13b9d(%rip), %rsi     # 0x39862
jmp 0x25cd5
movq 0x2030a(%rip), %rdi     # 0x45fd8
leaq 0x13b6b(%rip), %rsi     # 0x39840
callq 0x2130
movq %rax, %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2090
jmp 0x25d00
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/main.cpp
// Function: show(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::vector<float, std::allocator<float>>, std::vector<float, std::allocator<float>>, std::vector<float, std::allocator<float>>)
void show(vector<string> l0, vector<float> l1, vector<float> l2, vector<float> l3) {
	if ((l1.size()!=l2.size()) && (l1.size()!=l3.size()))
		return;
	for (unsigned int i=0; i<l1.size(); i++) {
		cout << l0[i] << "\t| " << l1[i] << "\t| "<<l2[i]<< "\t| "<<l3[i]<< "\n";
	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movq %rax, %rdx
subq %rcx, %rdx
movq 0x8(%r14), %rsi
subq (%r14), %rsi
cmpq %rsi, %rdx
je 0x37a3
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
cmpq %rsi, %rdx
jne 0x3867
xorl %edx, %edx
leaq 0x585e(%rip), %r13      # 0x900a
subq %rcx, %rax
movl %edx, %r12d
sarq $0x2, %rax
cmpq %r12, %rax
jbe 0x384d
movq %r12, %rsi
shlq $0x5, %rsi
movq -0x30(%rbp), %rax
addq (%rax), %rsi
movq 0xa804(%rip), %rdi      # 0xdfd8
callq 0x3200
movq %rax, %rdi
movq %r13, %rsi
callq 0x3220
movq (%r15), %rcx
movss (%rcx,%r12,4), %xmm0
movq %rax, %rdi
callq 0x31c0
movq %rax, %rdi
movq %r13, %rsi
callq 0x3220
movq (%r14), %rcx
movss (%rcx,%r12,4), %xmm0
movq %rax, %rdi
callq 0x31c0
movq %rax, %rdi
movq %r13, %rsi
callq 0x3220
movq (%rbx), %rcx
movss (%rcx,%r12,4), %xmm0
movq %rax, %rdi
callq 0x31c0
movq %rax, %rdi
leaq 0x59c9(%rip), %rsi      # 0x9200
callq 0x3220
leal 0x1(%r12), %edx
movq (%r15), %rcx
movq 0x8(%r15), %rax
jmp 0x37ac
movq 0xa784(%rip), %rdi      # 0xdfd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::loadSwearingChars(char*)
void Parser::loadSwearingChars(char* filename) {
	std::fstream f(filename);
	if(f.is_open()) {
		char c;
		while (!f.eof()) { // &&
			f.get(c);
			if (c != '\n')
				this->swearingChars.push_back(c);
		}
		f.close();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
leaq -0x230(%rbp), %rdi
pushq $0x18
popq %rdx
callq 0x32f0
leaq -0x1b0(%rbp), %rdi
callq 0x30c0
testb %al, %al
je 0x3b28
addq $0x48, %rbx
leaq -0x230(%rbp), %r14
leaq -0x19(%rbp), %r15
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x210(%rbp,%rax)
jne 0x3b1c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3310
cmpb $0xa, -0x19(%rbp)
je 0x3ae9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43c6
jmp 0x3ae9
leaq -0x230(%rbp), %rdi
callq 0x3060
leaq -0x230(%rbp), %rdi
callq 0x30a0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b44
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::Parser()
Parser::Parser() {
	//this->loadBadSmileys("bad-smileys.txt");
	//this->loadGoodSmileys("good-smileys.txt");
	//this->loadSwearingChars("swearing-chars.txt");
	this->loadColumnDelimiters();
	this->loadWordDelimeters();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0xa063(%rip), %rax      # 0xdc00
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %r15
movb %al, 0x38(%rdi)
leaq 0x48(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
andq $0x0, 0x58(%rdi)
callq 0x3b5c
movq %r14, %rdi
callq 0x3b72
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x4674
movq %r15, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3130
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::noFrontSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Parser::noFrontSpaces(string line) {
	string aux = line;
	while ((line[0] == '\n') || (line[0] == ' ')){
		aux.erase(0,1);
		line = aux;
	}
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x3300
pushq $0x1
popq %r15
movq (%r14), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x3c94
cmpl $0xa, %eax
jne 0x3cae
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x30b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3170
jmp 0x3c84
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3130
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::tokenizeColumns(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> Parser::tokenizeColumns(string line){
	vector<string> parts;
	boost::split(parts, line, boost::is_any_of(this->columnDelimeter));

	for (unsigned int i=0; i< parts.size(); i++){
		if (parts[i].size()==0)
			parts.erase(parts.begin()+i);
		parts[i] = noFrontSpaces(parts[i]);
	}

	return parts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
addq $0x8, %rsi
leaq -0x40(%rbp), %rdi
callq 0x4473
leaq -0x40(%rbp), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43e7
leaq -0x40(%rbp), %rdi
callq 0x44a4
xorl %r13d, %r13d
leaq -0x60(%rbp), %r14
leaq -0x80(%rbp), %r15
movl %r13d, %r13d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x3d91
movq %r13, %r12
shlq $0x5, %r12
cmpq $0x0, 0x8(%rsi,%r12)
jne 0x3d58
addq %r12, %rsi
movq %rbx, %rdi
callq 0x44c0
movq (%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x3300
movq %r15, %rdi
movq %r14, %rdx
callq 0x3c68
addq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
movq %r15, %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3130
incl %r13d
jmp 0x3d25
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x44a4
jmp 0x3dc6
jmp 0x3dc3
jmp 0x3dc3
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x3130
jmp 0x3dc6
movq %rax, %r14
movq %rbx, %rdi
callq 0x44ca
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::tokenizeReviews(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> Parser::tokenizeReviews(string line){
	vector<string> parts;
	vector<string> aux;
	boost::split(parts, line, boost::is_any_of(this->wordDelimeters));

	for (unsigned int i=0; i< parts.size(); i++){
		if (parts[i].size()==0)
			parts.erase(parts.begin()+i);
		parts[i] = noFrontSpaces(parts[i]);
	}
	string word;
	BOOST_FOREACH(word,parts)
	{
		if (word != "") aux.push_back(word);
	}
	return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
addq $0x28, %rsi
leaq -0x68(%rbp), %rdi
callq 0x4473
movq %r13, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rdx
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x43e7
leaq -0x68(%rbp), %rdi
callq 0x44a4
xorl %ebx, %ebx
leaq -0x88(%rbp), %r13
movl %ebx, %ebx
movq -0x50(%rbp), %r14
movq -0x48(%rbp), %r12
movq %r12, %rax
subq %r14, %rax
sarq $0x5, %rax
cmpq %rbx, %rax
jbe 0x3ec4
movq %rbx, %r15
shlq $0x5, %r15
cmpq $0x0, 0x8(%r14,%r15)
je 0x3e6b
leaq -0xa8(%rbp), %r12
jmp 0x3e85
addq %r15, %r14
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x44c0
leaq -0xa8(%rbp), %r12
movq -0x50(%rbp), %r14
addq %r15, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x3300
movq %r13, %rdi
movq %r12, %rdx
callq 0x3c68
addq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x32b0
movq %r13, %rdi
callq 0x3130
movq %r12, %rdi
callq 0x3130
incl %ebx
jmp 0x3e3a
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x88(%rbp), %r15
leaq 0x515f(%rip), %rbx      # 0x9041
movq -0x30(%rbp), %r13
cmpq %r12, %r14
je 0x3f16
movq %r15, %rdi
movq %r14, %rsi
callq 0x3170
movq %r15, %rdi
movq %rbx, %rsi
callq 0x44f5
testb %al, %al
je 0x3f10
movq %r13, %rdi
movq %r15, %rsi
callq 0x4502
addq $0x20, %r14
jmp 0x3ee6
leaq -0x88(%rbp), %rdi
callq 0x3130
leaq -0x50(%rbp), %rdi
callq 0x44ca
movq %r13, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x44a4
jmp 0x3f6b
movq %rax, %r14
jmp 0x3f80
jmp 0x3f68
jmp 0x3f71
movq %rax, %r14
leaq -0xa8(%rbp), %rdi
callq 0x3130
jmp 0x3f6b
movq %rax, %r14
movq -0x30(%rbp), %r13
jmp 0x3f80
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0x3130
movq %r13, %rdi
callq 0x44ca
leaq -0x50(%rbp), %rdi
callq 0x44ca
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> Parser::tokenize(string line, string newDelimiters){
	vector<string> parts;
	boost::split(parts, line, boost::is_any_of(newDelimiters));

	for (unsigned int i=0; i< parts.size(); i++){
		if (parts[i].size()==0)
			parts.erase(parts.begin()+i);
		parts[i] = noFrontSpaces(parts[i]);
	}
	return parts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x40(%rbp), %rdi
movq %rcx, %rsi
callq 0x4473
leaq -0x40(%rbp), %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43e7
leaq -0x40(%rbp), %rdi
callq 0x44a4
xorl %r13d, %r13d
leaq -0x60(%rbp), %r14
leaq -0x80(%rbp), %r15
movl %r13d, %r13d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x405a
movq %r13, %r12
shlq $0x5, %r12
cmpq $0x0, 0x8(%rsi,%r12)
jne 0x4021
addq %r12, %rsi
movq %rbx, %rdi
callq 0x44c0
movq (%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x3300
movq %r15, %rdi
movq %r14, %rdx
callq 0x3c68
addq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
movq %r15, %rdi
callq 0x3130
movq %r14, %rdi
callq 0x3130
incl %r13d
jmp 0x3fee
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x44a4
jmp 0x408f
jmp 0x408c
jmp 0x408c
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x3130
jmp 0x408f
movq %rax, %r14
movq %rbx, %rdi
callq 0x44ca
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::lastLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Parser::lastLine(string line) {
	vector<string> lines = this->tokenize(line, "\n.");
	while (lines[lines.size()-1].size() == 0) {
		lines.pop_back();
	}

	string l = lines[lines.size()-1];
	return noFrontSpaces(l);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq -0xa0(%rbp), %rdi
movq %rdx, %rsi
callq 0x3300
leaq 0x4f85(%rip), %rsi      # 0x904a
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x3110
leaq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
leaq -0x80(%rbp), %rcx
callq 0x3f9a
leaq -0x80(%rbp), %rdi
callq 0x3130
leaq -0xa0(%rbp), %rdi
callq 0x3130
movq -0x18(%rbp), %rsi
cmpq $0x0, -0x18(%rsi)
jne 0x4113
addq $-0x20, %rsi
movq %rsi, -0x18(%rbp)
movq %rsi, %rdi
jmp 0x40f6
addq $-0x20, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3300
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3300
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3c68
leaq -0x60(%rbp), %rdi
callq 0x3130
leaq -0x40(%rbp), %rdi
callq 0x3130
leaq -0x20(%rbp), %rdi
callq 0x44ca
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3130
jmp 0x4172
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3130
jmp 0x4180
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x44ca
jmp 0x41a8
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3130
jmp 0x419c
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::isSwearing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool Parser::isSwearing(string word, int minChars) {
	bool s = false;
	int counter = 0;

	for (unsigned int i=0; i< word.size(); i++) {
		for (unsigned int j=0; j< this->swearingChars.size(); j++) {
			if (word[i] == this->swearingChars[j])
				counter ++;
		}
	}
	if (counter >= minChars)
		s = true;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x8(%rsi), %rax
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %rdi
subq %rcx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %r9d, %r9d
cmpq %r9, %rax
jbe 0x41fa
xorl %r10d, %r10d
movl %r10d, %r10d
cmpq %r10, %rdi
jbe 0x41f5
movq (%rsi), %r11
movb (%r11,%r9), %r11b
xorl %ebx, %ebx
cmpb (%rcx,%r10), %r11b
sete %bl
addl %ebx, %r8d
incl %r10d
jmp 0x41d5
incl %r9d
jmp 0x41ca
cmpl %edx, %r8d
setge %al
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::noSwearing(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
vector<string> Parser::noSwearing(vector<string> tokens) {

	for (unsigned int i=0; i< tokens.size(); i++){
		if (this->isSwearing(tokens[i], 3)) // cantidad de chars extraños para considerarlo un insulto
			tokens.erase(tokens.begin()+i);
		//tokens[i] = noFrontSpaces(parts[i]);
	}

	return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
xorl %r14d, %r14d
leaq -0x58(%rbp), %r12
movl %r14d, %r14d
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %rdx, %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
cmpq %r14, %rcx
jbe 0x4284
movq %r14, %r15
shlq $0x5, %r15
addq %r15, %rsi
movq %r12, %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
movq %r12, %rsi
pushq $0x3
popq %rdx
callq 0x41b0
movl %eax, %r13d
movq %r12, %rdi
callq 0x3130
testb %r13b, %r13b
je 0x427f
addq (%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x44c0
incl %r14d
jmp 0x4227
movq -0x30(%rbp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::isFractionScore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Parser::isFractionScore(string s) {
	int counter  = 0;
	for (unsigned int i=0; i< s.size(); i++) {
		if (s[i]=='/')
			counter ++;
	}

	return (counter==1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rcx
xorl %eax, %eax
xorl %edx, %edx
movl %edx, %edx
cmpq %rdx, %rcx
jbe 0x42da
movq (%rsi), %rdi
xorl %r8d, %r8d
cmpb $0x2f, (%rdi,%rdx)
sete %r8b
addl %r8d, %eax
incl %edx
jmp 0x42be
cmpl $0x1, %eax
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/Parser.cpp
// Function: Parser::fractionScore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
float Parser::fractionScore(string s) {
	float f = 0.5;
	if (isFractionScore(s)){
		vector<string> fs = tokenize(s, "/");
		if (fs.size()==2) {
			std::string::size_type sz;
			float f_aux = 0.0;//std::stof(fs[0], &sz)/std::stof(fs[1], &sz);
			if ((f_aux >= 0)&&(f_aux <= 1)) {
				f = f_aux;
			}
		}
	}

	return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0x3300
movq %r14, %rsi
callq 0x42b2
movl %eax, %r15d
movq %r14, %rdi
callq 0x3130
testb %r15b, %r15b
je 0x438d
leaq -0x78(%rbp), %rdi
movq %rbx, %rsi
callq 0x3300
leaq 0x4d19(%rip), %rsi      # 0x9048
leaq -0x58(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3110
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x3f9a
leaq -0x58(%rbp), %rdi
callq 0x3130
leaq -0x78(%rbp), %rdi
callq 0x3130
movq -0x30(%rbp), %rax
subq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
cmpq $0x40, %rax
je 0x4378
movss 0x4cb4(%rip), %xmm0     # 0x902c
movss %xmm0, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x44ca
movss -0x20(%rbp), %xmm0
jmp 0x4395
movss 0x4c97(%rip), %xmm0     # 0x902c
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3130
jmp 0x43b4
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/HashingPerceptron.cpp
// Function: HashingPerceptron::getVector(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
vector<unsigned int> HashingPerceptron::getVector(vector<string> tokenized_words)
{
	vector<unsigned int> vec_pos;
	vector<string> phrase_vec;
	//Primero debo generar las frases
	for(unsigned int i=0; i < tokenized_words.size(); i++)
	{
		string str = tokenized_words[i];
		phrase_vec.push_back(str);

		for (int j=1; j< this->phrase_lenght; j++)
		{
			if (i+j < tokenized_words.size())
			{
				if (tokenized_words[i+j] != "")
				{
					str.append(" ");
					str.append(tokenized_words[i+j]);
					phrase_vec.push_back(str);
				}
			}
		}
	}
	hash<string> hash_fn;
	for(unsigned int i=0; i < phrase_vec.size(); i++)
	{
		unsigned int pos = hash_fn(phrase_vec[i])%this->hash_size;
		vec_pos.push_back(pos);
	}
	return vec_pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, -0x40(%rbp)
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, -0x38(%rbp)
movups %xmm0, (%rdi)
leaq -0x60(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %ebx, %ebx
leaq -0x80(%rbp), %r12
movl %ebx, %eax
movq (%r15), %rsi
movq 0x8(%r15), %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
cmpq %rax, %rcx
jbe 0x67fe
shlq $0x5, %rax
addq %rax, %rsi
movq %r12, %rdi
callq 0x3300
leaq -0x60(%rbp), %rdi
movq %r12, %r14
movq %r12, %rsi
callq 0x4502
pushq $0x1
popq %r13
movq -0x40(%rbp), %rax
movslq 0x30(%rax), %rax
cmpq %rax, %r13
jge 0x67eb
leal (%rbx,%r13), %r12d
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x67e6
shlq $0x5, %r12
addq %r12, %rdi
leaq 0x288d(%rip), %rsi      # 0x9041
callq 0x44f5
testb %al, %al
je 0x67e6
movq %r14, %rdi
leaq 0x2b86(%rip), %rsi      # 0x934d
callq 0x3420
addq (%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x3440
leaq -0x60(%rbp), %rdi
movq %r14, %rsi
callq 0x4502
incq %r13
jmp 0x6782
movq %r14, %r12
movq %r14, %rdi
callq 0x3130
incq %rbx
jmp 0x6747
xorl %r12d, %r12d
leaq -0x29(%rbp), %rbx
leaq -0x80(%rbp), %r15
movl %r12d, %r12d
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x6852
movq %r12, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x726e
movq -0x40(%rbp), %rcx
movl 0x34(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, -0x80(%rbp)
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x728e
incl %r12d
jmp 0x6809
leaq -0x60(%rbp), %rdi
callq 0x44ca
movq -0x38(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6872
jmp 0x6877
movq %rax, %rbx
jmp 0x6883
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3130
leaq -0x60(%rbp), %rdi
callq 0x44ca
movq -0x38(%rbp), %rdi
callq 0x75b8
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/aleperno[P]Datos/HashingPerceptron.cpp
// Function: HashingPerceptron::dot_product(std::vector<unsigned int, std::allocator<unsigned int>>)
float HashingPerceptron::dot_product(vector<unsigned int> vec)
{
	float count = 0;
	for (unsigned int i = 0; i < vec.size(); i++)
	{
		count += this->weights[vec[i]];
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
movq 0x38(%rdi), %rdx
xorl %esi, %esi
xorps %xmm0, %xmm0
movl %esi, %esi
cmpq %rsi, %rcx
jbe 0x6c28
movl (%rax,%rsi,4), %edi
addss (%rdx,%rdi,4), %xmm0
incl %esi
jmp 0x6c15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::groups_collection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::add_group(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
bool add_group(const std::string& group_name, const std::set<T>& set)
   {
      const auto itr = groups.find(group_name);

      if (itr != groups.end())
      {
         return false;
      }

      groups[group_name] = set;
      return true;
   }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x1121ae
movq %rax, %r14
leaq 0x8(%r12), %r13
cmpq %r13, %rax
jne 0x110bc8
movq %r12, %rdi
movq %r15, %rsi
callq 0x112148
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1125da
cmpq %r13, %r14
sete %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::create<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator() (parameter_list_t parameters) override
   {
      const std::string group_name = to_str(string_t(parameters[0]));

      if (
           !groups_.contains(group_name) &&
           !groups_.add_group(group_name, {})
         )
      {
         return T(0);
      }

      auto ptr = groups_.get(group_name);
      const std::size_t ptr_size = sizeof(ptr);
      T result = T(0);

      std::memcpy(reinterpret_cast<char*>(&result ),
                  reinterpret_cast<char*>(&ptr),
                  ptr_size);

      return result;
   }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x50(%rsp), %rsi
movq %rax, (%rsi)
movq (%rax), %rax
movq %rax, 0x8(%rsi)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x112ecc
addq $0x48, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x112ef0
testb %al, %al
jne 0x112a11
leaq 0x58(%rsp), %rax
pxor %xmm0, %xmm0
movdqa %xmm0, -0x8(%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %rbx, %rdi
callq 0x110b8e
movl %eax, %ebp
leaq 0x50(%rsp), %rdi
callq 0x2372c0
pxor %xmm0, %xmm0
testb %bpl, %bpl
je 0x112a3f
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x10e2a0
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x112efe
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x10e5e8
movq %rbx, %xmm0
movq %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x10e5e8
movsd 0x8(%rsp), %xmm0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2372c0
jmp 0x112a84
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x10e5e8
jmp 0x112a84
jmp 0x112a81
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x10e5e8
movq %rbx, %rdi
callq 0x10e310
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_groups_examples.cpp
// Function: groups_impl::groups_collection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ptr_t get(const std::string group_name)
   {
      auto itr = groups.find(group_name);
      if (itr == groups.end())
      {
         return nullptr;
      }
      return &(itr->second);
   }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1121ae
addq $0x8, %rbx
leaq 0x40(%rax), %rdx
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovneq %rdx, %rcx
movq %rcx, %rax
popq %rbx
retq
nop