LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::suiteOrderComparator(doctest::detail::TestCase const*, doctest::detail::TestCase const*)
bool suiteOrderComparator(const TestCase* lhs, const TestCase* rhs) {
        const int res = std::strcmp(lhs->m_test_suite, rhs->m_test_suite);
        if(res != 0)
            return res < 0;
        return fileOrderComparator(lhs, rhs);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq 0x28(%rsi), %rsi
callq 0x54d0
testl %eax, %eax
je 0xc1eb
shrl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc177
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::nameOrderComparator(doctest::detail::TestCase const*, doctest::detail::TestCase const*)
bool nameOrderComparator(const TestCase* lhs, const TestCase* rhs) {
        const int res = std::strcmp(lhs->m_name, rhs->m_name);
        if(res != 0)
            return res < 0;
        return suiteOrderComparator(lhs, rhs);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq 0x20(%rsi), %rsi
callq 0x54d0
testl %eax, %eax
je 0xc223
shrl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc1c5
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::FatalConditionHandler::reset()
static void reset() {
            if(isSet) {
                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
                for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
                    sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
                }
                // Return the old stack
                sigaltstack(&oldSigStack, nullptr);
                isSet = false;
            }
        }

// Assembly:
cmpb $0x1, 0x1a7f7(%rip)     # 0x26a30
jne 0xc28a
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1a809(%rip), %rbx     # 0x26a50
xorl %r14d, %r14d
leaq 0x1960f(%rip), %r15     # 0x25860
movl (%r14,%r15), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5460
addq $0x10, %r14
addq $0x98, %rbx
cmpq $0x60, %r14
jne 0xc251
leaq 0x1a7c1(%rip), %rdi     # 0x26a38
xorl %esi, %esi
callq 0x5680
movb $0x0, 0x1a7ab(%rip)     # 0x26a30
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::registerReporterImpl(char const*, int, doctest::IReporter* (*)(doctest::ContextOptions const&), bool)
void registerReporterImpl(const char* name, int priority, reporterCreatorFunc c, bool isReporter) {
        if(isReporter)
            getReporters().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
        else
            getListeners().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0xc3ad
callq 0xc14b
leaq 0x10(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r14, %rdi
callq 0x5170
movq %rax, %r12
movq %r15, %rdi
movl %r12d, %esi
callq 0x640c
movl %r12d, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5300
movl -0x8(%r15), %eax
leaq 0x28(%rsp), %rsi
movl %eax, (%rsi)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x10(%r15), %rax
movq %rax, 0x18(%rsi)
movb $0x0, (%r15)
movb $0x17, 0x17(%r15)
movq %rbx, 0x20(%rsi)
leaq 0x1a61a(%rip), %rdi     # 0x269c0
callq 0x1943e
jmp 0xc413
callq 0xc161
leaq 0x10(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r14, %rdi
callq 0x5170
movq %rax, %r12
movq %r15, %rdi
movl %r12d, %esi
callq 0x640c
movl %r12d, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5300
movl -0x8(%r15), %eax
leaq 0x28(%rsp), %rsi
movl %eax, (%rsi)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x10(%r15), %rax
movq %rax, 0x18(%rsi)
movb $0x0, (%r15)
movb $0x17, 0x17(%r15)
movq %rbx, 0x20(%rsi)
leaq 0x1a5ea(%rip), %rdi     # 0x269f8
callq 0x1943e
cmpb $0x0, 0x47(%rsp)
jns 0xc429
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xc429
callq 0x5480
cmpb $0x0, 0x27(%rsp)
jns 0xc43f
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xc43f
callq 0x5480
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc44e
movq %rax, %rbx
cmpb $0x0, 0x47(%rsp)
jns 0xc467
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xc467
callq 0x5480
cmpb $0x0, 0x27(%rsp)
jns 0xc47d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xc47d
callq 0x5480
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::parseOptionImpl(int, char const* const*, char const*, doctest::String*)
bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String* value) {
        // going from the end to the beginning and stopping on the first occurrence from the end
        for(int i = argc; i > 0; --i) {
            auto index = i - 1;
            auto temp = std::strstr(argv[index], pattern);
            if(temp && (value || strlen(temp) == strlen(pattern))) { //!OCLINT prefer early exits and continue
                // eliminate matches in which the chars before the option are not '-'
                bool noBadCharsFound = true;
                auto curr            = argv[index];
                while(curr != temp) {
                    if(*curr++ != '-') {
                        noBadCharsFound = false;
                        break;
                    }
                }
                if(noBadCharsFound && argv[index][0] == '-') {
                    if(value) {
                        // parsing the value of an option
                        temp += strlen(pattern);
                        const unsigned len = strlen(temp);
                        if(len) {
                            *value = temp;
                            return true;
                        }
                    } else {
                        // just a flag - no value
                        return true;
                    }
                }
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
testl %edi, %edi
setg %bl
jle 0xdd6a
movq %rcx, %r14
movq %rdx, %r15
movl %edi, %r12d
movq %rcx, (%rsp)
movq 0x20(%rsp), %rax
movq -0x8(%rax,%r12,8), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x50a0
testq %rax, %rax
je 0xdd55
movq %rax, %r13
testq %r14, %r14
jne 0xdd20
movq %r13, %rdi
callq 0x5170
movq %rax, %r14
movq %r15, %rdi
callq 0x5170
cmpq %rax, %r14
movq (%rsp), %r14
jne 0xdd55
movq %rbp, %rax
cmpq %r13, %rax
je 0xdd33
cmpb $0x2d, (%rax)
leaq 0x1(%rax), %rax
je 0xdd23
jmp 0xdd55
cmpb $0x2d, (%rbp)
jne 0xdd55
testq %r14, %r14
je 0xdd6a
movq %r15, %rdi
callq 0x5170
addq %rax, %r13
movq %r13, %rdi
callq 0x5170
testl %eax, %eax
jne 0xdd7e
leaq -0x1(%r12), %rax
cmpq $0x2, %r12
setge %bl
movq %rax, %r12
jge 0xdce2
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x5170
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x640c
movl %r14d, %edx
movq (%rsp), %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0x5300
cmpq %r14, %r15
je 0xdde0
cmpb $0x0, 0x17(%r14)
jns 0xddc4
movq (%r14), %rdi
testq %rdi, %rdi
je 0xddc4
callq 0x5480
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%r14)
movb $0x0, 0x8(%rsp)
movb $0x17, 0x1f(%rsp)
cmpb $0x0, 0x1f(%rsp)
jns 0xdd6a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xdd6a
callq 0x5480
jmp 0xdd6a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x5520
testl %eax, %eax
jne 0xfa71
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc782(%rip), %rsi      # 0x1c100
leaq 0xc784(%rip), %rdx      # 0x1c109
leaq 0x38(%rsp), %rdi
callq 0x16ac2
addq $0x8, %r15
movq %r15, 0x10(%rsp)
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x1088a
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc71c(%rip), %rsi      # 0x1c0d1
leaq 0xc71a(%rip), %rdx      # 0x1c0d6
leaq 0x18(%rsp), %rdi
callq 0x16ac2
movq 0x10(%rsp), %rdi
movzbl 0x18(%r14), %edx
leaq 0x18(%rsp), %rsi
callq 0x11200
cmpb $0x0, 0x17(%r14)
jns 0xf9e4
movq (%r14), %r14
leaq 0x58(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x16a84
leaq 0x10(%rsp), %rdi
leaq 0x58(%rsp), %rsi
movl $0x1, %edx
callq 0x117da
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfa25
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0xfa3c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53d0
leaq 0x10(%rsp), %rdi
callq 0x10758
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xfa5d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x52d0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x5230
movq %rax, %r14
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfa9d
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xfa9d
jmp 0xfa9a
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0xfabb
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xfabb
jmp 0xfab8
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x10758
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xfae1
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xfae1
movq %rax, %r14
movq %rbx, %rdi
callq 0x52d0
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xc5ba(%rip), %rsi      # 0x1c0d7
leaq 0xc5ba(%rip), %rdx      # 0x1c0de
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x16ac2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1088a
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xc374(%rip), %rsi      # 0x1bec0
leaq 0xc371(%rip), %rdx      # 0x1bec4
movq %rsp, %rdi
callq 0x16ac2
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10ee6
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0xc343(%rip), %rsi      # 0x1bebc
leaq 0xc344(%rip), %rdx      # 0x1bec4
leaq 0x48(%rsp), %rdi
callq 0x16ac2
movq %r13, %r12
movq 0x18(%r14), %rdi
callq 0x6ec0
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x10fc6
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xbe3c(%rip), %rsi      # 0x1b9f2
leaq 0xbe39(%rip), %rdx      # 0x1b9f6
leaq 0x28(%rsp), %rdi
callq 0x16ac2
movq 0x78(%r15), %rcx
xorl %eax, %eax
cmpb $0x0, 0x7d(%rcx)
jne 0xfbd7
movl 0x20(%r14), %eax
leaq 0x24(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x11120
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xfc02
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xfc19
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xfc34
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0xfc4b
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x1090a
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xfc86
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xfc86
jmp 0xfc83
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xfca7
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xfca7
jmp 0xfca1
movq %r13, %r12
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xfccc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xfccc
jmp 0xfcc6
movq %r13, %r12
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0xfce3
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x78(%rdi), %rax
cmpb $0x0, 0x7f(%rax)
jne 0x106f3
movq %rdi, %rbx
callq 0x11290
addq $0x8, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcbc7(%rip), %rsi      # 0x1d278
leaq 0xcbc7(%rip), %rdx      # 0x1d27f
movq %rsp, %r14
movq %r14, %rdi
callq 0x16ac2
leaq 0xae6c(%rip), %rdx      # 0x1b536
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10fc6
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x106eb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x10770
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x10716
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10960
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rcx
addq $-0x2, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x53e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5450
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x107c2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x40(%rbx), %rdi
cmpb $0x1, (%rbx)
jne 0x107e1
leaq 0xb80f(%rip), %rsi      # 0x1bfe1
movl $0x2, %edx
callq 0x5410
movb $0x0, (%rbx)
jmp 0x1082d
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x5410
movq %rax, %r14
leaq 0xb7ec(%rip), %rsi      # 0x1bfe4
movl $0x2, %edx
movq %rax, %rdi
callq 0x5410
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq %r14, %rdi
callq 0x5410
leaq 0xb7c2(%rip), %rsi      # 0x1bfe2
movl $0x1, %edx
movq %rax, %rdi
callq 0x5410
movq 0x40(%rbx), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5390
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5260
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x1087c
movq (%rax), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1090a
movq %rbx, %rdi
callq 0x10960
movq 0x40(%rbx), %rdi
leaq 0x20(%rbx), %r15
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x5410
leaq 0xf(%rsp), %rsi
movb $0x3c, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x5410
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x5410
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x18164
leaq 0xbc4d(%rip), %rsi      # 0x1c53f
movq %r15, %rdi
callq 0x5690
movb $0x1, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
callq 0x161d8
movq %fs:-0x28, %r13
subq %fs:-0x30, %r13
shrq $0x3, %r13
testl %r13d, %r13d
je 0x11a0c
callq 0xc2ae
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5290
testl %r13d, %r13d
jle 0x119ee
leaq 0x18(%rsp), %r12
addq $0x8, %rbx
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x28(%rsp), %rax
movq (%rax,%rbp,8), %rdi
movq (%rdi), %rax
leaq 0x60(%rsp), %rsi
callq *0x10(%rax)
movq %r12, 0x8(%rsp)
movq %r15, %rdi
leaq 0xa7fc(%rip), %rsi      # 0x1c12b
leaq 0xa7f9(%rip), %rdx      # 0x1c12f
callq 0x16ac2
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1088a
leaq 0x30(%rsp), %r14
movq %r14, %rdi
leaq 0x68(%rsp), %rsi
callq 0x5560
movq %rsp, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x117da
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x11988
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rsp, %rdi
callq 0x10758
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x119a7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %r12, 0x8(%rsp)
movq %r15, %rdi
leaq 0x9c52(%rip), %rdx      # 0x1b608
movq %rdx, %rsi
callq 0x16ac2
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0x5530
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x119e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53d0
incq %rbp
cmpq %rbp, %r13
jne 0x1190c
movq 0x1459b(%rip), %rsi     # 0x25f90
leaq 0x50(%rsp), %rdi
callq 0x52c0
leaq 0xd0(%rsp), %rdi
callq 0x5120
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11a52
jmp 0x11a52
jmp 0x11a24
movq %rax, %rbx
jmp 0x11a48
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x11a48
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rsp, %rdi
callq 0x10758
jmp 0x11a5a
movq %rax, %rbx
jmp 0x11a71
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x11a71
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x14518(%rip), %rsi     # 0x25f90
leaq 0x50(%rsp), %rdi
callq 0x52c0
leaq 0xd0(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
leaq 0x98(%rdi), %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x5580
imulq $0xf4240, (%r12), %rax  # imm = 0xF4240
addq 0x8(%r12), %rax
subq 0x78(%r15), %rax
movq %rax, %xmm0
punpckldq 0x8c0d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x8c15(%rip), %xmm0     # 0x1b2b0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd 0x8c11(%rip), %xmm1     # 0x1b2c0
movapd %xmm1, %xmm0
cmpltsd 0x8c24(%rip), %xmm0     # 0x1b2e0
andnpd %xmm1, %xmm0
movq 0xa0(%r15), %rax
movlpd %xmm0, -0x38(%rax)
movsd 0xb0(%r15), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0xb0(%r15)
leaq 0x80(%r15), %r12
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x184c0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1346c
leaq 0x48(%rsp), %rdi
callq 0x168e6
movq 0x80(%r15), %rsi
movq %r12, %rdi
callq 0x18476
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x5580
imulq $0xf4240, (%r12), %rax  # imm = 0xF4240
addq 0x8(%r12), %rax
movq %rax, 0x78(%r15)
cmpb $0x0, 0x17(%r14)
movq %r14, %rdi
jns 0x1274a
movq (%r14), %rdi
callq 0x6ec0
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x16a84
movq 0x20(%r14), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x16a84
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x130b8
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x127a1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53d0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x127bc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53d0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x127ed
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0x127ed
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1281c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0x1281c
movq %rax, %rbx
jmp 0x1281c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x168e6
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x18(%rbx), %rsi
callq 0x187fc
movq $0x0, 0x30(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x157bb
movq 0x60(%rbx), %rax
cmpb $0x1, 0x6c(%rax)
jne 0x157c5
movq 0x68(%rbx), %rax
cmpb $0x0, 0x3a(%rax)
je 0x157cb
popq %rbx
popq %r14
popq %r15
retq
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x5520
testl %eax, %eax
jne 0x15830
movq %rbx, %rdi
callq 0x15cb2
movq 0x10(%r15), %rsi
movl 0x18(%r15), %edx
movq (%rbx), %rax
leaq 0x6d4b(%rip), %rcx      # 0x1c540
movq %rbx, %rdi
callq *0x70(%rax)
movzbl 0x28(%r15), %esi
movl 0x8(%r15), %edx
xorl $0x1, %esi
movq %rbx, %rdi
callq 0x16050
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x1385e
movq %rbx, %rdi
callq 0x160f2
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x52d0
movl %eax, %edi
callq 0x5230
movq %rax, %rbx
movq %r14, %rdi
callq 0x52d0
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq 0x68(%rdi), %rax
cmpb $0x0, 0x3a(%rax)
je 0x15867
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r15
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x5520
testl %eax, %eax
jne 0x1595d
movq %r14, %rdi
callq 0x15cb2
movq 0x18(%r15), %rsi
movl 0x20(%r15), %edx
movq (%r14), %rax
leaq 0x6ca5(%rip), %rcx      # 0x1c540
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 0x6a32
movl 0x24(%r15), %eax
testb $0x1, %al
jne 0x158dd
testb $0x2, %al
jne 0x158e6
testb $0x4, %al
leaq 0x5d38(%rip), %rax      # 0x1b608
leaq 0x5c53(%rip), %r13      # 0x1b52a
cmoveq %rax, %r13
jmp 0x158ed
leaq 0x7bcc(%rip), %r13      # 0x1d4b0
jmp 0x158ed
leaq 0x5c43(%rip), %r13      # 0x1b530
movq %r13, %rdi
callq 0x5170
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5410
leaq 0x7b87(%rip), %rsi      # 0x1d491
movl $0x2, %edx
movq %r12, %rdi
callq 0x5410
movq 0x8(%r14), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x6a32
movq %r12, %rdi
movq %r15, %rsi
callq 0x69e0
leaq 0x72d4(%rip), %rsi      # 0x1cc0b
movl $0x1, %edx
movq %r12, %rdi
callq 0x5410
movq %r14, %rdi
callq 0x160f2
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x52d0
movl %eax, %edi
callq 0x5230
movq %rax, %r14
movq %rbx, %rdi
callq 0x52d0
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x161d8
movq %fs:-0x28, %r12
subq %fs:-0x30, %r12
shrq $0x3, %r12
testl %r12d, %r12d
je 0x161b5
callq 0xc2ae
movq %rax, %r14
movq 0x8(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x6a32
leaq 0x615a(%rip), %rsi      # 0x1c29b
movl $0xa, %edx
movq %r15, %rdi
callq 0x5410
testl %r12d, %r12d
jle 0x161b5
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq 0x63d3(%rip), %rbp      # 0x1c537
leaq 0x6aa0(%rip), %r15      # 0x1cc0b
testq %r13, %r13
movq %rbp, %rsi
leaq 0x5490(%rip), %rax      # 0x1b608
cmoveq %rax, %rsi
movq 0x8(%rbx), %rdi
movl $0xa, %edx
cmoveq %r13, %rdx
callq 0x5410
movq (%r14,%r13,8), %rdi
movq 0x8(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rbx), %rdi
movl $0x1, %edx
movq %r15, %rsi
callq 0x5410
incq %r13
cmpq %r13, %r12
jne 0x1616b
movq 0x8(%rbx), %rdi
leaq 0x6a4b(%rip), %rsi      # 0x1cc0b
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5410
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, (%rsp)
cmpl $0x2, %edx
jl 0x2e55f
movq %rsi, %r15
leal -0x1(%rdx), %eax
movslq %eax, %r12
movl %edx, %r13d
movl $0x1, %r14d
movsbl %cl, %ebp
movq (%r15,%r14,8), %rsi
movq %rbx, %rdi
callq 0x21d0
cmpq %r12, %r14
jge 0x2e557
movq %rbx, %rdi
movl %ebp, %esi
callq 0x20f0
incq %r14
cmpq %r14, %r13
jne 0x2e53c
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x2e584
movq (%rbx), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x2170
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x2e56e
movq (%rsp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rsi
cmpq %rsi, %rdx
je 0x2e5a7
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2e5ad
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rsi, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x2, %edi
jl 0x2e688
movq %rsi, %r14
movl %edi, %ebx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe6b0(%rip), %rdx      # 0x3ccad
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x2dd92
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movl %ebx, %edx
movl $0x20, %ecx
movq %r15, %r8
callq 0x2e510
leaq 0x22ae5(%rip), %rdi     # 0x51110
leaq 0x28(%rsp), %rsi
callq 0x2e730
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e653
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2130
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2e66a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
testq %rbx, %rbx
je 0x2e69d
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq 0x2295a(%rip), %rdi     # 0x50fd8
callq 0x2150
movq %rax, %rbx
jmp 0x2e6b8
movq 0x22949(%rip), %rbx     # 0x50fd8
leaq 0x141cc(%rip), %rsi     # 0x42862
movl $0x43, %edx
jmp 0x2e6b0
movq 0x22934(%rip), %rbx     # 0x50fd8
leaq 0x14195(%rip), %rsi     # 0x42840
movl $0x21, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e710
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2130
jmp 0x2e710
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2e727
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
leaq -0x238(%rbp), %rdi
movl $0x18, %edx
callq 0x32e0
leaq -0x1b8(%rbp), %rdi
callq 0x30c0
testb %al, %al
je 0x3df6
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
jne 0x3dea
leaq 0x48(%rbx), %r14
leaq -0x238(%rbp), %r15
leaq -0x21(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x32f0
movb -0x21(%rbp), %al
cmpb $0xa, %al
je 0x3dd5
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x3dca
movb %al, (%rsi)
incq 0x50(%rbx)
jmp 0x3dd5
movq %r14, %rdi
movq %r12, %rdx
callq 0x4c4a
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
je 0x3da6
leaq -0x238(%rbp), %rdi
callq 0x3070
leaq -0x238(%rbp), %rdi
callq 0x30a0
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e14
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x9d70(%rip), %rax      # 0xdbf8
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x619f(%rip), %rcx      # 0xa06c
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3360
movq 0x30(%r15), %rdx
leaq 0x6184(%rip), %rcx      # 0xa06e
movl $0x7, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3360
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3f1d
callq 0x3210
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x3f2a
callq 0x3210
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3f37
callq 0x3210
movq %r15, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x3cb2
movq (%r14), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x3fe0
cmpl $0xa, %eax
jne 0x3ffc
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x30b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3160
jmp 0x3fd0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x401a
callq 0x3210
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
addq %rax, %rcx
leaq -0x80(%rbp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
leaq -0x40(%rbp), %rdi
callq 0x4d3c
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x4986
cmpq $0x11, -0x30(%rbp)
jb 0x408f
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x408f
callq 0x32c0
movq (%rbx), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x413d
movl $0x1, %r13d
xorl %r12d, %r12d
leaq -0x60(%rbp), %r14
leaq -0x80(%rbp), %r15
shlq $0x5, %r12
cmpq $0x0, 0x8(%rsi,%r12)
jne 0x40c4
addq %r12, %rsi
movq %rbx, %rdi
callq 0x6928
movq (%rbx), %rax
leaq -0x50(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x3cb2
movq %r15, %rdi
movq %r14, %rdx
callq 0x3faa
addq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x410e
callq 0x3210
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4120
callq 0x3210
movl %r13d, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
incl %r13d
cmpq %r12, %rax
ja 0x40ad
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpq $0x11, -0x30(%rbp)
jb 0x4187
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4187
callq 0x32c0
jmp 0x4187
jmp 0x416d
jmp 0x416d
movq %rax, %r14
jmp 0x4187
movq %rax, %r14
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4187
callq 0x3210
movq %rbx, %rdi
callq 0x4b08
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movq %rdx, %r14
xorl %eax, %eax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq %rax, 0x10(%rdi)
movq %rdi, -0x48(%rbp)
movups %xmm0, (%rdi)
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rcx
addq %rax, %rcx
leaq -0x68(%rbp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
leaq -0x80(%rbp), %rdi
callq 0x4d3c
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movq %r14, %rsi
movl $0x1, %ecx
callq 0x4986
cmpq $0x11, -0x70(%rbp)
jb 0x420d
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x420d
callq 0x32c0
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r12
cmpq %r14, %r12
je 0x42cf
movl $0x1, %ebx
xorl %r15d, %r15d
leaq -0x68(%rbp), %r13
shlq $0x5, %r15
cmpq $0x0, 0x8(%r14,%r15)
jne 0x4245
addq %r15, %r14
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x6928
movq -0x40(%rbp), %rax
leaq -0x90(%rbp), %r12
movq %r12, -0xa0(%rbp)
movq (%rax,%r15), %rsi
movq 0x8(%rax,%r15), %rdx
addq %rsi, %rdx
leaq -0xa0(%rbp), %r14
movq %r14, %rdi
callq 0x3cb2
movq %r13, %rdi
movq %r14, %rdx
callq 0x3faa
addq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x32b0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x429e
callq 0x3210
movq -0xa0(%rbp), %rdi
cmpq %r12, %rdi
je 0x42af
callq 0x3210
movl %ebx, %r15d
movq -0x40(%rbp), %r14
movq -0x38(%rbp), %r12
movq %r12, %rax
subq %r14, %rax
sarq $0x5, %rax
incl %ebx
cmpq %r15, %rax
ja 0x422a
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
cmpq %r12, %r14
je 0x4323
leaq -0x68(%rbp), %r15
leaq 0x5d79(%rip), %rbx      # 0xa06d
movq %r15, %rdi
movq %r14, %rsi
callq 0x3160
movq %r15, %rdi
movq %rbx, %rsi
callq 0x30f0
testl %eax, %eax
je 0x431a
movq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x4b56
addq $0x20, %r14
cmpq %r12, %r14
jne 0x42f4
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x4331
callq 0x3210
leaq -0x40(%rbp), %rdi
callq 0x4b08
movq -0x48(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpq $0x11, -0x70(%rbp)
jb 0x4394
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x4394
callq 0x32c0
jmp 0x4394
jmp 0x437b
jmp 0x437b
jmp 0x436d
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
jne 0x438f
jmp 0x4394
movq %rax, %r14
jmp 0x4394
movq %rax, %r14
movq -0xa0(%rbp), %rdi
cmpq %r12, %rdi
je 0x4394
callq 0x3210
movq -0x48(%rbp), %rdi
callq 0x4b08
leaq -0x40(%rbp), %rdi
callq 0x4b08
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
addq %rax, %rcx
leaq -0x80(%rbp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
leaq -0x40(%rbp), %rdi
callq 0x4d3c
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x4986
cmpq $0x11, -0x30(%rbp)
jb 0x441a
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x441a
callq 0x32c0
movq (%rbx), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x44c8
movl $0x1, %r13d
xorl %r12d, %r12d
leaq -0x60(%rbp), %r14
leaq -0x80(%rbp), %r15
shlq $0x5, %r12
cmpq $0x0, 0x8(%rsi,%r12)
jne 0x444f
addq %r12, %rsi
movq %rbx, %rdi
callq 0x6928
movq (%rbx), %rax
leaq -0x50(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x3cb2
movq %r15, %rdi
movq %r14, %rdx
callq 0x3faa
addq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x32b0
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x4499
callq 0x3210
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x44ab
callq 0x3210
movl %r13d, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
incl %r13d
cmpq %r12, %rax
ja 0x4438
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpq $0x11, -0x30(%rbp)
jb 0x4512
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4512
callq 0x32c0
jmp 0x4512
jmp 0x44f8
jmp 0x44f8
movq %rax, %r14
jmp 0x4512
movq %rax, %r14
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x4512
callq 0x3210
movq %rbx, %rdi
callq 0x4b08
movq %r14, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq -0xa0(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0xb0(%rbp), %rdi
callq 0x3cb2
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5b11(%rip), %rsi      # 0xa076
leaq 0x5b0c(%rip), %rdx      # 0xa078
leaq -0x90(%rbp), %rdi
callq 0x4bb0
leaq -0x30(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
leaq -0x90(%rbp), %rcx
callq 0x43ae
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x45a0
callq 0x3210
movq -0xb0(%rbp), %rdi
cmpq %r14, %rdi
jne 0x45e1
jmp 0x45e6
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x45c7
callq 0x3210
jmp 0x45c7
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
cmpq %r14, %rdi
je 0x46b4
callq 0x3210
jmp 0x46b4
callq 0x3210
movq -0x28(%rbp), %rax
cmpq $0x0, -0x18(%rax)
jne 0x4608
leaq -0x20(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
jne 0x45e1
jmp 0x45e6
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x3cb2
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x3cb2
leaq -0x70(%rbp), %rdx
movq %rbx, %rdi
callq 0x3faa
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x465a
callq 0x3210
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x4668
callq 0x3210
leaq -0x30(%rbp), %rdi
callq 0x4b08
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x4698
callq 0x3210
jmp 0x4698
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x46ab
callq 0x3210
jmp 0x46ab
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4b08
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x4718
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x48(%rdi), %rcx
movq 0x50(%rdi), %rdi
movq %rdi, %r8
subq %rcx, %r8
xorl %r10d, %r10d
xorl %r9d, %r9d
cmpq %rcx, %rdi
je 0x4707
movq (%rsi), %r11
movb (%r11,%r10), %r11b
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpb (%rcx,%rbx), %r11b
sete %r14b
addl %r14d, %r9d
incq %rbx
movl %ebx, %r14d
cmpq %r14, %r8
ja 0x46ee
incq %r10
movl %r10d, %r11d
cmpq %r11, %rax
ja 0x46e0
popq %rbx
popq %r14
popq %rbp
jmp 0x471b
xorl %r9d, %r9d
cmpl %edx, %r9d
setge %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq (%rdx), %rdi
movq 0x8(%rdx), %rcx
cmpq %rdi, %rcx
je 0x47c8
movl $0x1, %r15d
xorl %r13d, %r13d
shlq $0x5, %r13
leaq -0x48(%rbp), %r12
movq %r12, -0x58(%rbp)
movq (%rdi,%r13), %rsi
movq 0x8(%rdi,%r13), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x3cb2
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x46bc
movl %eax, %r14d
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0x4799
callq 0x3210
testb %r14b, %r14b
je 0x47ac
addq (%rbx), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6928
movl %r15d, %r13d
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rdi, %rdx
sarq $0x5, %rdx
incl %r15d
cmpq %r13, %rdx
ja 0x4753
movq -0x30(%rbp), %rax
movq %rdi, (%rax)
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq